@messagevisor/catalog 0.5.0 → 0.7.0

package/src/node/index.spec.ts

@@ -46,6 +46,25 @@ async function pathExists(root: string, relativePath: string) {
   }
 }
 
+function stripAnsi(value: string) {
+  return value.replace(/\x1b\[[0-9;]*m/g, "").replace(/%s/g, "");
+}
+
+async function captureConsoleLog(callback: () => Promise<void>) {
+  const logs: string[] = [];
+  const spy = jest.spyOn(console, "log").mockImplementation((...args: unknown[]) => {
+    logs.push(args.map(String).join(" "));
+  });
+
+  try {
+    await callback();
+  } finally {
+    spy.mockRestore();
+  }
+
+  return stripAnsi(logs.join("\n"));
+}
+
 async function createProject() {
   const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "messagevisor-catalog-"));
   const interpolationModulePath = path.join(
@@ -230,14 +249,6 @@ describe("catalog", function () {
     const manifest = await readJson<any>(root, "catalog-out/data/manifest.json");
     const index = await readJson<any>(root, "catalog-out/data/root/index.json");
     const locale = await readJson<any>(root, "catalog-out/data/root/entities/locale/en-US.json");
-    const localeDuplicates = await readJson<any>(
-      root,
-      "catalog-out/data/root/duplicates/locales/en-US.json",
-    );
-    const emptyLocaleDuplicates = await readJson<any>(
-      root,
-      "catalog-out/data/root/duplicates/locales/nl.json",
-    );
     const message = await readJson<any>(
       root,
       "catalog-out/data/root/entities/message/common.welcome.json",
@@ -253,11 +264,20 @@ describe("catalog", function () {
     expect(manifest.sets).toBe(false);
     expect(manifest.router).toBe("browser");
     expect(manifest.dev).toBeUndefined();
-    expect(manifest.features).toEqual({ translationSearch: false });
+    expect(manifest.features).toEqual({ translationSearch: false, duplicates: false });
     expect(manifest.paths.root).toBe("data/root/index.json");
     await expect(pathExists(root, "catalog-out/data/root/translations/77656c.json")).resolves.toBe(
       false,
     );
+    await expect(
+      pathExists(root, "catalog-out/data/root/duplicates/locales/en-US.json"),
+    ).resolves.toBe(false);
+    await expect(
+      pathExists(root, "catalog-out/data/root/history/message/common.welcome/page-1.json"),
+    ).resolves.toBe(false);
+    await expect(
+      pathExists(root, "catalog-out/data/root/history/message/common.draft/page-1.json"),
+    ).resolves.toBe(false);
     expect(index.counts.message).toBe(2);
     expect(
       index.entities.message.find((entry: any) => entry.key === "common.welcome").targets,
@@ -321,31 +341,6 @@ describe("catalog", function () {
       ]),
     );
     expect(locale.targetFormats.web.number.money.minimumFractionDigits).toBe(2);
-    expect(localeDuplicates).toEqual({
-      locale: "en-US",
-      summary: {
-        duplicateValues: 1,
-        duplicateMessageKeys: 2,
-      },
-      duplicateValues: [
-        {
-          value: "Welcome",
-          messageKeys: ["common.draft", "common.welcome"],
-          sources: [
-            { messageKey: "common.draft", locale: "en" },
-            { messageKey: "common.welcome", locale: "en" },
-          ],
-        },
-      ],
-    });
-    expect(emptyLocaleDuplicates).toEqual({
-      locale: "nl",
-      summary: {
-        duplicateValues: 0,
-        duplicateMessageKeys: 0,
-      },
-      duplicateValues: [],
-    });
     expect(target.formatRowsByLocale["en-US"]).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
@@ -403,6 +398,56 @@ describe("catalog", function () {
     expect(history.entries).toEqual([]);
   });
 
+  it("exports locale duplicate reports only when opted in", async function () {
+    const root = await createProject();
+    roots.push(root);
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    await catalogApi.exportCatalog(root, projectConfig, datasource, {
+      outDir: "catalog-out",
+      copyAssets: false,
+      withDuplicates: true,
+    });
+
+    const manifest = await readJson<any>(root, "catalog-out/data/manifest.json");
+    const localeDuplicates = await readJson<any>(
+      root,
+      "catalog-out/data/root/duplicates/locales/en-US.json",
+    );
+    const emptyLocaleDuplicates = await readJson<any>(
+      root,
+      "catalog-out/data/root/duplicates/locales/nl.json",
+    );
+
+    expect(manifest.features).toEqual({ translationSearch: false, duplicates: true });
+    expect(localeDuplicates).toEqual({
+      locale: "en-US",
+      summary: {
+        duplicateValues: 1,
+        duplicateMessageKeys: 2,
+      },
+      duplicateValues: [
+        {
+          value: "Welcome",
+          messageKeys: ["common.draft", "common.welcome"],
+          sources: [
+            { messageKey: "common.draft", locale: "en" },
+            { messageKey: "common.welcome", locale: "en" },
+          ],
+        },
+      ],
+    });
+    expect(emptyLocaleDuplicates).toEqual({
+      locale: "nl",
+      summary: {
+        duplicateValues: 0,
+        duplicateMessageKeys: 0,
+      },
+      duplicateValues: [],
+    });
+  });
+
   it("exports translation search shards only when opted in", async function () {
     const root = await createProject();
     roots.push(root);
@@ -418,11 +463,121 @@ describe("catalog", function () {
     const manifest = await readJson<any>(root, "catalog-out/data/manifest.json");
     const shard = await readJson<any>(root, "catalog-out/data/root/translations/77656c.json");
 
-    expect(manifest.features).toEqual({ translationSearch: true });
+    expect(manifest.features).toEqual({ translationSearch: true, duplicates: false });
     expect(shard["common.welcome"]).toEqual(expect.arrayContaining(["welcome", "welcome pro"]));
     expect(shard["common.draft"]).toEqual(["welcome"]);
   });
 
+  it("prints progress output for default catalog export", async function () {
+    const root = await createProject();
+    roots.push(root);
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    const output = await captureConsoleLog(async () => {
+      await catalogApi.exportCatalog(root, projectConfig, datasource, {
+        outDir: "catalog-out",
+        copyAssets: false,
+      });
+    });
+
+    expect(output).toContain("Generating Messagevisor catalog");
+    expect(output).toContain("Output: catalog-out");
+    expect(output).toContain("Router: browser");
+    expect(output).toContain("Features: none");
+    expect(output).toContain("Preparing output directory");
+    expect(output).toContain("Reading Git history");
+    expect(output).toContain("Discovering project sets");
+    expect(output).toContain("Writing project history");
+    expect(output).toContain("Root catalog");
+    expect(output).toContain("Processing entities");
+    expect(output).toContain("Writing messages");
+    expect(output).toContain("Writing message details");
+    expect(output).toContain("Writing message history pages");
+    expect(output).toContain("Writing manifest");
+    expect(output).toContain("Catalog exported to catalog-out");
+    expect(output).toContain("Time:");
+    expect(output).not.toContain("Scanning duplicate translations");
+    expect(output).not.toContain("Building translation search shards");
+  });
+
+  it("prints optional catalog progress only when feature work is enabled", async function () {
+    const root = await createProject();
+    roots.push(root);
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    const output = await captureConsoleLog(async () => {
+      await catalogApi.exportCatalog(root, projectConfig, datasource, {
+        outDir: "catalog-out",
+        copyAssets: false,
+        withDuplicates: true,
+        withTranslationSearch: true,
+      });
+    });
+
+    expect(output).toContain("Features: translation search, duplicates");
+    expect(output).toContain("Scanning duplicate translations");
+    expect(output).toContain("Writing duplicate reports");
+    expect(output).toContain("Building translation search shards");
+  });
+
+  it("exports many messages deterministically without empty history files", async function () {
+    const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "messagevisor-catalog-"));
+    roots.push(root);
+
+    await writeFile(root, "messagevisor.config.js", "module.exports = {};\n");
+    await writeFile(root, "locales/en.yml", "description: English\n");
+
+    const messageCount = 1200;
+    await Promise.all(
+      Array.from({ length: messageCount }, (_, index) => {
+        const key = String(index).padStart(4, "0");
+        return writeFile(
+          root,
+          `messages/bulk/${key}.yml`,
+          `description: Bulk ${key}\ntranslations:\n  en: Bulk ${key}\n`,
+        );
+      }),
+    );
+
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    const output = await captureConsoleLog(async () => {
+      await catalogApi.exportCatalog(root, projectConfig, datasource, {
+        outDir: "catalog-out",
+        copyAssets: false,
+      });
+    });
+
+    const index = await readJson<any>(root, "catalog-out/data/root/index.json");
+    const firstMessage = await readJson<any>(
+      root,
+      "catalog-out/data/root/entities/message/bulk.0000.json",
+    );
+    const lastMessage = await readJson<any>(
+      root,
+      "catalog-out/data/root/entities/message/bulk.1199.json",
+    );
+
+    expect(index.counts.message).toBe(messageCount);
+    expect(index.entities.message.slice(0, 3).map((entry: any) => entry.key)).toEqual([
+      "bulk.0000",
+      "bulk.0001",
+      "bulk.0002",
+    ]);
+    expect(firstMessage.sourcePath).toBe("messages/bulk/0000.yml");
+    expect(lastMessage.translations).toEqual([
+      { locale: "en", value: "Bulk 1199", source: "direct" },
+    ]);
+    await expect(
+      pathExists(root, "catalog-out/data/root/history/message/bulk.0000/page-1.json"),
+    ).resolves.toBe(false);
+    expect(output).toContain("1200 messages");
+    expect(output).toContain("1200 empty histories skipped");
+  });
+
   it("streams Git history into project, entity, and last-modified catalog data", async function () {
     const root = await createProject();
     roots.push(root);
@@ -492,9 +647,12 @@ describe("catalog", function () {
       ]),
     );
     expect(messageHistory.entries).toHaveLength(2);
-    expect(spacedMessageHistory.entries[0].entities).toEqual(
-      expect.arrayContaining([{ type: "message", key: "common.with space" }]),
-    );
+    expect(messageHistory.entries[0].entities).toEqual([
+      { type: "message", key: "common.welcome" },
+    ]);
+    expect(spacedMessageHistory.entries[0].entities).toEqual([
+      { type: "message", key: "common.with space" },
+    ]);
     expect(message.lastModified).toMatchObject({
       author: "Catalog Tester",
       commit: projectHistory.entries[0].commit,
@@ -506,6 +664,67 @@ describe("catalog", function () {
     });
   });
 
+  it("keeps large commit entity lists out of per-entity history files", async function () {
+    const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "messagevisor-catalog-"));
+    roots.push(root);
+
+    await writeFile(root, "messagevisor.config.js", "module.exports = {};\n");
+    await writeFile(root, "locales/en.yml", "description: English\n");
+
+    const messageCount = 1200;
+    await Promise.all(
+      Array.from({ length: messageCount }, (_, index) => {
+        const key = String(index).padStart(4, "0");
+        return writeFile(
+          root,
+          `messages/bulk/${key}.yml`,
+          `description: Bulk ${key}\ntranslations:\n  en: Bulk ${key}\n`,
+        );
+      }),
+    );
+
+    git(root, ["init"]);
+    git(root, ["add", "."]);
+    gitCommit(root, "large message import");
+
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    await catalogApi.exportCatalog(root, projectConfig, datasource, {
+      outDir: "catalog-out",
+      copyAssets: false,
+    });
+
+    const projectHistory = await readJson<any>(
+      root,
+      "catalog-out/data/project/history/page-1.json",
+    );
+    const firstMessageHistory = await readJson<any>(
+      root,
+      "catalog-out/data/root/history/message/bulk.0000/page-1.json",
+    );
+    const lastMessageHistory = await readJson<any>(
+      root,
+      "catalog-out/data/root/history/message/bulk.1199/page-1.json",
+    );
+
+    expect(projectHistory.entries[0].entities).toHaveLength(messageCount + 1);
+    expect(projectHistory.entries[0].entities).toEqual(
+      expect.arrayContaining([
+        { type: "locale", key: "en" },
+        { type: "message", key: "bulk.0000" },
+        { type: "message", key: "bulk.1199" },
+      ]),
+    );
+    expect(firstMessageHistory.entries[0]).toMatchObject({
+      commit: projectHistory.entries[0].commit,
+      author: projectHistory.entries[0].author,
+      timestamp: projectHistory.entries[0].timestamp,
+      entities: [{ type: "message", key: "bulk.0000" }],
+    });
+    expect(lastMessageHistory.entries[0].entities).toEqual([{ type: "message", key: "bulk.1199" }]);
+  });
+
   it("exports branch-aware repository links and hash router mode when requested", async function () {
     const root = await createProject();
     roots.push(root);
@@ -700,22 +919,41 @@ describe("catalog", function () {
     const admin = await readJson<any>(root, "catalog-out/data/sets/admin/index.json");
 
     expect(manifest.sets).toBe(true);
-    expect(manifest.features).toEqual({ translationSearch: false });
+    expect(manifest.features).toEqual({ translationSearch: false, duplicates: false });
     expect(manifest.setKeys).toEqual(["admin", "storefront"]);
     await expect(
       pathExists(root, "catalog-out/data/sets/storefront/translations/73746f.json"),
     ).resolves.toBe(false);
+    await expect(
+      pathExists(root, "catalog-out/data/sets/storefront/duplicates/locales/en.json"),
+    ).resolves.toBe(false);
+
+    expect(storefront.counts.message).toBe(2);
+    expect(admin.counts.message).toBe(2);
+    await expect(
+      readJson<any>(root, "catalog-out/data/sets/storefront/entities/message/common.welcome.json"),
+    ).resolves.toMatchObject({
+      key: "common.welcome",
+      entity: { translations: { en: "storefront" } },
+    });
+
+    await catalogApi.exportCatalog(root, projectConfig, datasource, {
+      outDir: "catalog-with-duplicates",
+      copyAssets: false,
+      withDuplicates: true,
+    });
+
+    const optInManifest = await readJson<any>(root, "catalog-with-duplicates/data/manifest.json");
     const storefrontDuplicates = await readJson<any>(
       root,
-      "catalog-out/data/sets/storefront/duplicates/locales/en.json",
+      "catalog-with-duplicates/data/sets/storefront/duplicates/locales/en.json",
     );
     const adminDuplicates = await readJson<any>(
       root,
-      "catalog-out/data/sets/admin/duplicates/locales/en.json",
+      "catalog-with-duplicates/data/sets/admin/duplicates/locales/en.json",
     );
 
-    expect(storefront.counts.message).toBe(2);
-    expect(admin.counts.message).toBe(2);
+    expect(optInManifest.features).toEqual({ translationSearch: false, duplicates: true });
     expect(storefrontDuplicates.duplicateValues).toEqual([
       {
         value: "storefront",
@@ -736,12 +974,38 @@ describe("catalog", function () {
         ],
       },
     ]);
-    await expect(
-      readJson<any>(root, "catalog-out/data/sets/storefront/entities/message/common.welcome.json"),
-    ).resolves.toMatchObject({
-      key: "common.welcome",
-      entity: { translations: { en: "storefront" } },
+  });
+
+  it("prints set names while exporting set project catalogs", async function () {
+    const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "messagevisor-catalog-"));
+    roots.push(root);
+
+    await writeFile(root, "messagevisor.config.js", "module.exports = { sets: true };\n");
+
+    for (const set of ["storefront", "admin"]) {
+      await writeFile(root, `sets/${set}/locales/en.yml`, "description: English\n");
+      await writeFile(
+        root,
+        `sets/${set}/messages/common/welcome.yml`,
+        `description: Welcome\ntranslations:\n  en: ${set}\n`,
+      );
+    }
+
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    const output = await captureConsoleLog(async () => {
+      await catalogApi.exportCatalog(root, projectConfig, datasource, {
+        outDir: "catalog-out",
+        copyAssets: false,
+      });
     });
+
+    expect(output).toContain("Sets:   enabled");
+    expect(output).toContain("Discovering project sets");
+    expect(output).toContain('Set "admin"');
+    expect(output).toContain('Set "storefront"');
+    expect(output).toContain("Processing entities");
   });
 
   it("exports set translation search shards when opted in", async function () {
@@ -778,7 +1042,7 @@ describe("catalog", function () {
       "catalog-out/data/sets/admin/translations/61646d.json",
     );
 
-    expect(manifest.features).toEqual({ translationSearch: true });
+    expect(manifest.features).toEqual({ translationSearch: true, duplicates: false });
     expect(storefrontShard).toEqual({ "common.welcome": ["storefront"] });
     expect(adminShard).toEqual({ "common.welcome": ["admin"] });
   });
@@ -988,6 +1252,19 @@ describe("catalog plugin", function () {
     );
   });
 
+  it("forwards duplicates option for dev catalog mode", async function () {
+    const { handler } = createPlugin();
+
+    await handler({ _: ["catalog"], withDuplicates: true });
+
+    expect(exportMock).toHaveBeenLastCalledWith(
+      expect.any(String),
+      expect.any(Object),
+      expect.any(Object),
+      expect.objectContaining({ withDuplicates: true, dev: true }),
+    );
+  });
+
   it("forwards translation search option for export subcommand", async function () {
     const { handler } = createPlugin();
 
@@ -1005,16 +1282,45 @@ describe("catalog plugin", function () {
     );
   });
 
+  it("forwards duplicates option for export subcommand", async function () {
+    const { handler } = createPlugin();
+
+    await handler({
+      _: ["catalog", "export"],
+      subcommand: "export",
+      "with-duplicates": true,
+    });
+
+    expect(exportMock).toHaveBeenLastCalledWith(
+      expect.any(String),
+      expect.any(Object),
+      expect.any(Object),
+      expect.objectContaining({ withDuplicates: true }),
+    );
+  });
+
   it("forwards long and short port options for serve subcommand", async function () {
     const { handler } = createPlugin();
 
-    await handler({ _: ["catalog", "serve"], subcommand: "serve", port: 3103 });
+    await handler({
+      _: ["catalog", "serve"],
+      subcommand: "serve",
+      port: 3103,
+      "with-duplicates": true,
+      "with-translation-search": true,
+    });
     expect(serveMock).toHaveBeenLastCalledWith(
       expect.any(String),
       expect.any(Object),
       expect.any(Object),
       expect.not.objectContaining({ withTranslationSearch: true }),
     );
+    expect(serveMock).toHaveBeenLastCalledWith(
+      expect.any(String),
+      expect.any(Object),
+      expect.any(Object),
+      expect.not.objectContaining({ withDuplicates: true }),
+    );
     expect(serveMock).toHaveBeenLastCalledWith(
       expect.any(String),
       expect.any(Object),
@@ -1043,4 +1349,17 @@ describe("catalog plugin", function () {
       expect.objectContaining({ port: undefined }),
     );
   });
+
+  it("does not print catalog generation progress for serve subcommand", async function () {
+    const { handler } = createPlugin();
+
+    const output = await captureConsoleLog(async () => {
+      await handler({ _: ["catalog", "serve"], subcommand: "serve" });
+    });
+
+    expect(output).not.toContain("Generating Messagevisor catalog");
+    expect(output).not.toContain("Processing entities");
+    expect(serveMock).toHaveBeenCalledTimes(1);
+    expect(exportMock).not.toHaveBeenCalled();
+  });
 });