@messagevisor/core 0.0.1 → 0.1.0

package/src/generate-code/typescript.spec.ts

@@ -0,0 +1,241 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import { getProjectConfig } from "../config";
+import { Datasource } from "../datasource";
+import { generateCodeForProject, generateCodePlugin } from "./index";
+
+async function writeFile(root: string, relativePath: string, content: string) {
+  const filePath = path.join(root, relativePath);
+
+  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, content);
+}
+
+async function createProject() {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "messagevisor-codegen-"));
+
+  await writeFile(root, "messagevisor.config.js", "module.exports = {};\n");
+  await writeFile(root, "locales/en-US.yml", "description: English\n");
+  await writeFile(
+    root,
+    "targets/web.yml",
+    "description: Web\nincludeMessages:\n  - common*\n  - checkout*\nexcludeMessages:\n  - common.hidden\nlocales:\n  - en-US\n",
+  );
+  await writeFile(
+    root,
+    "messages/common/welcome.yml",
+    "description: Welcome\ntranslations:\n  en-US: Welcome\n",
+  );
+  await writeFile(
+    root,
+    "messages/checkout/total.yml",
+    "description: Total\ntranslations:\n  en-US: Total\n",
+  );
+  await writeFile(
+    root,
+    "messages/common/hidden.yml",
+    "description: Hidden\ntranslations:\n  en-US: Hidden\n",
+  );
+  await writeFile(
+    root,
+    "messages/common/draft.yml",
+    "description: Draft\ntranslations:\n  en-US: Draft\n",
+  );
+  await writeFile(
+    root,
+    "messages/common/archived.yml",
+    "description: Archived\narchived: true\ntranslations:\n  en-US: Archived\n",
+  );
+
+  return root;
+}
+
+async function generate(root: string, options: Record<string, unknown>) {
+  const projectConfig = getProjectConfig(root);
+  const datasource = new Datasource(projectConfig, root);
+
+  return generateCodeForProject(projectConfig, datasource, root, {
+    language: "typescript",
+    outDir: "generated",
+    ...options,
+  });
+}
+
+async function readGenerated(root: string, fileName: string) {
+  return fs.promises.readFile(path.join(root, "generated", fileName), "utf8");
+}
+
+describe("generate-code/typescript", function () {
+  let roots: string[] = [];
+  let consoleLogSpy: jest.SpyInstance;
+
+  beforeEach(function () {
+    consoleLogSpy = jest.spyOn(console, "log").mockImplementation(function () {
+      // Keep generator unit tests focused on generated files.
+    });
+  });
+
+  afterEach(async function () {
+    consoleLogSpy.mockRestore();
+
+    for (const root of roots) {
+      await fs.promises.rm(root, { recursive: true, force: true });
+    }
+
+    roots = [];
+  });
+
+  it("generates typed SDK helpers without runtime key metadata", async function () {
+    const root = await createProject();
+    roots.push(root);
+
+    const result = await generate(root, {});
+    const messages = await readGenerated(root, "messages.ts");
+    const sdk = await readGenerated(root, "sdk.ts");
+    const index = await readGenerated(root, "index.ts");
+
+    expect(result.messageKeys).toEqual([
+      "checkout.total",
+      "common.draft",
+      "common.hidden",
+      "common.welcome",
+    ]);
+    expect(messages).toEqual(
+      [
+        "export type MessagevisorMessageKey =",
+        '  | "checkout.total"',
+        '  | "common.draft"',
+        '  | "common.hidden"',
+        '  | "common.welcome";',
+        "",
+      ].join("\n"),
+    );
+    expect(messages).not.toContain("const");
+    expect(messages).not.toContain("[");
+    expect(messages).not.toContain("{");
+    expect(sdk).toContain("let instance: Messagevisor | undefined;");
+    expect(sdk).toContain("export function setInstance(messagevisor: Messagevisor)");
+    expect(sdk).toContain("export function getInstance()");
+    expect(sdk).toContain("export function translate(");
+    expect(sdk).toContain("export const t = translate;");
+    expect(index).toContain('export type * from "./messages";');
+    expect(index).toContain('export * from "./sdk";');
+    expect(index).not.toContain("./react");
+  });
+
+  it("prints expected plugin option errors without throwing", async function () {
+    const root = await createProject();
+    roots.push(root);
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      await expect(
+        generateCodePlugin.handler({
+          rootDirectoryPath: root,
+          projectConfig,
+          datasource,
+          parsed: {
+            outDir: "generated",
+          },
+        } as any),
+      ).resolves.toEqual(false);
+
+      expect(errorSpy).toHaveBeenCalledWith("Option --language is required.");
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it("generates React helpers when requested", async function () {
+    const root = await createProject();
+    roots.push(root);
+
+    await generate(root, { react: true });
+
+    const react = await readGenerated(root, "react.ts");
+    const index = await readGenerated(root, "index.ts");
+
+    expect(react).toContain("useBaseTranslation");
+    expect(react).toContain("export function useTranslation(");
+    expect(react).toContain("export function useMessagevisor()");
+    expect(react).toContain("t: messagevisor.t as typeof useTranslation");
+    expect(index).toContain('export * from "./react";');
+  });
+
+  it("supports target and include/exclude message filters", async function () {
+    const root = await createProject();
+    roots.push(root);
+
+    await generate(root, {
+      target: "web",
+      includeMessages: "common*",
+      excludeMessages: "common.hidden",
+    });
+
+    const messages = await readGenerated(root, "messages.ts");
+
+    expect(messages).toContain('"common.draft"');
+    expect(messages).toContain('"common.welcome"');
+    expect(messages).not.toContain("checkout.total");
+    expect(messages).not.toContain("common.hidden");
+    expect(messages).not.toContain("common.archived");
+  });
+
+  it("generates never when no messages match", async function () {
+    const root = await createProject();
+    roots.push(root);
+
+    await generate(root, {
+      includeMessages: "missing*",
+    });
+
+    await expect(readGenerated(root, "messages.ts")).resolves.toEqual(
+      "export type MessagevisorMessageKey = never;\n",
+    );
+  });
+
+  it("generates union across sets by default and selected set with --set", async function () {
+    const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "messagevisor-codegen-"));
+    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-US.yml`, "description: English\n");
+      await writeFile(
+        root,
+        `sets/${set}/messages/common/welcome.yml`,
+        `description: Welcome\ntranslations:\n  en-US: ${set} welcome\n`,
+      );
+    }
+
+    await writeFile(
+      root,
+      "sets/storefront/messages/storefront/cart.yml",
+      "description: Cart\ntranslations:\n  en-US: Cart\n",
+    );
+    await writeFile(
+      root,
+      "sets/admin/messages/admin/dashboard.yml",
+      "description: Dashboard\ntranslations:\n  en-US: Dashboard\n",
+    );
+
+    await generate(root, {});
+    expect(await readGenerated(root, "messages.ts")).toContain('"admin.dashboard"');
+    expect(await readGenerated(root, "messages.ts")).toContain('"storefront.cart"');
+    expect(await readGenerated(root, "messages.ts")).toContain('"common.welcome"');
+
+    await fs.promises.rm(path.join(root, "generated"), { recursive: true, force: true });
+
+    await generate(root, { set: "storefront" });
+    const messages = await readGenerated(root, "messages.ts");
+
+    expect(messages).not.toContain("admin.dashboard");
+    expect(messages).toContain('"storefront.cart"');
+    expect(messages).toContain('"common.welcome"');
+  });
+});

package/src/generate-code/typescript.ts

@@ -0,0 +1,284 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import type { Message, Target } from "@messagevisor/types";
+
+import type { ProjectConfig } from "../config";
+import type { Datasource } from "../datasource";
+import { MessagevisorCLIError } from "../error";
+import { getProjectSetExecutions } from "../sets";
+
+export interface TypeScriptCodeGenerationOptions {
+  set?: string | string[];
+  target?: string | string[];
+  includeMessages?: string | string[];
+  excludeMessages?: string | string[];
+  react?: boolean;
+}
+
+export interface TypeScriptCodeGenerationResult {
+  messageKeys: string[];
+  files: string[];
+}
+
+function toArray(value?: string | string[]): string[] {
+  if (typeof value === "undefined") return [];
+  return Array.isArray(value) ? value : [value];
+}
+
+function matchesPattern(key: string, patterns?: string[]) {
+  if (!patterns || patterns.length === 0) {
+    return false;
+  }
+
+  return patterns.some((pattern) => {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`).test(key);
+  });
+}
+
+function isAvailable(message: Message) {
+  return !message.archived;
+}
+
+function sortUnique(values: string[]) {
+  return Array.from(new Set(values)).sort();
+}
+
+function resolveSelectedSet(projectConfig: ProjectConfig, value?: string | string[]) {
+  const sets = toArray(value);
+
+  if (!projectConfig.sets && sets.length > 0) {
+    throw new MessagevisorCLIError("Option --set can only be used when project sets are enabled.");
+  }
+
+  if (sets.length > 1) {
+    throw new MessagevisorCLIError("Only one --set value can be used for code generation.");
+  }
+
+  return sets[0];
+}
+
+async function collectTargetMessageKeys(
+  datasource: Datasource,
+  targetKeys: string[],
+  allMessageKeys: string[],
+) {
+  if (targetKeys.length === 0) {
+    return allMessageKeys;
+  }
+
+  const selected: string[] = [];
+
+  for (const targetKey of targetKeys) {
+    const target = (await datasource.readTarget(targetKey)) as Target;
+    const includeMessages = target.includeMessages?.length ? target.includeMessages : ["*"];
+    const excludeMessages = target.excludeMessages || [];
+
+    for (const messageKey of allMessageKeys) {
+      if (
+        matchesPattern(messageKey, includeMessages) &&
+        !matchesPattern(messageKey, excludeMessages)
+      ) {
+        selected.push(messageKey);
+      }
+    }
+  }
+
+  return sortUnique(selected);
+}
+
+async function collectMessageKeysForDatasource(
+  datasource: Datasource,
+  options: TypeScriptCodeGenerationOptions,
+) {
+  const allMessageKeys = await datasource.listMessages();
+  const messages: Record<string, Message> = {};
+
+  for (const messageKey of allMessageKeys) {
+    messages[messageKey] = await datasource.readMessage(messageKey);
+  }
+
+  let messageKeys = await collectTargetMessageKeys(
+    datasource,
+    toArray(options.target),
+    allMessageKeys,
+  );
+
+  const includeMessages = toArray(options.includeMessages);
+  const excludeMessages = toArray(options.excludeMessages);
+
+  if (includeMessages.length > 0) {
+    messageKeys = messageKeys.filter((messageKey) => matchesPattern(messageKey, includeMessages));
+  }
+
+  if (excludeMessages.length > 0) {
+    messageKeys = messageKeys.filter((messageKey) => !matchesPattern(messageKey, excludeMessages));
+  }
+
+  return messageKeys.filter((messageKey) => isAvailable(messages[messageKey]));
+}
+
+async function collectMessageKeys(
+  projectConfig: ProjectConfig,
+  datasource: Datasource,
+  options: TypeScriptCodeGenerationOptions,
+) {
+  const selectedSet = resolveSelectedSet(projectConfig, options.set);
+  const executions = await getProjectSetExecutions(projectConfig, datasource, selectedSet);
+  const messageKeys: string[] = [];
+
+  for (const execution of executions) {
+    messageKeys.push(...(await collectMessageKeysForDatasource(execution.datasource, options)));
+  }
+
+  return sortUnique(messageKeys);
+}
+
+function renderMessageKeyType(messageKeys: string[]) {
+  if (messageKeys.length === 0) {
+    return "export type MessagevisorMessageKey = never;\n";
+  }
+
+  return [
+    "export type MessagevisorMessageKey =",
+    ...messageKeys.map((messageKey, index) => {
+      const suffix = index === messageKeys.length - 1 ? ";" : "";
+
+      return `  | ${JSON.stringify(messageKey)}${suffix}`;
+    }),
+    "",
+  ].join("\n");
+}
+
+function renderSdkFile() {
+  return `import type {
+  TranslateOptions,
+  MessageFormatResult,
+  MessagePrimitiveValue,
+  MessageValues,
+  Messagevisor,
+} from "@messagevisor/sdk";
+import type { MessagevisorMessageKey } from "./messages";
+
+let instance: Messagevisor | undefined;
+
+export function setInstance(messagevisor: Messagevisor) {
+  instance = messagevisor;
+}
+
+export function getInstance() {
+  if (!instance) {
+    throw new Error("Messagevisor instance is not set. Call setInstance(instance) first.");
+  }
+
+  return instance;
+}
+
+export function translate(
+  messageKey: MessagevisorMessageKey,
+  values?: Record<string, MessagePrimitiveValue>,
+  options?: TranslateOptions,
+): string;
+export function translate<T>(
+  messageKey: MessagevisorMessageKey,
+  values: MessageValues<T>,
+  options?: TranslateOptions,
+): MessageFormatResult<T>;
+export function translate<T>(
+  messageKey: MessagevisorMessageKey,
+  values?: MessageValues<T>,
+  options?: TranslateOptions,
+) {
+  return getInstance().translate(messageKey, values, options);
+}
+
+export const t = translate;
+`;
+}
+
+function renderReactFile() {
+  return `import type * as React from "react";
+import type {
+  TranslateOptions,
+  MessageFormatResult,
+  MessagePrimitiveValue,
+  MessageValues,
+} from "@messagevisor/sdk";
+import {
+  useMessagevisor as useBaseMessagevisor,
+  useTranslation as useBaseTranslation,
+} from "@messagevisor/react";
+import type { MessagevisorMessageKey } from "./messages";
+
+export function useTranslation(
+  messageKey: MessagevisorMessageKey,
+  values?: Record<string, MessagePrimitiveValue>,
+  options?: TranslateOptions,
+): string;
+export function useTranslation<T>(
+  messageKey: MessagevisorMessageKey,
+  values: MessageValues<T>,
+  options?: TranslateOptions,
+): MessageFormatResult<T> | React.ReactNode;
+export function useTranslation<T>(
+  messageKey: MessagevisorMessageKey,
+  values?: MessageValues<T>,
+  options?: TranslateOptions,
+) {
+  return useBaseTranslation(messageKey, values as any, options);
+}
+
+export function useMessagevisor() {
+  const messagevisor = useBaseMessagevisor();
+
+  return {
+    ...messagevisor,
+    t: messagevisor.t as typeof useTranslation,
+  };
+}
+`;
+}
+
+function renderIndexFile(react?: boolean) {
+  return [
+    'export type * from "./messages";',
+    'export * from "./sdk";',
+    react ? 'export * from "./react";' : "",
+    "",
+  ]
+    .filter((line) => line !== "")
+    .join("\n");
+}
+
+async function writeGeneratedFile(outDir: string, fileName: string, content: string) {
+  const filePath = path.join(outDir, fileName);
+
+  await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.promises.writeFile(filePath, content.endsWith("\n") ? content : `${content}\n`);
+
+  return filePath;
+}
+
+export async function generateTypeScriptCodeForProject(
+  projectConfig: ProjectConfig,
+  datasource: Datasource,
+  outDir: string,
+  options: TypeScriptCodeGenerationOptions = {},
+): Promise<TypeScriptCodeGenerationResult> {
+  const messageKeys = await collectMessageKeys(projectConfig, datasource, options);
+  const files = [
+    await writeGeneratedFile(outDir, "messages.ts", renderMessageKeyType(messageKeys)),
+    await writeGeneratedFile(outDir, "sdk.ts", renderSdkFile()),
+    await writeGeneratedFile(outDir, "index.ts", renderIndexFile(options.react)),
+  ];
+
+  if (options.react) {
+    files.push(await writeGeneratedFile(outDir, "react.ts", renderReactFile()));
+  }
+
+  return {
+    messageKeys,
+    files,
+  };
+}