intor-cli 0.0.8 → 0.0.10

package/src/features/validate/replacements/validate-replacements-schema.ts

@@ -0,0 +1,51 @@
+import type { InferNode } from "../../../core";
+import type { ValidationResult } from "../validate-locale-messages";
+import type { MessageObject } from "intor";
+import { extractInterpolationNames } from "../../../core";
+
+export function validateReplacementsSchema(
+  schema: InferNode,
+  messages: MessageObject,
+  path: string,
+  result: ValidationResult,
+) {
+  // Only object schemas define required message keys
+  if (schema.kind !== "object") return;
+
+  // Traverse schema-defined keys and validate message presence
+  for (const key of Object.keys(schema.properties)) {
+    const nextPath = path ? `${path}.${key}` : key;
+    const expected = schema.properties[key];
+    const value = messages[key];
+
+    // Schema requires this key, but message does not provide it
+    if (value === undefined) continue;
+
+    // ------------------------------------------------------------
+    // Leaf string message: validate interpolation replacements
+    // ------------------------------------------------------------
+    if (typeof value === "string") {
+      if (expected.kind !== "object") continue;
+
+      const actualNames = extractInterpolationNames(value);
+
+      // Report any schema-required replacements missing in the message
+      for (const name of Object.keys(expected.properties)) {
+        if (actualNames.includes(name)) continue;
+        result.missingReplacements.push({ key: nextPath, name });
+      }
+
+      continue;
+    }
+
+    // Recurse into nested message objects
+    if (typeof value === "object" && value !== null) {
+      validateReplacementsSchema(
+        expected,
+        value as MessageObject,
+        nextPath,
+        result,
+      );
+    }
+  }
+}

package/src/features/validate/rich/index.ts

@@ -0,0 +1 @@
+export { validateRichSchema } from "./validate-rich-schema";

package/src/features/validate/rich/validate-rich-schema.ts

@@ -0,0 +1,48 @@
+import type { InferNode } from "../../../core";
+import type { ValidationResult } from "../validate-locale-messages";
+import { tokenize, type MessageObject, type Token } from "intor";
+
+export function validateRichSchema(
+  schema: InferNode,
+  messages: MessageObject,
+  path: string,
+  result: ValidationResult,
+) {
+  // Only object schemas define expected rich tags
+  if (schema.kind !== "object") return;
+
+  // Traverse schema-defined keys
+  for (const key of Object.keys(schema.properties)) {
+    const nextPath = path ? `${path}.${key}` : key;
+    const expected = schema.properties[key];
+    const value = messages[key];
+
+    // Schema requires this key, but message does not provide it
+    if (value === undefined) continue;
+
+    // --------------------------------------------------
+    // Leaf string message: validate rich tags
+    // --------------------------------------------------
+    if (typeof value === "string") {
+      if (expected.kind !== "object") continue;
+
+      const tokens: Token[] = tokenize(value);
+      const actualTags = new Set(
+        tokens.filter((t) => t.type === "tag-open").map((t) => t.name),
+      );
+
+      // Report any schema-required rich tags missing in the message
+      for (const tag of Object.keys(expected.properties)) {
+        if (actualTags.has(tag)) continue;
+        result.missingRichTags.push({ key: nextPath, tag });
+      }
+
+      continue;
+    }
+
+    // Recurse into nested message objects
+    if (typeof value === "object" && value !== null) {
+      validateRichSchema(expected, value as MessageObject, nextPath, result);
+    }
+  }
+}

package/src/features/validate/validate-locale-messages.ts

@@ -0,0 +1,38 @@
+import type { InferredSchemas } from "../../core";
+import type { MessageObject } from "intor";
+import { validateMessagesSchema } from "./messages";
+import { validateReplacementsSchema } from "./replacements";
+import { validateRichSchema } from "./rich";
+
+export interface ValidationResult {
+  missingKeys: string[];
+  missingReplacements: Array<{ key: string; name: string }>;
+  missingRichTags: Array<{ key: string; tag: string }>;
+}
+
+/**
+ * Validate a locale's messages against inferred semantic schemas.
+ */
+export function validateLocaleMessages(
+  schemas: InferredSchemas,
+  localeMessages: MessageObject,
+): ValidationResult {
+  const result: ValidationResult = {
+    missingKeys: [],
+    missingReplacements: [],
+    missingRichTags: [],
+  };
+
+  validateMessagesSchema(schemas.messagesSchema, localeMessages, "", result);
+
+  validateReplacementsSchema(
+    schemas.replacementsSchema,
+    localeMessages,
+    "",
+    result,
+  );
+
+  validateRichSchema(schemas.richSchema, localeMessages, "", result);
+
+  return result;
+}

package/src/features/validate/validate.ts

@@ -0,0 +1,84 @@
+/* eslint-disable unicorn/no-process-exit */
+import { discoverConfigs, readSchema, type ExtraExt } from "../../core";
+import { collectOtherLocaleMessages } from "../../core";
+import { printMissingSchema, printTitle } from "../print";
+import { spinner } from "../spinner";
+import { printSummary } from "./print-summary";
+import {
+  validateLocaleMessages,
+  type ValidationResult,
+} from "./validate-locale-messages";
+
+export interface ValidateOptions {
+  exts?: Array<ExtraExt>;
+  customReaders?: Record<string, string>;
+  debug?: boolean;
+}
+
+export async function validate({
+  exts = [],
+  customReaders,
+  debug,
+}: ValidateOptions) {
+  printTitle("Validating intor translations");
+  spinner.start();
+
+  // -----------------------------------------------------------------------
+  // Discover configs from the current workspace
+  // -----------------------------------------------------------------------
+  const configEntries = await discoverConfigs(debug);
+  if (configEntries.length === 0) {
+    spinner.stop();
+    throw new Error("No Intor config found.");
+  }
+
+  try {
+    // -----------------------------------------------------------------------
+    // Read generated schema
+    // -----------------------------------------------------------------------
+    const schema = await readSchema();
+
+    const resultsByConfig: Record<
+      string,
+      Record<string, ValidationResult>
+    > = {};
+
+    // Per-config processing
+    for (const { config } of configEntries) {
+      const schemaConfig = schema.configs.find((c) => c.id === config.id);
+      if (!schemaConfig) {
+        spinner.stop();
+        printMissingSchema(config.id);
+        spinner.start();
+        continue;
+      }
+
+      // Load all non-default locale messages
+      const localeMessages = await collectOtherLocaleMessages(
+        config,
+        exts,
+        customReaders,
+      );
+
+      const results: Record<string, ValidationResult> = {};
+      for (const locale of config.supportedLocales) {
+        if (locale === config.defaultLocale) continue;
+        const messages = localeMessages[locale];
+        if (!messages) continue;
+        results[locale] = validateLocaleMessages(
+          schemaConfig.schemas,
+          messages,
+        );
+      }
+
+      resultsByConfig[config.id] = results;
+    }
+
+    spinner.stop();
+    printSummary(resultsByConfig);
+  } catch (error) {
+    spinner.stop();
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

package/src/core/constants/generated-files.ts

@@ -1,3 +0,0 @@
-export const DEFAULT_OUT_DIR = ".intor";
-export const DEFAULT_TYPES_FILE = "intor-generated-types.d.ts";
-export const DEFAULT_SCHEMA_FILE = "intor-generated.schema.json";

package/src/core/read-generated-schema.ts

@@ -1,42 +0,0 @@
-import type { GeneratedSchema } from "../build";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { DEFAULT_OUT_DIR, DEFAULT_SCHEMA_FILE } from "./constants";
-
-export interface ReadGeneratedSchemaOptions {
-  cwd?: string;
-  outDir?: string;
-  fileName?: string;
-}
-
-export async function readGeneratedSchema(
-  options: ReadGeneratedSchemaOptions = {},
-): Promise<GeneratedSchema> {
-  const {
-    cwd = process.cwd(),
-    outDir = DEFAULT_OUT_DIR,
-    fileName = DEFAULT_SCHEMA_FILE,
-  } = options;
-
-  const schemaPath = path.resolve(cwd, outDir, fileName);
-
-  let raw: string;
-
-  // Try to read
-  try {
-    raw = await fs.readFile(schemaPath, "utf8");
-  } catch {
-    throw new Error(
-      `Failed to read intor schema file at "${schemaPath}".\n Have you run "intor generate"?`,
-    );
-  }
-
-  // Try to parse
-  try {
-    return JSON.parse(raw) as GeneratedSchema;
-  } catch {
-    throw new Error(
-      `Invalid JSON format in intor schema file at "${schemaPath}".`,
-    );
-  }
-}

package/src/core/write-generated-files.ts

@@ -1,51 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import {
-  DEFAULT_OUT_DIR,
-  DEFAULT_TYPES_FILE,
-  DEFAULT_SCHEMA_FILE,
-} from "./constants";
-
-export interface WriteOptions {
-  cwd?: string;
-  outDir?: string;
-  typesFileName?: string;
-  schemaFileName?: string;
-}
-
-export interface WriteGeneratedFilesResult {
-  outDir: string;
-  typesPath: string;
-  schemaPath: string;
-}
-
-export async function writeGeneratedFiles(
-  { types, schema }: { types: string; schema: unknown },
-  options: WriteOptions = {},
-): Promise<WriteGeneratedFilesResult> {
-  const {
-    cwd = process.cwd(),
-    outDir = DEFAULT_OUT_DIR,
-    typesFileName = DEFAULT_TYPES_FILE,
-    schemaFileName = DEFAULT_SCHEMA_FILE,
-  } = options;
-
-  const resolvedOutDir = path.resolve(cwd, outDir);
-  const typesPath = path.join(resolvedOutDir, typesFileName);
-  const schemaPath = path.join(resolvedOutDir, schemaFileName);
-
-  // Ensure .intor directory exists
-  await fs.mkdir(resolvedOutDir, { recursive: true });
-
-  // Write types (as-is)
-  await fs.writeFile(typesPath, types, "utf8");
-
-  // Write schema (pretty JSON for diff / debug)
-  await fs.writeFile(schemaPath, JSON.stringify(schema, null, 2), "utf8");
-
-  return {
-    outDir: resolvedOutDir,
-    typesPath,
-    schemaPath,
-  };
-}

package/src/features/print-title.ts

@@ -1,7 +0,0 @@
-import pc from "picocolors";
-
-export function printTitle(title: string) {
-  console.log();
-  console.log(pc.bgBlack(` • ${title} `));
-  console.log();
-}