@messagevisor/core 0.0.1 → 0.1.0

package/src/create/index.spec.ts

@@ -0,0 +1,272 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { Readable } from "stream";
+
+import { getProjectConfig } from "../config";
+import { Datasource } from "../datasource";
+import { lintProject } from "../linter";
+import { createPlugin } 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(configContent = "module.exports = {};\n") {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "messagevisor-create-"));
+  await writeFile(root, "messagevisor.config.js", configContent);
+  return root;
+}
+
+async function createSetsProject() {
+  const root = await fs.promises.mkdtemp(path.join(os.tmpdir(), "messagevisor-create-sets-"));
+  await writeFile(root, "messagevisor.config.js", "module.exports = { sets: true };\n");
+  await fs.promises.mkdir(path.join(root, "sets/dev"), { recursive: true });
+  await fs.promises.mkdir(path.join(root, "sets/production"), { recursive: true });
+  return root;
+}
+
+function mockStdin(content: string) {
+  const originalDescriptor = Object.getOwnPropertyDescriptor(process, "stdin");
+  const stdin = Readable.from([content]) as NodeJS.ReadableStream & { isTTY?: boolean };
+  stdin.isTTY = false;
+
+  Object.defineProperty(process, "stdin", {
+    configurable: true,
+    value: stdin,
+  });
+
+  return () => {
+    if (originalDescriptor) {
+      Object.defineProperty(process, "stdin", originalDescriptor);
+      return;
+    }
+
+    delete (process as any).stdin;
+  };
+}
+
+function pluginOptions(projectConfig: any, datasource: any, parsed: Record<string, unknown>) {
+  return {
+    rootDirectoryPath: "",
+    projectConfig,
+    datasource,
+    parsed: {
+      _: [],
+      ...parsed,
+    },
+  };
+}
+
+describe("createPlugin", function () {
+  it("creates missing message definitions from --keys and respects namespace paths", async function () {
+    const root = await createProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        locales: true,
+        keys: "en\n",
+      }),
+    );
+
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        messages: true,
+        keys: "auth.signin\nauth.signout\n",
+      }),
+    );
+
+    expect(fs.existsSync(path.join(root, "messages/auth/signin.yml"))).toBe(true);
+    expect(fs.existsSync(path.join(root, "messages/auth/signout.yml"))).toBe(true);
+
+    const lintResult = await lintProject(projectConfig, datasource);
+    expect(lintResult.hasError).toBe(false);
+  });
+
+  it("creates missing locale, target, attribute, and segment definitions with lint-valid shells", async function () {
+    const root = await createProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        locales: true,
+        keys: "en\nnl\n",
+      }),
+    );
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        targets: true,
+        keys: "web\n",
+      }),
+    );
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        attributes: true,
+        keys: "plan\n",
+      }),
+    );
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        segments: true,
+        keys: "everyone\n",
+      }),
+    );
+
+    const lintResult = await lintProject(projectConfig, datasource);
+    expect(lintResult.hasError).toBe(false);
+  });
+
+  it("reads keys from stdin, trims whitespace, ignores blank lines, and dedupes duplicates", async function () {
+    const root = await createProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        locales: true,
+        keys: "en\n",
+      }),
+    );
+
+    const restoreStdin = mockStdin(" auth.signin \n\nauth.signin\naccount.profile\n");
+
+    try {
+      await createPlugin.handler(
+        pluginOptions(projectConfig, datasource, {
+          messages: true,
+        }),
+      );
+    } finally {
+      restoreStdin();
+    }
+
+    expect((await datasource.listMessages()).sort()).toEqual(["account.profile", "auth.signin"]);
+  });
+
+  it("skips existing files and reports a JSON summary", async function () {
+    const root = await createProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        locales: true,
+        keys: "en\n",
+      }),
+    );
+
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        messages: true,
+        keys: "auth.signin\n",
+      }),
+    );
+
+    await createPlugin.handler(
+      pluginOptions(projectConfig, datasource, {
+        messages: true,
+        keys: "auth.signin\nauth.signout\n",
+        json: true,
+      }),
+    );
+
+    const summary = JSON.parse(String(logSpy.mock.calls[logSpy.mock.calls.length - 1][0]));
+    expect(summary.entityType).toEqual("messages");
+    expect(summary.requestedKeys).toEqual(["auth.signin", "auth.signout"]);
+    expect(summary.createdKeys).toEqual(["auth.signout"]);
+    expect(summary.skippedKeys).toEqual(["auth.signin"]);
+    expect(summary.createdFilePaths).toEqual([
+      path.relative(process.cwd(), path.join(root, "messages/auth/signout.yml")),
+    ]);
+    logSpy.mockRestore();
+  });
+
+  it("errors when creating messages without any locales", async function () {
+    const root = await createProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      await expect(
+        createPlugin.handler(
+          pluginOptions(projectConfig, datasource, {
+            messages: true,
+            keys: "auth.signin\n",
+          }),
+        ),
+      ).resolves.toEqual(false);
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Cannot create messages without at least one locale. Create a locale first.",
+      );
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it("requires exactly one selector flag", async function () {
+    const root = await createProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      await expect(
+        createPlugin.handler(
+          pluginOptions(projectConfig, datasource, {
+            keys: "auth.signin\n",
+          }),
+        ),
+      ).resolves.toEqual(false);
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Nothing to create. Pass exactly one of --messages, --locales, --targets, --attributes, or --segments.",
+      );
+
+      errorSpy.mockClear();
+
+      await expect(
+        createPlugin.handler(
+          pluginOptions(projectConfig, datasource, {
+            messages: true,
+            locales: true,
+            keys: "auth.signin\n",
+          }),
+        ),
+      ).resolves.toEqual(false);
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Pass exactly one of --messages, --locales, --targets, --attributes, or --segments.",
+      );
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it("requires --set in sets-enabled projects", async function () {
+    const root = await createSetsProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+
+    try {
+      await expect(
+        createPlugin.handler(
+          pluginOptions(projectConfig, datasource, {
+            messages: true,
+            keys: "auth.signin\n",
+          }),
+        ),
+      ).resolves.toEqual(false);
+
+      expect(errorSpy).toHaveBeenCalledWith("Pass --set=<set>");
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+});

package/src/create/index.ts

@@ -0,0 +1,295 @@
+import * as path from "path";
+
+import type { Attribute, Locale, Message, Target, Segment } from "@messagevisor/types";
+
+import type { Plugin } from "../cli";
+import { MessagevisorCLIError, printMessagevisorCLIError } from "../error";
+import { getProjectSetExecutions } from "../sets";
+
+type CreateEntityType = "messages" | "locales" | "targets" | "attributes" | "segments";
+
+interface CreateSummary {
+  entityType: CreateEntityType;
+  requestedKeys: string[];
+  createdKeys: string[];
+  skippedKeys: string[];
+  createdFilePaths: string[];
+}
+
+function getSelectedEntityType(parsed: Record<string, unknown>): CreateEntityType {
+  const selected = (
+    ["messages", "locales", "targets", "attributes", "segments"] as CreateEntityType[]
+  ).filter((entityType) => Boolean(parsed[entityType]));
+
+  if (selected.length === 0) {
+    throw new MessagevisorCLIError(
+      "Nothing to create. Pass exactly one of --messages, --locales, --targets, --attributes, or --segments.",
+    );
+  }
+
+  if (selected.length > 1) {
+    throw new MessagevisorCLIError(
+      "Pass exactly one of --messages, --locales, --targets, --attributes, or --segments.",
+    );
+  }
+
+  return selected[0];
+}
+
+async function readInputKeys(parsed: Record<string, unknown>) {
+  if (typeof parsed.keys === "string") {
+    return parsed.keys;
+  }
+
+  if (process.stdin.isTTY) {
+    throw new MessagevisorCLIError(
+      "Pass --keys=<multiline string> or provide newline-separated keys via stdin.",
+    );
+  }
+
+  const chunks: string[] = [];
+
+  for await (const chunk of process.stdin) {
+    chunks.push(String(chunk));
+  }
+
+  return chunks.join("");
+}
+
+function parseKeys(input: string) {
+  const seen = new Set<string>();
+  const keys: string[] = [];
+
+  for (const rawLine of input.split(/\r?\n/g)) {
+    const key = rawLine.trim();
+
+    if (!key || seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    keys.push(key);
+  }
+
+  if (keys.length === 0) {
+    throw new MessagevisorCLIError("No keys found. Pass at least one newline-separated key.");
+  }
+
+  return keys;
+}
+
+function getParserExtension(projectConfig: any) {
+  return (projectConfig.parser as any).extension || "yml";
+}
+
+function getEntityDirectoryPath(projectConfig: any, entityType: CreateEntityType) {
+  if (entityType === "messages") {
+    return projectConfig.messagesDirectoryPath;
+  }
+
+  if (entityType === "locales") {
+    return projectConfig.localesDirectoryPath;
+  }
+
+  if (entityType === "targets") {
+    return projectConfig.targetsDirectoryPath;
+  }
+
+  if (entityType === "attributes") {
+    return projectConfig.attributesDirectoryPath;
+  }
+
+  return projectConfig.segmentsDirectoryPath;
+}
+
+function getEntityFilePath(projectConfig: any, entityType: CreateEntityType, key: string) {
+  return (
+    path.join(
+      getEntityDirectoryPath(projectConfig, entityType),
+      ...key.split(projectConfig.namespaceCharacter),
+    ) + `.${getParserExtension(projectConfig)}`
+  );
+}
+
+async function createEntityShell(
+  datasource: any,
+  entityType: CreateEntityType,
+): Promise<Message | Locale | Target | Attribute | Segment> {
+  if (entityType === "messages") {
+    const localeKeys = await datasource.listLocales();
+
+    if (localeKeys.length === 0) {
+      throw new MessagevisorCLIError(
+        "Cannot create messages without at least one locale. Create a locale first.",
+      );
+    }
+
+    return {
+      description: "",
+      translations: {
+        [localeKeys[0]]: "",
+      },
+    };
+  }
+
+  if (entityType === "locales") {
+    return {
+      description: "",
+    };
+  }
+
+  if (entityType === "targets") {
+    return {
+      description: "",
+      includeMessages: ["*"],
+    };
+  }
+
+  if (entityType === "attributes") {
+    return {
+      description: "",
+      type: "string",
+    };
+  }
+
+  return {
+    description: "",
+    conditions: "*",
+  };
+}
+
+async function listExistingKeys(datasource: any, entityType: CreateEntityType) {
+  if (entityType === "messages") {
+    return datasource.listMessages();
+  }
+
+  if (entityType === "locales") {
+    return datasource.listLocales();
+  }
+
+  if (entityType === "targets") {
+    return datasource.listTargets();
+  }
+
+  if (entityType === "attributes") {
+    return datasource.listAttributes();
+  }
+
+  return datasource.listSegments();
+}
+
+async function writeEntity(datasource: any, entityType: CreateEntityType, key: string) {
+  const entity = await createEntityShell(datasource, entityType);
+
+  if (entityType === "messages") {
+    await datasource.writeMessage(key, entity as Message);
+    return;
+  }
+
+  if (entityType === "locales") {
+    await datasource.writeLocale(key, entity as Locale);
+    return;
+  }
+
+  if (entityType === "targets") {
+    await datasource.writeTarget(key, entity as Target);
+    return;
+  }
+
+  if (entityType === "attributes") {
+    await datasource.writeAttribute(key, entity as Attribute);
+    return;
+  }
+
+  await datasource.writeSegment(key, entity as Segment);
+}
+
+async function createDefinitions(
+  projectConfig: any,
+  datasource: any,
+  entityType: CreateEntityType,
+  requestedKeys: string[],
+): Promise<CreateSummary> {
+  const existingKeys = new Set(await listExistingKeys(datasource, entityType));
+  const createdKeys: string[] = [];
+  const skippedKeys: string[] = [];
+  const createdFilePaths: string[] = [];
+
+  for (const key of requestedKeys) {
+    if (existingKeys.has(key)) {
+      skippedKeys.push(key);
+      continue;
+    }
+
+    await writeEntity(datasource, entityType, key);
+    createdKeys.push(key);
+    createdFilePaths.push(
+      path.relative(process.cwd(), getEntityFilePath(projectConfig, entityType, key)),
+    );
+    existingKeys.add(key);
+  }
+
+  return {
+    entityType,
+    requestedKeys,
+    createdKeys,
+    skippedKeys,
+    createdFilePaths,
+  };
+}
+
+function printSummary(summary: CreateSummary) {
+  console.log("");
+  console.log(`Entity type      : ${summary.entityType}`);
+  console.log(`Requested        : ${summary.requestedKeys.length}`);
+  console.log(`Created          : ${summary.createdKeys.length}`);
+  console.log(`Skipped existing : ${summary.skippedKeys.length}`);
+}
+
+export const createPlugin: Plugin = {
+  command: "create",
+  handler: async ({ projectConfig, datasource, parsed }) => {
+    try {
+      if (projectConfig.sets && !parsed.set) {
+        throw new MessagevisorCLIError("Pass --set=<set>");
+      }
+
+      if (projectConfig.sets) {
+        const [execution] = await getProjectSetExecutions(projectConfig, datasource, parsed.set);
+        projectConfig = execution.projectConfig;
+        datasource = execution.datasource;
+      }
+
+      const entityType = getSelectedEntityType(parsed);
+      const requestedKeys = parseKeys(await readInputKeys(parsed));
+      const summary = await createDefinitions(projectConfig, datasource, entityType, requestedKeys);
+
+      if (parsed.json) {
+        console.log(parsed.pretty ? JSON.stringify(summary, null, 2) : JSON.stringify(summary));
+        return;
+      }
+
+      printSummary(summary);
+    } catch (error) {
+      if (printMessagevisorCLIError(error)) {
+        return false;
+      }
+
+      throw error;
+    }
+  },
+  examples: [
+    {
+      command: `create --messages --keys=$'auth.signin\\nauth.signout'`,
+      description: "create missing message definitions from newline-separated keys",
+    },
+    {
+      command: `create --locales --keys=$'en\\nnl'`,
+      description: "create missing locale definitions",
+    },
+    {
+      command: `create --attributes --keys=$'plan\\nplatform'`,
+      description: "create missing attribute definitions",
+    },
+  ],
+};