@messagevisor/catalog 0.4.0 → 0.6.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(
@@ -72,6 +91,8 @@ async function createProject() {
       "direction: ltr",
       "formats:",
       "  number:",
+      "    decimal:",
+      "      maximumFractionDigits: 2",
       "    money:",
       "      style: currency",
       "      currency: USD",
@@ -228,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",
@@ -251,11 +264,14 @@ 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);
     expect(index.counts.message).toBe(2);
     expect(
       index.entities.message.find((entry: any) => entry.key === "common.welcome").targets,
@@ -270,19 +286,16 @@ describe("catalog", function () {
       "web",
     ]);
     expect(index.entities.target.find((entry: any) => entry.key === "web").messageCount).toBe(2);
-    expect(locale.computedFormats.number.money).toEqual({
-      style: "currency",
-      currency: "USD",
-      currencyDisplay: "code",
-    });
+    expect(locale.computedFormats.number.decimal).toEqual({ maximumFractionDigits: 2 });
+    expect(locale.computedFormats.number.money).toEqual({ currencyDisplay: "code" });
     expect(locale.entity.examples).toHaveLength(1);
     expect(locale.entity.direction).toBe("ltr");
     expect(locale.entity.promotable).toBe(false);
     expect(locale.formatRows).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          path: "number.money.style",
-          value: "currency",
+          path: "number.decimal.maximumFractionDigits",
+          value: 2,
           source: "inherited",
           from: "en",
           examplePreview: expect.any(String),
@@ -322,31 +335,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({
@@ -357,8 +345,8 @@ describe("catalog", function () {
           examplePreview: expect.any(String),
         }),
         expect.objectContaining({
-          path: "number.money.style",
-          value: "currency",
+          path: "number.decimal.maximumFractionDigits",
+          value: 2,
           source: "inherited",
           from: "en",
           examplePreview: expect.any(String),
@@ -404,6 +392,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);
@@ -419,11 +457,63 @@ 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 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("streams Git history into project, entity, and last-modified catalog data", async function () {
     const root = await createProject();
     roots.push(root);
@@ -701,22 +791,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",
@@ -737,12 +846,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 () {
@@ -779,7 +914,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"] });
   });
@@ -989,6 +1124,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();
 
@@ -1006,16 +1154,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),
@@ -1044,4 +1221,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();
+  });
 });