@messagevisor/core 0.0.1 → 0.1.0

package/src/linter/checkLocaleCircularDependency.ts

@@ -0,0 +1,51 @@
+import type { Locale } from "@messagevisor/types";
+
+export type LocaleInheritanceField =
+  | "inheritFormatsFrom"
+  | "inheritTranslationsFrom"
+  | "mergeExamplesFrom";
+
+export interface LocaleCircularDependency {
+  field: LocaleInheritanceField;
+  cycle: string[];
+}
+
+export function checkLocaleCircularDependency(
+  localesByKey: Record<string, Locale>,
+  field: LocaleInheritanceField,
+): LocaleCircularDependency[] {
+  const cycles: LocaleCircularDependency[] = [];
+  const reportedCycles = new Set<string>();
+
+  for (const localeKey of Object.keys(localesByKey)) {
+    const path: string[] = [];
+    const seenInPath = new Map<string, number>();
+    let currentKey: string | undefined = localeKey;
+
+    while (currentKey) {
+      if (seenInPath.has(currentKey)) {
+        const cycle = [...path.slice(seenInPath.get(currentKey)), currentKey];
+        const normalizedKey = cycle.slice(0, -1).sort().join(">");
+
+        if (!reportedCycles.has(normalizedKey)) {
+          reportedCycles.add(normalizedKey);
+          cycles.push({ field, cycle });
+        }
+
+        break;
+      }
+
+      const locale = localesByKey[currentKey];
+
+      if (!locale) {
+        break;
+      }
+
+      seenInPath.set(currentKey, path.length);
+      path.push(currentKey);
+      currentKey = locale[field];
+    }
+  }
+
+  return cycles;
+}

package/src/linter/conditionSchema.ts

@@ -0,0 +1,386 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import type { Attribute } from "@messagevisor/types";
+import { z } from "zod";
+
+import { refineWithMessage } from "./zodHelpers";
+
+const commonOperators = ["equals", "notEquals"];
+const numericOperators = ["greaterThan", "greaterThanOrEquals", "lessThan", "lessThanOrEquals"];
+const stringOperators = ["contains", "notContains", "startsWith", "endsWith"];
+const dateOperators = ["before", "after"];
+const arrayOperators = ["includes", "notIncludes"];
+const membershipOperators = ["in", "notIn"];
+const operatorsWithoutValue = ["exists", "notExists"];
+const featureOperators = ["isEnabled", "isDisabled"];
+const experimentOperators = ["hasVariation"];
+
+type SchemaNode = Attribute & {
+  type?: string;
+  properties?: Record<string, SchemaNode>;
+  additionalProperties?: SchemaNode;
+  oneOf?: SchemaNode[];
+};
+type ResolvedLeaf = { kind: "schema"; schema: SchemaNode } | { kind: "flat-object-property" };
+
+function isPrimitiveValue(value: unknown): boolean {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+
+function valuesEqual(left: unknown, right: unknown): boolean {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
+
+function resolveAttributePath(
+  attributePath: string,
+  attributesByKey: Record<string, Attribute>,
+): ResolvedLeaf | null {
+  const [rootKey, ...rest] = attributePath.split(".");
+  const rootAttribute = attributesByKey[rootKey];
+
+  if (!rootAttribute) {
+    return null;
+  }
+
+  let current: SchemaNode = rootAttribute;
+
+  if (rest.length === 0) {
+    return { kind: "schema", schema: current };
+  }
+
+  for (let index = 0; index < rest.length; index++) {
+    const segment = rest[index];
+
+    if (current.type !== "object") {
+      return null;
+    }
+
+    if (current.properties && current.properties[segment]) {
+      current = current.properties[segment];
+      continue;
+    }
+
+    if (!current.properties && !current.additionalProperties) {
+      return index === rest.length - 1 ? { kind: "flat-object-property" } : null;
+    }
+
+    if (current.additionalProperties) {
+      current = current.additionalProperties;
+      continue;
+    }
+
+    return null;
+  }
+
+  return { kind: "schema", schema: current };
+}
+
+function getLeafTypes(leaf: ResolvedLeaf): string[] {
+  if (leaf.kind === "flat-object-property") {
+    return ["primitive"];
+  }
+
+  if (leaf.schema.oneOf) {
+    return Array.from(
+      new Set(
+        leaf.schema.oneOf.flatMap((branch) =>
+          getLeafTypes({ kind: "schema", schema: branch as SchemaNode }),
+        ),
+      ),
+    );
+  }
+
+  return leaf.schema.type ? [leaf.schema.type] : [];
+}
+
+function matchesSchemaValue(schema: SchemaNode, value: unknown): boolean {
+  if (schema.oneOf) {
+    return (
+      schema.oneOf.filter((branch) => matchesSchemaValue(branch as SchemaNode, value)).length === 1
+    );
+  }
+
+  if (schema.const !== undefined) {
+    return valuesEqual(schema.const, value);
+  }
+
+  if (schema.enum) {
+    return schema.enum.some((entry) => valuesEqual(entry, value));
+  }
+
+  if (!schema.type) {
+    return true;
+  }
+
+  if (schema.type === "string" || schema.type === "date") {
+    if (typeof value !== "string" && !(value instanceof Date)) return false;
+    const stringValue = value instanceof Date ? value.toISOString() : value;
+    if (schema.minLength !== undefined && stringValue.length < schema.minLength) return false;
+    if (schema.maxLength !== undefined && stringValue.length > schema.maxLength) return false;
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(stringValue)) return false;
+    return true;
+  }
+
+  if (schema.type === "boolean") {
+    return typeof value === "boolean";
+  }
+
+  if (schema.type === "integer" || schema.type === "double") {
+    if (typeof value !== "number") return false;
+    if (schema.type === "integer" && !Number.isInteger(value)) return false;
+    if (schema.minimum !== undefined && value < schema.minimum) return false;
+    if (schema.maximum !== undefined && value > schema.maximum) return false;
+    return true;
+  }
+
+  if (schema.type === "array") {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+  }
+
+  if (schema.type === "object") {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+
+  return true;
+}
+
+function matchesLeafValue(leaf: ResolvedLeaf, value: unknown): boolean {
+  if (leaf.kind === "flat-object-property") {
+    return isPrimitiveValue(value);
+  }
+
+  return matchesSchemaValue(leaf.schema, value);
+}
+
+function addIssue(ctx: z.RefinementCtx, message: string, path: (string | number)[] = ["value"]) {
+  ctx.addIssue({
+    code: z.ZodIssueCode.custom,
+    message,
+    path,
+  });
+}
+
+function validateAttributeAwareCondition(
+  data: { attribute: string; operator: string; value?: unknown },
+  ctx: z.RefinementCtx,
+  attributesByKey: Record<string, Attribute>,
+) {
+  const leaf = resolveAttributePath(data.attribute, attributesByKey);
+
+  if (!leaf) {
+    return;
+  }
+
+  const leafTypes = getLeafTypes(leaf);
+
+  if (operatorsWithoutValue.includes(data.operator)) {
+    return;
+  }
+
+  if (leaf.kind === "schema" && leaf.schema.type === "object") {
+    addIssue(
+      ctx,
+      `Attribute "${data.attribute}" resolves to an object. Use a nested attribute path or \`exists\`/\`notExists\`.`,
+    );
+    return;
+  }
+
+  if (
+    numericOperators.includes(data.operator) &&
+    !leafTypes.some((type) => ["integer", "double"].includes(type))
+  ) {
+    addIssue(
+      ctx,
+      `Operator "${data.operator}" can only be used with integer or double attributes.`,
+    );
+    return;
+  }
+
+  if (
+    stringOperators.includes(data.operator) &&
+    !leafTypes.some((type) => ["string", "date"].includes(type))
+  ) {
+    addIssue(ctx, `Operator "${data.operator}" can only be used with string or date attributes.`);
+    return;
+  }
+
+  if (
+    dateOperators.includes(data.operator) &&
+    !leafTypes.some((type) => ["string", "date"].includes(type))
+  ) {
+    addIssue(ctx, `Operator "${data.operator}" can only be used with string or date attributes.`);
+    return;
+  }
+
+  if (arrayOperators.includes(data.operator)) {
+    if (!leafTypes.includes("array")) {
+      addIssue(ctx, `Operator "${data.operator}" can only be used with array attributes.`);
+      return;
+    }
+
+    if (typeof data.value !== "string") {
+      addIssue(ctx, `Operator "${data.operator}" only supports string values.`);
+    }
+
+    return;
+  }
+
+  if (membershipOperators.includes(data.operator)) {
+    if (!Array.isArray(data.value)) {
+      return;
+    }
+
+    data.value.forEach((entry, index) => {
+      if (!matchesLeafValue(leaf, entry)) {
+        addIssue(
+          ctx,
+          `Value at index ${index} does not match the schema of attribute "${data.attribute}".`,
+          ["value", index],
+        );
+      }
+    });
+
+    return;
+  }
+
+  if (
+    commonOperators.includes(data.operator) &&
+    data.value !== null &&
+    !matchesLeafValue(leaf, data.value)
+  ) {
+    addIssue(ctx, `Value does not match the schema of attribute "${data.attribute}".`);
+  }
+}
+
+export function getConditionsZodSchema(attributesByKey: Record<string, Attribute>) {
+  type ConditionInput = any;
+
+  const conditionZodSchema: z.ZodType<ConditionInput> = z.lazy(() => {
+    const attributeCondition = z
+      .object({
+        attribute: refineWithMessage(
+          z.string(),
+          (value) => resolveAttributePath(value, attributesByKey) !== null,
+          (value) => `Unknown attribute "${value}"`,
+        ),
+        operator: z.enum([
+          ...commonOperators,
+          ...numericOperators,
+          ...stringOperators,
+          ...dateOperators,
+          ...arrayOperators,
+          ...membershipOperators,
+          ...operatorsWithoutValue,
+        ]),
+        value: z
+          .union([
+            z.string(),
+            z.array(z.union([z.string(), z.number(), z.boolean(), z.null()])),
+            z.number(),
+            z.boolean(),
+            z.date(),
+            z.null(),
+          ])
+          .optional(),
+        regexFlags: z.never().optional(),
+      })
+      .strict()
+      .superRefine((data, ctx) => {
+        if (operatorsWithoutValue.includes(data.operator) && typeof data.value !== "undefined") {
+          addIssue(ctx, `when operator is "${data.operator}", value must not be provided`);
+        }
+
+        if (!operatorsWithoutValue.includes(data.operator) && typeof data.value === "undefined") {
+          addIssue(ctx, `when operator is "${data.operator}", value must be provided`);
+        }
+
+        if (numericOperators.includes(data.operator) && typeof data.value !== "number") {
+          addIssue(ctx, `when operator is "${data.operator}", value must be a number`);
+        }
+
+        if (
+          [...stringOperators, ...dateOperators, ...arrayOperators].includes(data.operator) &&
+          typeof data.value !== "string"
+        ) {
+          addIssue(ctx, `when operator is "${data.operator}", value must be a string`);
+        }
+
+        if (membershipOperators.includes(data.operator) && !Array.isArray(data.value)) {
+          addIssue(ctx, `when operator is "${data.operator}", value must be an array`);
+        }
+
+        validateAttributeAwareCondition(data, ctx, attributesByKey);
+      });
+
+    const featureCondition = z
+      .object({
+        feature: z.string(),
+        operator: z.string(),
+        attribute: z.never().optional(),
+        experiment: z.never().optional(),
+        value: z.unknown().optional(),
+        regexFlags: z.never().optional(),
+      })
+      .strict()
+      .superRefine((data, ctx) => {
+        if (!featureOperators.includes(data.operator)) {
+          addIssue(ctx, `Feature conditions only support operators "isEnabled" and "isDisabled".`, [
+            "operator",
+          ]);
+        }
+
+        if (typeof data.value !== "undefined") {
+          addIssue(
+            ctx,
+            `Feature conditions must not define \`value\`; the flag state comes from resolveFlag.`,
+            ["value"],
+          );
+        }
+      });
+
+    const experimentCondition = z
+      .object({
+        experiment: z.string(),
+        operator: z.string(),
+        value: z.unknown().optional(),
+        attribute: z.never().optional(),
+        feature: z.never().optional(),
+        regexFlags: z.never().optional(),
+      })
+      .strict()
+      .superRefine((data, ctx) => {
+        if (data.operator !== "hasVariation") {
+          addIssue(ctx, `Experiment conditions only support operator "hasVariation".`, [
+            "operator",
+          ]);
+        }
+
+        if (typeof data.value === "undefined") {
+          addIssue(
+            ctx,
+            `Experiment conditions must define \`value\` with the expected variation.`,
+            ["value"],
+          );
+          return;
+        }
+
+        if (typeof data.value !== "string") {
+          addIssue(ctx, `Experiment condition \`value\` must be a string variation.`, ["value"]);
+        }
+      });
+
+    const andCondition = z.object({ and: z.array(conditionZodSchema).min(1) }).strict();
+    const orCondition = z.object({ or: z.array(conditionZodSchema).min(1) }).strict();
+    const notCondition = z.object({ not: z.array(conditionZodSchema).min(1) }).strict();
+
+    return z.union([
+      attributeCondition,
+      featureCondition,
+      experimentCondition,
+      andCondition,
+      orCondition,
+      notCondition,
+    ]);
+  });
+
+  return z.union([z.literal("*"), conditionZodSchema, z.array(conditionZodSchema).min(1)]);
+}

package/src/linter/formatSchema.ts

@@ -0,0 +1,170 @@
+import { z } from "zod";
+
+const numberShared = {
+  useGrouping: z.union([z.boolean(), z.enum(["min2", "auto", "always"])]).optional(),
+  minimumIntegerDigits: z.number().int().nonnegative().optional(),
+  minimumFractionDigits: z.number().int().nonnegative().optional(),
+  maximumFractionDigits: z.number().int().nonnegative().optional(),
+  minimumSignificantDigits: z.number().int().nonnegative().optional(),
+  maximumSignificantDigits: z.number().int().nonnegative().optional(),
+  notation: z.enum(["standard", "scientific", "engineering", "compact"]).optional(),
+  compactDisplay: z.enum(["short", "long"]).optional(),
+  signDisplay: z.enum(["auto", "never", "always", "exceptZero", "negative"]).optional(),
+  roundingPriority: z.enum(["auto", "morePrecision", "lessPrecision"]).optional(),
+  roundingIncrement: z
+    .union([
+      z.literal(1),
+      z.literal(2),
+      z.literal(5),
+      z.literal(10),
+      z.literal(20),
+      z.literal(25),
+      z.literal(50),
+      z.literal(100),
+      z.literal(200),
+      z.literal(250),
+      z.literal(500),
+      z.literal(1000),
+      z.literal(2000),
+      z.literal(2500),
+      z.literal(5000),
+    ])
+    .optional(),
+  roundingMode: z
+    .enum([
+      "ceil",
+      "floor",
+      "expand",
+      "trunc",
+      "halfCeil",
+      "halfFloor",
+      "halfExpand",
+      "halfTrunc",
+      "halfEven",
+    ])
+    .optional(),
+  trailingZeroDisplay: z.enum(["auto", "stripIfInteger"]).optional(),
+  numberingSystem: z.string().optional(),
+};
+
+const numberPresetZodSchema = z
+  .object({
+    ...numberShared,
+    style: z.enum(["decimal", "currency", "percent", "unit"]).optional(),
+    currency: z.string().optional(),
+    currencyDisplay: z.enum(["code", "symbol", "narrowSymbol", "name"]).optional(),
+    currencySign: z.enum(["standard", "accounting"]).optional(),
+    unit: z.string().optional(),
+    unitDisplay: z.enum(["short", "narrow", "long"]).optional(),
+  })
+  .strict()
+  .superRefine((data, ctx) => {
+    if (data.style !== "currency" && (data.currency || data.currencyDisplay || data.currencySign)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Currency options can only be used when \`style\` is "currency".`,
+        path: ["style"],
+      });
+    }
+
+    if (data.style === "unit" && !data.unit) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Unit number formats must define \`unit\`.`,
+        path: ["unit"],
+      });
+    }
+
+    if (data.style !== "unit" && (data.unit || data.unitDisplay)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `Unit options can only be used when \`style\` is "unit".`,
+        path: ["style"],
+      });
+    }
+
+    if (data.notation !== "compact" && data.compactDisplay) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `\`compactDisplay\` can only be used when \`notation\` is "compact".`,
+        path: ["notation"],
+      });
+    }
+  });
+
+const dateTimePresetZodSchema = z
+  .object({
+    timeZone: z.string().optional(),
+    calendar: z.string().optional(),
+    numberingSystem: z.string().optional(),
+    hour12: z.boolean().optional(),
+    hourCycle: z.enum(["h11", "h12", "h23", "h24"]).optional(),
+    dateStyle: z.enum(["full", "long", "medium", "short"]).optional(),
+    timeStyle: z.enum(["full", "long", "medium", "short"]).optional(),
+    formatMatcher: z.enum(["basic", "best fit"]).optional(),
+    fractionalSecondDigits: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional(),
+    weekday: z.enum(["long", "short", "narrow"]).optional(),
+    era: z.enum(["long", "short", "narrow"]).optional(),
+    year: z.enum(["numeric", "2-digit"]).optional(),
+    month: z.enum(["numeric", "2-digit", "long", "short", "narrow"]).optional(),
+    day: z.enum(["numeric", "2-digit"]).optional(),
+    dayPeriod: z.enum(["long", "short", "narrow"]).optional(),
+    hour: z.enum(["numeric", "2-digit"]).optional(),
+    minute: z.enum(["numeric", "2-digit"]).optional(),
+    second: z.enum(["numeric", "2-digit"]).optional(),
+    timeZoneName: z
+      .enum(["long", "short", "shortOffset", "longOffset", "shortGeneric", "longGeneric"])
+      .optional(),
+  })
+  .strict()
+  .superRefine((data, ctx) => {
+    const hasStyleShortcut =
+      typeof data.dateStyle !== "undefined" || typeof data.timeStyle !== "undefined";
+    const hasGranularFields = [
+      "weekday",
+      "era",
+      "year",
+      "month",
+      "day",
+      "dayPeriod",
+      "hour",
+      "minute",
+      "second",
+      "fractionalSecondDigits",
+      "timeZoneName",
+    ].some((field) => typeof data[field as keyof typeof data] !== "undefined");
+
+    if (hasStyleShortcut && hasGranularFields) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message:
+          "`dateStyle` / `timeStyle` cannot be combined with granular date/time component fields.",
+        path: ["dateStyle"],
+      });
+    }
+
+    if (hasStyleShortcut && typeof data.formatMatcher !== "undefined") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "`formatMatcher` cannot be combined with `dateStyle` / `timeStyle`.",
+        path: ["formatMatcher"],
+      });
+    }
+  });
+
+const relativeTimePresetZodSchema = z
+  .object({
+    numeric: z.enum(["always", "auto"]).optional(),
+    style: z.enum(["long", "short", "narrow"]).optional(),
+  })
+  .strict();
+
+export const formatPresetsZodSchema = z
+  .object({
+    number: z.record(z.string(), numberPresetZodSchema).optional(),
+    date: z.record(z.string(), dateTimePresetZodSchema).optional(),
+    time: z.record(z.string(), dateTimePresetZodSchema).optional(),
+    relative: z.record(z.string(), relativeTimePresetZodSchema).optional(),
+    dateTimeRange: z.record(z.string(), dateTimePresetZodSchema).optional(),
+  })
+  .strict();