@messagevisor/core 0.0.1 → 0.1.0

package/src/evaluate/cli.spec.ts

@@ -0,0 +1,368 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import { getProjectConfig } from "../config";
+import { Datasource } from "../datasource";
+import { evaluatePlugin } from "./cli";
+
+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-evaluate-"));
+
+  await writeFile(root, "messagevisor.config.js", configContent);
+  await writeFile(
+    root,
+    "locales/en.yml",
+    [
+      "description: English",
+      "formats:",
+      "  number:",
+      "    decimal:",
+      "      minimumFractionDigits: 2",
+      "      maximumFractionDigits: 2",
+      "",
+    ].join("\n"),
+  );
+  await writeFile(
+    root,
+    "targets/web.yml",
+    [
+      "description: Web",
+      "includeMessages:",
+      "  - auth*",
+      "locales:",
+      "  - en",
+      "formats:",
+      "  en:",
+      "    number:",
+      "      money:",
+      "        style: currency",
+      "        currency: USD",
+      "",
+    ].join("\n"),
+  );
+  await writeFile(
+    root,
+    "messages/auth/signin.yml",
+    [
+      "description: Sign in",
+      "translations:",
+      "  en: Sign in",
+      "overrides:",
+      "  - key: adult",
+      "    segments: adult",
+      "    translations:",
+      "      en: Adult sign in",
+      "",
+    ].join("\n"),
+  );
+  await writeFile(
+    root,
+    "segments/adult.yml",
+    [
+      "conditions:",
+      "  - attribute: age",
+      "    operator: greaterThanOrEquals",
+      "    value: 18",
+      "",
+    ].join("\n"),
+  );
+
+  return root;
+}
+
+describe("evaluatePlugin", function () {
+  it("evaluates segments using context without requiring a locale", async function () {
+    const root = await createProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(
+      evaluatePlugin.handler({
+        projectConfig,
+        datasource,
+        parsed: {
+          segment: "adult",
+          context: JSON.stringify({ age: 21 }),
+        },
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(logSpy).toHaveBeenCalledWith('Segment "adult" matched: true');
+    logSpy.mockRestore();
+  });
+
+  it("still requires locale for message evaluation", 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(
+        evaluatePlugin.handler({
+          projectConfig,
+          datasource,
+          parsed: {
+            message: "auth.signin",
+            context: JSON.stringify({}),
+          },
+        }),
+      ).resolves.toEqual(false);
+
+      expect(errorSpy).toHaveBeenCalledWith("Pass --locale=<locale>");
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it("evaluates messages with JSON values using project-configured modules", async function () {
+    const interpolationModulePath = path.join(
+      path.resolve(__dirname, "../../../.."),
+      "packages/module-interpolation/src/index.ts",
+    );
+    const root = await createProject(
+      [
+        `const { createInterpolationModule } = require(${JSON.stringify(interpolationModulePath)});`,
+        "module.exports = {",
+        "  modules: [createInterpolationModule()],",
+        "};",
+        "",
+      ].join("\n"),
+    );
+
+    await writeFile(
+      root,
+      "messages/auth/signin.yml",
+      ["description: Sign in", "translations:", "  en: Hello {name}", ""].join("\n"),
+    );
+
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(
+      evaluatePlugin.handler({
+        projectConfig,
+        datasource,
+        parsed: {
+          message: "auth.signin",
+          locale: "en",
+          values: JSON.stringify({ name: "Ada" }),
+        },
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(logSpy).toHaveBeenCalledWith("Hello Ada");
+    logSpy.mockRestore();
+  });
+
+  it("evaluates keyed messages with context and applies overrides without requiring a target", async function () {
+    const root = await createProject();
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(
+      evaluatePlugin.handler({
+        projectConfig,
+        datasource,
+        parsed: {
+          message: "auth.signin",
+          locale: "en",
+          context: JSON.stringify({ age: 21 }),
+        },
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(logSpy).toHaveBeenCalledWith("Adult sign in");
+    logSpy.mockRestore();
+  });
+
+  it("reports invalid values JSON clearly for message evaluation", 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(
+        evaluatePlugin.handler({
+          projectConfig,
+          datasource,
+          parsed: {
+            message: "auth.signin",
+            locale: "en",
+            values: "{not-json}",
+          },
+        }),
+      ).resolves.toEqual(false);
+
+      expect(errorSpy).toHaveBeenCalledWith("Invalid --values: expected valid JSON");
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it("evaluates raw messages with JSON values using project-configured modules", async function () {
+    const interpolationModulePath = path.join(
+      path.resolve(__dirname, "../../../.."),
+      "packages/module-interpolation/src/index.ts",
+    );
+    const root = await createProject(
+      [
+        `const { createInterpolationModule } = require(${JSON.stringify(interpolationModulePath)});`,
+        "module.exports = {",
+        "  modules: [createInterpolationModule()],",
+        "};",
+        "",
+      ].join("\n"),
+    );
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(
+      evaluatePlugin.handler({
+        projectConfig,
+        datasource,
+        parsed: {
+          rawMessage: "Hello {name}",
+          locale: "en",
+          values: JSON.stringify({ name: "Ada" }),
+        },
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(logSpy).toHaveBeenCalledWith("Hello Ada");
+    logSpy.mockRestore();
+  });
+
+  it("evaluates raw messages without target while still using locale formats", async function () {
+    const icuModulePath = path.join(
+      path.resolve(__dirname, "../../../.."),
+      "packages/module-icu/src/index.ts",
+    );
+    const root = await createProject(
+      [
+        `const { createICUModule } = require(${JSON.stringify(icuModulePath)});`,
+        "module.exports = {",
+        "  modules: [createICUModule()],",
+        "};",
+        "",
+      ].join("\n"),
+    );
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(
+      evaluatePlugin.handler({
+        projectConfig,
+        datasource,
+        parsed: {
+          rawMessage: "Amount: {amount, number, decimal}",
+          locale: "en",
+          values: JSON.stringify({ amount: 12 }),
+        },
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(logSpy).toHaveBeenCalledWith("Amount: 12.00");
+    logSpy.mockRestore();
+  });
+
+  it("evaluates raw messages with target using the target-specific datafile formats", async function () {
+    const icuModulePath = path.join(
+      path.resolve(__dirname, "../../../.."),
+      "packages/module-icu/src/index.ts",
+    );
+    const root = await createProject(
+      [
+        `const { createICUModule } = require(${JSON.stringify(icuModulePath)});`,
+        "module.exports = {",
+        "  modules: [createICUModule()],",
+        "};",
+        "",
+      ].join("\n"),
+    );
+    const projectConfig = getProjectConfig(root);
+    const datasource = new Datasource(projectConfig, root);
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    await expect(
+      evaluatePlugin.handler({
+        projectConfig,
+        datasource,
+        parsed: {
+          rawMessage: "Total: {amount, number, money}",
+          locale: "en",
+          target: "web",
+          values: JSON.stringify({ amount: 12 }),
+        },
+      }),
+    ).resolves.toBeUndefined();
+
+    expect(String(logSpy.mock.calls[0][0])).toContain("12");
+    expect(String(logSpy.mock.calls[0][0])).toContain("$");
+    logSpy.mockRestore();
+  });
+
+  it("still requires locale for raw message evaluation", 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(
+        evaluatePlugin.handler({
+          projectConfig,
+          datasource,
+          parsed: {
+            rawMessage: "Hello {name}",
+            values: JSON.stringify({ name: "Ada" }),
+          },
+        }),
+      ).resolves.toEqual(false);
+
+      expect(errorSpy).toHaveBeenCalledWith("Pass --locale=<locale>");
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+
+  it("rejects using message and rawMessage together", 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(
+        evaluatePlugin.handler({
+          projectConfig,
+          datasource,
+          parsed: {
+            message: "auth.signin",
+            rawMessage: "Hello {name}",
+            locale: "en",
+          },
+        }),
+      ).resolves.toEqual(false);
+
+      expect(errorSpy).toHaveBeenCalledWith(
+        "Pass either --message=<key> or --rawMessage=<message>, not both",
+      );
+    } finally {
+      errorSpy.mockRestore();
+    }
+  });
+});

package/src/evaluate/cli.ts

@@ -0,0 +1,130 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { createMessagevisor } from "@messagevisor/sdk";
+import type { Segment } from "@messagevisor/types";
+
+import { buildDatafile } from "../builder";
+import { MessagevisorCLIError, printMessagevisorCLIError } from "../error";
+import { getProjectSetExecutions } from "../sets";
+import { evaluateSegment } from "./index";
+
+async function readAllSegments(datasource: any) {
+  const segmentKeys = await datasource.listSegments();
+  const entries = await Promise.all(
+    segmentKeys.map(async (segmentKey: string) => {
+      const segment = (await datasource.readSegment(segmentKey)) as Segment;
+      return [segmentKey, segment] as const;
+    }),
+  );
+
+  return Object.fromEntries(entries);
+}
+
+function parseJsonOption(optionName: string, value: string) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new MessagevisorCLIError(`Invalid ${optionName}: expected valid JSON`);
+  }
+}
+
+export const evaluatePlugin = {
+  command: "evaluate",
+  handler: async ({ projectConfig, datasource, parsed }: any) => {
+    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 target = parsed.target;
+      const context = parsed.context ? parseJsonOption("--context", parsed.context) : {};
+      const values = parsed.values ? parseJsonOption("--values", parsed.values) : undefined;
+
+      if (parsed.message && parsed.rawMessage) {
+        throw new MessagevisorCLIError(
+          "Pass either --message=<key> or --rawMessage=<message>, not both",
+        );
+      }
+
+      if (parsed.segment) {
+        const segments = await readAllSegments(datasource);
+        const matched = evaluateSegment(parsed.segment, {
+          segments,
+          context,
+        });
+        const result = { segment: parsed.segment, matched };
+        console.log(
+          parsed.json
+            ? JSON.stringify(result, null, parsed.pretty ? 2 : 0)
+            : `Segment "${parsed.segment}" matched: ${matched}`,
+        );
+        return;
+      }
+
+      if (!parsed.locale) {
+        throw new MessagevisorCLIError("Pass --locale=<locale>");
+      }
+
+      const locale = parsed.locale;
+      const revision = await datasource.readRevision();
+      const datafile = await buildDatafile(projectConfig, datasource, target, locale, revision);
+      const messagevisor = createMessagevisor({
+        datafile,
+        context,
+        modules: projectConfig.modules || [],
+        logLevel: "warn",
+      });
+
+      if (parsed.message) {
+        const translation = messagevisor.translate(parsed.message, values, { context });
+        const result = { message: parsed.message, translation };
+        console.log(
+          parsed.json ? JSON.stringify(result, null, parsed.pretty ? 2 : 0) : translation,
+        );
+        return;
+      }
+
+      if (parsed.rawMessage) {
+        const translation = messagevisor.formatMessage(parsed.rawMessage, values);
+        const result = { rawMessage: parsed.rawMessage, translation };
+        console.log(
+          parsed.json ? JSON.stringify(result, null, parsed.pretty ? 2 : 0) : translation,
+        );
+        return;
+      }
+
+      throw new MessagevisorCLIError(
+        "Pass --message=<key>, --rawMessage=<message>, or --segment=<key>",
+      );
+    } catch (error) {
+      if (printMessagevisorCLIError(error)) {
+        return false;
+      }
+
+      throw error;
+    }
+  },
+  examples: [
+    {
+      command: "evaluate --message=auth.signin --locale=en-US",
+      description: "evaluate a message translation",
+    },
+    {
+      command: 'evaluate --message=dashboard.welcome --locale=en-US --values=\'{"name":"Ada"}\'',
+      description: "evaluate a message translation with JSON values",
+    },
+    {
+      command: 'evaluate --rawMessage="Hello {name}" --locale=en-US --values=\'{"name":"Ada"}\'',
+      description: "evaluate a raw message string with JSON values",
+    },
+    {
+      command: 'evaluate --segment=platform-web --context=\'{"platform":"web"}\'',
+      description: "evaluate a segment",
+    },
+  ],
+};

package/src/evaluate/index.ts

@@ -0,0 +1,161 @@
+import type { Condition, Context, GroupSegment, Segment } from "@messagevisor/types";
+
+export interface EvaluateConditionOptions {
+  context?: Context;
+  segments?: Record<string, Segment>;
+  resolveFlag?: (featureKey: string, context?: Context) => boolean;
+  resolveVariation?: (experimentKey: string, context?: Context) => string;
+}
+
+function getContextValue(context: Context | undefined, attribute: string) {
+  if (!context) {
+    return undefined;
+  }
+
+  return attribute
+    .split(".")
+    .reduce((value: any, part) => (value ? value[part] : undefined), context as any);
+}
+
+function compareDate(value: unknown, expected: unknown, operator: "before" | "after") {
+  const valueTime = new Date(value as any).getTime();
+  const expectedTime = new Date(expected as any).getTime();
+
+  if (Number.isNaN(valueTime) || Number.isNaN(expectedTime)) {
+    return false;
+  }
+
+  return operator === "before" ? valueTime < expectedTime : valueTime > expectedTime;
+}
+
+export function evaluateCondition(
+  condition: Condition | Condition[] | "*" | undefined,
+  options: EvaluateConditionOptions = {},
+): boolean {
+  if (!condition || condition === "*") {
+    return true;
+  }
+
+  if (Array.isArray(condition)) {
+    return condition.every((item) => evaluateCondition(item, options));
+  }
+
+  if (typeof condition === "string") {
+    return evaluateSegment(condition, options);
+  }
+
+  if ("and" in condition) {
+    return condition.and.every((item) => evaluateCondition(item, options));
+  }
+
+  if ("or" in condition) {
+    return condition.or.some((item) => evaluateCondition(item, options));
+  }
+
+  if ("not" in condition) {
+    return !condition.not.every((item) => evaluateCondition(item, options));
+  }
+
+  if ("feature" in condition) {
+    const enabled = options.resolveFlag
+      ? options.resolveFlag(condition.feature, options.context)
+      : false;
+    return condition.operator === "isEnabled"
+      ? enabled
+      : condition.operator === "isDisabled"
+        ? !enabled
+        : false;
+  }
+
+  if ("experiment" in condition) {
+    const variation = options.resolveVariation
+      ? options.resolveVariation(condition.experiment, options.context)
+      : undefined;
+    return condition.operator === "hasVariation" ? variation === condition.value : false;
+  }
+
+  const value = getContextValue(options.context, condition.attribute);
+  const expected = condition.value;
+
+  switch (condition.operator) {
+    case "equals":
+      return value === expected;
+    case "notEquals":
+      return value !== expected;
+    case "exists":
+      return value !== undefined && value !== null;
+    case "notExists":
+      return value === undefined || value === null;
+    case "greaterThan":
+      return Number(value) > Number(expected);
+    case "greaterThanOrEquals":
+      return Number(value) >= Number(expected);
+    case "lessThan":
+      return Number(value) < Number(expected);
+    case "lessThanOrEquals":
+      return Number(value) <= Number(expected);
+    case "contains":
+      return String(value).includes(String(expected));
+    case "notContains":
+      return !String(value).includes(String(expected));
+    case "startsWith":
+      return String(value).startsWith(String(expected));
+    case "endsWith":
+      return String(value).endsWith(String(expected));
+    case "before":
+      return compareDate(value, expected, "before");
+    case "after":
+      return compareDate(value, expected, "after");
+    case "includes":
+      return Array.isArray(value) && value.includes(expected as any);
+    case "notIncludes":
+      return !Array.isArray(value) || !value.includes(expected as any);
+    case "in":
+      return Array.isArray(expected) && expected.includes(value as any);
+    case "notIn":
+      return !Array.isArray(expected) || !expected.includes(value as any);
+    default:
+      return false;
+  }
+}
+
+export function evaluateGroupSegment(
+  groupSegment: GroupSegment | GroupSegment[] | "*" | undefined,
+  options: EvaluateConditionOptions = {},
+): boolean {
+  if (!groupSegment || groupSegment === "*") {
+    return true;
+  }
+
+  if (Array.isArray(groupSegment)) {
+    return groupSegment.every((item) => evaluateGroupSegment(item, options));
+  }
+
+  if (typeof groupSegment === "string") {
+    return evaluateSegment(groupSegment, options);
+  }
+
+  if ("and" in groupSegment) {
+    return groupSegment.and.every((item) => evaluateGroupSegment(item, options));
+  }
+
+  if ("or" in groupSegment) {
+    return groupSegment.or.some((item) => evaluateGroupSegment(item, options));
+  }
+
+  if ("not" in groupSegment) {
+    return !groupSegment.not.every((item) => evaluateGroupSegment(item, options));
+  }
+
+  return false;
+}
+
+export function evaluateSegment(segmentKey: string, options: EvaluateConditionOptions = {}) {
+  const segment = options.segments ? options.segments[segmentKey] : undefined;
+
+  if (!segment || segment.archived) {
+    return false;
+  }
+
+  return evaluateCondition(segment.conditions, options);
+}