fix: start a new server if the config is different

AleksandrSl · AleksandrSl · commit cb6c8c3e8796 · 2025-12-14T21:22:51.000+01:00
diff --git a/cmp/compiler/src/translation-server/translation-server.test.ts b/cmp/compiler/src/translation-server/translation-server.test.ts
@@ -0,0 +1,240 @@
+import { describe, expect, it } from "vitest";
+import { hashConfig, stableStringify } from "./translation-server";
+
+describe("stableStringify", () => {
+  describe("consistency - same input produces same output", () => {
+    it("should produce identical output for identical objects", () => {
+      const obj = { a: 1, b: 2, c: 3 };
+      expect(stableStringify(obj)).toBe(stableStringify(obj));
+    });
+
+    it("should produce identical output regardless of key order", () => {
+      const obj1 = { a: 1, b: 2, c: 3 };
+      const obj2 = { c: 3, a: 1, b: 2 };
+      expect(stableStringify(obj1)).toBe(stableStringify(obj2));
+    });
+
+    it("should handle nested objects consistently", () => {
+      const obj1 = { a: 1, nested: { x: 10, y: 20 } };
+      const obj2 = { nested: { y: 20, x: 10 }, a: 1 };
+      expect(stableStringify(obj1)).toBe(stableStringify(obj2));
+    });
+
+    it("should handle deeply nested objects", () => {
+      const obj1 = {
+        level1: {
+          level2: {
+            level3: { z: 3, y: 2, x: 1 },
+            b: "beta",
+          },
+          a: "alpha",
+        },
+      };
+      const obj2 = {
+        level1: {
+          a: "alpha",
+          level2: {
+            b: "beta",
+            level3: { x: 1, y: 2, z: 3 },
+          },
+        },
+      };
+      expect(stableStringify(obj1)).toBe(stableStringify(obj2));
+    });
+  });
+
+  describe("arrays", () => {
+    it("should preserve array order", () => {
+      const obj1 = { arr: [1, 2, 3] };
+      const obj2 = { arr: [3, 2, 1] };
+      expect(stableStringify(obj1)).not.toBe(stableStringify(obj2));
+    });
+
+    it("should handle arrays of objects", () => {
+      const obj1 = {
+        items: [
+          { b: 2, a: 1 },
+          { d: 4, c: 3 },
+        ],
+      };
+      const obj2 = {
+        items: [
+          { a: 1, b: 2 },
+          { c: 3, d: 4 },
+        ],
+      };
+      expect(stableStringify(obj1)).toBe(stableStringify(obj2));
+    });
+
+    it("should handle nested arrays", () => {
+      const obj = {
+        matrix: [
+          [1, 2],
+          [3, 4],
+        ],
+      };
+      const result = stableStringify(obj);
+      expect(result).toContain("[[1,2],[3,4]]");
+    });
+  });
+
+  describe("filtering - removes non-serializable values", () => {
+    it("should filter out undefined values", () => {
+      const obj = { a: 1, b: undefined, c: 3 };
+      const result = stableStringify(obj);
+      expect(result).not.toContain("b");
+      expect(result).toBe('{"a":1,"c":3}');
+    });
+
+    it("should filter out undefined in arrays", () => {
+      const obj = { arr: [1, undefined, 2, undefined, 3] };
+      const result = stableStringify(obj);
+      expect(result).toBe('{"arr":[1,2,3]}');
+    });
+  });
+
+  describe("complex nested structures", () => {
+    it("should handle mixed nested types", () => {
+      const obj = {
+        string: "value",
+        number: 123,
+        boolean: true,
+        null: null,
+        array: [1, 2, { nested: "item" }],
+        object: {
+          deep: {
+            deeper: {
+              value: "deepest",
+            },
+          },
+        },
+      };
+      const result = stableStringify(obj);
+      expect(result).toContain('"string":"value"');
+      expect(result).toContain('"number":123');
+      expect(result).toContain('"boolean":true');
+      expect(result).toContain('"null":null');
+      expect(result).toContain('"value":"deepest"');
+    });
+
+    it("should be deterministic across multiple calls", () => {
+      const obj = {
+        z: 26,
+        a: 1,
+        m: { y: 2, x: 1 },
+        arr: [3, 2, 1],
+      };
+      const results = Array.from({ length: 10 }, () => stableStringify(obj));
+      const allSame = results.every((r) => r === results[0]);
+      expect(allSame).toBe(true);
+    });
+  });
+});
+
+describe("hashConfig", () => {
+  describe("stability - same config produces same hash", () => {
+    it("should produce same hash for identical configs", () => {
+      const config = {
+        sourceLocale: "en",
+        targetLocales: ["es", "fr"],
+        sourceRoot: "src",
+      };
+      const hash1 = hashConfig(config);
+      const hash2 = hashConfig(config);
+      expect(hash1).toBe(hash2);
+    });
+
+    it("should produce same hash regardless of key order", () => {
+      const config1 = {
+        sourceLocale: "en",
+        targetLocales: ["es", "fr"],
+        sourceRoot: "src",
+      };
+      const config2 = {
+        targetLocales: ["es", "fr"],
+        sourceRoot: "src",
+        sourceLocale: "en",
+      };
+      const hash1 = hashConfig(config1);
+      const hash2 = hashConfig(config2);
+      expect(hash1).toBe(hash2);
+    });
+
+    it("should produce same hash for nested objects with different key order", () => {
+      const config1 = {
+        sourceLocale: "en",
+        dev: { port: 3000, host: "localhost" },
+        models: { en_es: "model1" },
+      };
+      const config2 = {
+        models: { en_es: "model1" },
+        sourceLocale: "en",
+        dev: { host: "localhost", port: 3000 },
+      };
+      expect(hashConfig(config1)).toBe(hashConfig(config2));
+    });
+  });
+
+  describe("differentiation - different configs produce different hashes", () => {
+    it("should produce different hash when value changes", () => {
+      const config1 = { sourceLocale: "en", targetLocales: ["es"] };
+      const config2 = { sourceLocale: "en", targetLocales: ["fr"] };
+      expect(hashConfig(config1)).not.toBe(hashConfig(config2));
+    });
+
+    it("should produce different hash when nested value changes", () => {
+      const config1 = {
+        sourceLocale: "en",
+        dev: { port: 3000 },
+      };
+      const config2 = {
+        sourceLocale: "en",
+        dev: { port: 4000 },
+      };
+      expect(hashConfig(config1)).not.toBe(hashConfig(config2));
+    });
+
+    it("should produce different hash when key is added", () => {
+      const config1 = { sourceLocale: "en" };
+      const config2 = { sourceLocale: "en", sourceRoot: "src" };
+      expect(hashConfig(config1)).not.toBe(hashConfig(config2));
+    });
+
+    it("should produce different hash when array order changes", () => {
+      const config1 = { targetLocales: ["es", "fr", "de"] };
+      const config2 = { targetLocales: ["de", "es", "fr"] };
+      expect(hashConfig(config1)).not.toBe(hashConfig(config2));
+    });
+  });
+
+  describe("real-world config examples", () => {
+    it("should handle typical translation config", () => {
+      const config = {
+        sourceLocale: "en",
+        targetLocales: ["es", "fr", "de"],
+        sourceRoot: "src",
+        lingoDir: ".lingo",
+        models: "lingo.dev",
+        pluralization: { enabled: true, model: "groq:llama3" },
+        dev: {
+          translationServerStartPort: 60000,
+          usePseudotranslator: false,
+        },
+      };
+      const hash = hashConfig(config);
+      expect(hash).toMatch(/^[a-f0-9]{12}$/);
+    });
+
+    it("should differentiate configs with different translator settings", () => {
+      const config1 = {
+        sourceLocale: "en",
+        models: "lingo.dev",
+      };
+      const config2 = {
+        sourceLocale: "en",
+        models: { "en:es": "openai:gpt-4" },
+      };
+      expect(hashConfig(config1)).not.toBe(hashConfig(config2));
+    });
+  });
+});
diff --git a/cmp/compiler/src/translation-server/translation-server.ts b/cmp/compiler/src/translation-server/translation-server.ts
@@ -5,13 +5,13 @@
  * - Finds a free port automatically
  * - Serves translations via:
  *   - GET /translations/:locale - Full dictionary (cached)
- *   - GET /translations/:locale/:hash - Single hash translation
  *   - POST /translations/:locale (body: { hashes: string[] }) - Batch translation
  * - Uses the same translation logic as middleware
  * - Can be started/stopped programmatically
  */
 
 import http from "http";
+import crypto from "crypto";
 import type { Socket } from "net";
 import { URL } from "url";
 import { WebSocket, WebSocketServer } from "ws";
@@ -58,6 +58,7 @@ export class TranslationServer {
   private url: string | undefined = undefined;
   private logger;
   private config: TranslationMiddlewareConfig;
+  private configHash: string;
   private startPort: number;
   private onReadyCallback?: (port: number) => void;
   private onErrorCallback?: (error: Error) => void;
@@ -75,6 +76,7 @@ export class TranslationServer {
 
   constructor(options: TranslationServerOptions) {
     this.config = options.config;
+    this.configHash = hashConfig(options.config);
     this.startPort = options.startPort || 60000;
     this.onReadyCallback = options.onReady;
     this.onErrorCallback = options.onError;
@@ -508,6 +510,7 @@ export class TranslationServer {
 
   /**
    * Check if a given URL is running our translation server by calling the health endpoint
+   * Also verifies that the config hash matches to ensure compatible configuration
    */
   private async checkIfTranslationServer(url: string): Promise<boolean> {
     return new Promise((resolve) => {
@@ -525,11 +528,18 @@ export class TranslationServer {
             // Check if response is valid and has the expected structure
             if (res.statusCode === 200) {
               const json = JSON.parse(data);
-              // Our translation server returns { status: "ok", port: ... }
-              if (json.status === "ok") {
-                resolve(true);
+              // Our translation server returns { status: "ok", port: ..., configHash: ... }
+              // Check if config hash matches (if present)
+              // If configHash is missing (old server), accept it for backward compatibility
+              if (json.configHash && json.configHash !== this.configHash) {
+                this.logger.warn(
+                  `Existing server has different config (hash: ${json.configHash} vs ${this.configHash}), will start new server`,
+                );
+                resolve(false);
                 return;
               }
+              resolve(true);
+              return;
             }
             resolve(false);
           } catch (error) {
@@ -581,10 +591,14 @@ export class TranslationServer {
         return;
       }
 
-      // Health check endpoint
       if (url.pathname === "/health") {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ status: "ok", port: this.url }));
+        res.end(
+          JSON.stringify({
+            port: this.url,
+            configHash: this.configHash,
+          }),
+        );
         return;
       }
 
@@ -775,6 +789,53 @@ export class TranslationServer {
   }
 }
 
+type SerializablePrimitive = string | number | boolean | null | undefined;
+
+type SerializableObject = {
+  [key: string]: SerializableValue;
+};
+export type SerializableValue =
+  | SerializablePrimitive
+  | SerializableValue[]
+  | SerializableObject;
+
+export function stableStringify(
+  value: Record<string, SerializableValue>,
+): string {
+  const normalize = (v: any): any => {
+    if (v === undefined) return undefined;
+    if (typeof v === "function") return undefined;
+    if (v === null) return null;
+
+    if (Array.isArray(v)) {
+      return v.map(normalize).filter((x) => x !== undefined);
+    }
+
+    if (typeof v === "object") {
+      const out: Record<string, any> = {};
+      for (const key of Object.keys(v).sort()) {
+        const next = normalize(v[key]);
+        if (next !== undefined) out[key] = next;
+      }
+      return out;
+    }
+
+    return v;
+  };
+
+  return JSON.stringify(normalize(value));
+}
+
+/**
+ * Generate a stable hash of a config object
+ * Filters out functions and non-serializable values
+ * Sorts keys for stability
+ */
+export function hashConfig(config: Record<string, SerializableValue>): string {
+  const serialized = stableStringify(config);
+  return crypto.createHash("md5").update(serialized).digest("hex").slice(0, 12);
+}
+
 /**
  * Create and start a translation server
  */
@@ -800,7 +861,6 @@ export async function startOrGetTranslationServer(
   options: TranslationServerOptions,
 ): Promise<{ server: TranslationServer; url: string }> {
   const server = new TranslationServer(options);
-  // TODO (AleksandrSl 03/12/2025): Health endpoint should return the config and we should check if it matched the current one.
   const url = await server.startOrGetUrl();
   return { server, url };
 }
diff --git a/cmp/compiler/src/utils/hash.ts b/cmp/compiler/src/utils/hash.ts
@@ -24,6 +24,7 @@ export function generateTranslationHash(
   context: Record<string, any>,
 ): string {
   const input = `${sourceText}::${Object.entries(context)
+    .sort((a, b) => a[0].localeCompare(b[0]))
     .map(([key, value]) => `${key}:${value}`)
     .join("::")}`;
   return crypto.createHash("md5").update(input).digest("hex").substring(0, 12); // Use first 12 chars for brevity
