@toolproof-core/schema 1.0.16 → 1.0.17

package/src/scripts/generateStandaloneZodSchema.ts

@@ -0,0 +1,139 @@
+import fs from 'fs';
+import path from 'path';
+import { getConfig } from './_lib/config.js';
+import { jsonSchemaToZodExpressions } from './_lib/utils/jsonSchemaToZod.js';
+
+/**
+ * Generate a Zod v4 validator module from a standalone schema JSON file.
+ *
+ * Usage:
+ *   node ./dist/scripts/generateStandaloneZodSchema.js --name <DefName>
+ */
+
+function stripSurroundingQuotes(value: string): string {
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function parseArgs(args: string[]): { name?: string } {
+  let name: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--name') {
+      name = args[i + 1];
+      i++;
+    } else if (a.startsWith('--name=')) {
+      name = a.split('=')[1];
+    }
+  }
+  const normalized = typeof name === 'string' ? stripSurroundingQuotes(name) : undefined;
+  return { name: normalized?.trim() ? normalized : undefined };
+}
+
+function isValidIdentifier(name: string): boolean {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name);
+}
+
+function toIdentifier(name: string): string {
+  // Standalone def names in Genesis are already identifier-friendly.
+  // We still sanitize minimally to avoid codegen footguns.
+  let out = name.replace(/[^A-Za-z0-9_]/g, '_');
+  if (!/^[A-Za-z_]/.test(out)) out = '_' + out;
+  return out;
+}
+
+function emitHeader(name: string): string {
+  return (
+    `// Auto-generated from standalone schema '${name}'. Do not edit.\n` +
+    `import { z } from 'zod/v4';\n\n`
+  );
+}
+
+function emitModule(name: string, expressionsByName: Record<string, string>, warnings: Array<{ path: string; message: string }>): string {
+  const lines: string[] = [];
+  lines.push(emitHeader(name));
+
+  if (warnings.length > 0) {
+    const warningsName = `${toIdentifier(name)}ZodGenerationWarnings`;
+    lines.push(`export const ${warningsName} = ` + JSON.stringify(warnings, null, 2) + ' as const;\n');
+  }
+
+  const rootIdent = toIdentifier(name);
+
+  // Emit file-local defs first (not exported) to avoid name collisions across modules.
+  const defNames = Object.keys(expressionsByName)
+    .filter((n) => n !== name)
+    .sort((a, b) => a.localeCompare(b));
+
+  for (const schemaName of defNames) {
+    const ident = toIdentifier(schemaName);
+    if (!isValidIdentifier(ident)) {
+      throw new Error(`Invalid generated identifier for schema '${schemaName}': '${ident}'`);
+    }
+    const expr = expressionsByName[schemaName];
+    lines.push(`const ${ident}Schema: z.ZodTypeAny = z.lazy(() => ${expr});`);
+  }
+
+  lines.push('');
+
+  // Export only the root schema.
+  const rootExpr = expressionsByName[name];
+  lines.push(`export const ${rootIdent}Schema: z.ZodTypeAny = z.lazy(() => ${rootExpr});`);
+
+  return lines.join('\n') + '\n';
+}
+
+function writeBarrelFile(zodDir: string) {
+  const entries = fs
+    .readdirSync(zodDir)
+    .filter((f) => f.endsWith('.ts') && f !== 'index.ts' && !f.startsWith('.'))
+    .sort((a, b) => a.localeCompare(b));
+
+  const exports = entries.map((f) => {
+    const base = path.basename(f, '.ts');
+    const ident = toIdentifier(base);
+    // Export only the root schema to avoid name collisions across modules.
+    return `export { ${ident}Schema } from './${base}.js';`;
+  });
+  const content = `// Auto-generated barrel file. Do not edit.\n${exports.join('\n')}\n`;
+  fs.writeFileSync(path.join(zodDir, 'index.ts'), content, 'utf8');
+}
+
+async function main() {
+  try {
+    const config = getConfig();
+    const { name } = parseArgs(process.argv.slice(2));
+    if (!name) throw new Error('Missing --name <DefName> argument');
+
+    const inPath = config.getStandaloneSchemaPath(`${name}.json`);
+    if (!fs.existsSync(inPath)) {
+      throw new Error(`Standalone schema not found at ${inPath}. Run generateStandaloneSchema -- --name ${name} first.`);
+    }
+
+    const raw = fs.readFileSync(inPath, 'utf8');
+    const parsed = JSON.parse(raw);
+
+    const { expressionsByName, warnings } = jsonSchemaToZodExpressions(parsed, name);
+
+    const zodDir = config.getZodSchemasDir();
+    const outPath = config.getZodSchemaPath(`${name}.ts`);
+    fs.mkdirSync(zodDir, { recursive: true });
+
+    const content = emitModule(name, expressionsByName, warnings);
+    fs.writeFileSync(outPath, content, 'utf8');
+
+    writeBarrelFile(zodDir);
+
+    if (warnings.length > 0) {
+      console.warn(`Generated Zod schema '${name}' with ${warnings.length} warning(s).`);
+    }
+    console.log(`Wrote ${outPath}`);
+  } catch (e: any) {
+    console.error(e?.message ?? e);
+    process.exitCode = 1;
+  }
+}
+
+void main();