osury 0.16.0 → 0.17.1

package/README.md

@@ -156,6 +156,25 @@ export type user = {
 
 The library uses **sury-ppx** for code-first approach — `@schema` annotation automatically generates runtime validators from type definitions.
 
+## Demo Playground
+
+This repository includes a local demo website for codegen exploration.
+
+### Run demo
+
+```bash
+npm run demo
+```
+
+Open [http://localhost:4173/demo/](http://localhost:4173/demo/).
+
+### What it supports
+
+- Upload OpenAPI JSON as a file
+- Paste OpenAPI JSON into a text area
+- Formatted ReScript output
+- Formatted TypeScript output (derived from osury AST and matching generated ReScript structures)
+
 ### Helper Files
 
 Also generates helper files:

package/bin/osury.mjs

@@ -4,37 +4,98 @@ import * as OpenAPIParser from "../src/OpenAPIParser.res.mjs";
 import * as Codegen from "../src/Codegen.res.mjs";
 import fs from "fs";
 import path from "path";
+import { createRequire } from "module";
+import { performance } from "perf_hooks";
 
-const args = process.argv.slice(2);
+// ─── Package info ────────────────────────────────────────────────────────────
+
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+const VERSION = pkg.version;
+
+// ─── Color support ───────────────────────────────────────────────────────────
+
+const noColor =
+  process.env.NO_COLOR != null ||
+  process.argv.includes("--no-color") ||
+  !process.stderr.isTTY;
+
+const fmt = (code, text) =>
+  noColor ? text : `\x1b[${code}m${text}\x1b[0m`;
+
+const c = {
+  bold: (t) => fmt("1", t),
+  dim: (t) => fmt("2", t),
+  italic: (t) => fmt("3", t),
+  red: (t) => fmt("31", t),
+  green: (t) => fmt("32", t),
+  yellow: (t) => fmt("33", t),
+  blue: (t) => fmt("34", t),
+  magenta: (t) => fmt("35", t),
+  cyan: (t) => fmt("36", t),
+  white: (t) => fmt("37", t),
+  gray: (t) => fmt("90", t),
+  boldRed: (t) => fmt("1;31", t),
+  boldGreen: (t) => fmt("1;32", t),
+  boldYellow: (t) => fmt("1;33", t),
+  boldCyan: (t) => fmt("1;36", t),
+};
+
+// ─── Symbols ─────────────────────────────────────────────────────────────────
+
+const sym = {
+  success: c.green("✓"),
+  error: c.red("✗"),
+  warning: c.yellow("⚠"),
+  arrow: c.dim("→"),
+  bullet: c.dim("·"),
+  bar: c.dim("│"),
+};
+
+// ─── Output helpers ──────────────────────────────────────────────────────────
+
+const log = (...args) => console.log(...args);
+const err = (...args) => console.error(...args);
+const blank = () => log();
+
+function header() {
+  blank();
+  log(`  ${c.bold("osury")} ${c.dim(`v${VERSION}`)}`);
+  log(`  ${c.dim("OpenAPI 3.x → ReScript + Sury")}`);
+  blank();
+}
+
+function elapsed(startMs) {
+  const ms = performance.now() - startMs;
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+
+// ─── Help ────────────────────────────────────────────────────────────────────
 
 function printHelp() {
-  console.log(`
-osury - Generate ReScript types from OpenAPI schema
-
-Usage:
-  osury <input.json> [output.res]
-  osury generate <input.json> -o <output.res>
-
-Arguments:
-  input.json    Path to OpenAPI/JSON Schema file
-  output.res    Output ReScript file (default: ./Generated.res)
-
-Options:
-  -o, --output  Output file path
-  -h, --help    Show this help
-
-Examples:
-  osury openapi.json
-  osury openapi.json src/API.res
-  osury generate ./schema.json -o ./src/Schema.res
-`);
+  header();
+  log(`  ${c.bold("Usage")}`);
+  log(`    ${c.cyan("$")} osury ${c.cyan("<input.json>")} ${c.dim("[output.res]")}`);
+  log(`    ${c.cyan("$")} osury generate ${c.cyan("<input.json>")} -o ${c.cyan("<output.res>")}`);
+  blank();
+  log(`  ${c.bold("Options")}`);
+  log(`    ${c.cyan("-o")}, ${c.cyan("--output")}    Output file path ${c.dim("(default: ./Generated.res)")}`);
+  log(`    ${c.cyan("-h")}, ${c.cyan("--help")}      Show this help`);
+  log(`    ${c.cyan("-v")}, ${c.cyan("--version")}   Show version`);
+  log(`    ${c.cyan("--no-color")}    Disable colored output`);
+  blank();
+  log(`  ${c.bold("Examples")}`);
+  log(`    ${c.cyan("$")} osury openapi.json`);
+  log(`    ${c.cyan("$")} osury openapi.json src/API.res`);
+  log(`    ${c.cyan("$")} osury generate schema.json -o src/Schema.res`);
+  blank();
 }
 
+// ─── Arg parsing ─────────────────────────────────────────────────────────────
+
 function parseArgs(args) {
-  const options = {
-    input: null,
-    output: "./Generated.res",
-  };
+  const options = { input: null, output: "./Generated.res" };
 
   let i = 0;
   while (i < args.length) {
@@ -43,10 +104,24 @@ function parseArgs(args) {
     if (arg === "-h" || arg === "--help") {
       printHelp();
       process.exit(0);
+    } else if (arg === "-v" || arg === "--version") {
+      log(`osury v${VERSION}`);
+      process.exit(0);
+    } else if (arg === "--no-color") {
+      // already handled above
     } else if (arg === "-o" || arg === "--output") {
-      options.output = args[++i];
+      i++;
+      if (i >= args.length) {
+        header();
+        err(`  ${sym.error} ${c.boldRed("Missing value for --output")}`);
+        blank();
+        err(`  Expected: osury input.json ${c.cyan("-o <path>")}`);
+        blank();
+        process.exit(1);
+      }
+      options.output = args[i];
     } else if (arg === "generate") {
-      // Skip 'generate' command word
+      // skip command word
     } else if (!options.input) {
       options.input = arg;
     } else if (options.output === "./Generated.res") {
@@ -58,60 +133,230 @@ function parseArgs(args) {
   return options;
 }
 
+// ─── "Did you mean?" ─────────────────────────────────────────────────────────
+
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++)
+    for (let j = 1; j <= n; j++)
+      dp[i][j] = a[i - 1] === b[j - 1]
+        ? dp[i - 1][j - 1]
+        : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+  return dp[m][n];
+}
+
+function findSimilarFiles(target) {
+  const dir = path.dirname(target);
+  const resolvedDir = dir === "." ? process.cwd() : dir;
+  const base = path.basename(target).toLowerCase();
+
+  try {
+    const files = fs.readdirSync(resolvedDir);
+    return files
+      .filter((f) => {
+        const fl = f.toLowerCase();
+        if (
+          !fl.endsWith(".json") &&
+          !fl.endsWith(".yaml") &&
+          !fl.endsWith(".yml")
+        )
+          return false;
+        // Levenshtein distance ≤ 40% of target name length
+        return levenshtein(base, fl) <= Math.ceil(base.length * 0.4);
+      })
+      .sort((a, b) => levenshtein(a.toLowerCase(), base) - levenshtein(b.toLowerCase(), base))
+      .slice(0, 3);
+  } catch {
+    return [];
+  }
+}
+
+// ─── Error formatting ────────────────────────────────────────────────────────
+
+function formatErrorKind(kind) {
+  if (!kind || !kind.TAG) return "Unknown error";
+  switch (kind.TAG) {
+    case "UnknownType":
+      return `Unknown type ${c.bold(`"${kind._0}"`)}`;
+    case "MissingRequiredField":
+      return `Missing required field ${c.bold(`"${kind._0}"`)}`;
+    case "InvalidRef":
+      return `Invalid reference ${c.bold(`"${kind._0}"`)}`;
+    case "UnsupportedFeature":
+      return `Unsupported feature ${c.bold(`"${kind._0}"`)}`;
+    case "InvalidFormat":
+      return `Invalid format ${c.bold(`"${kind._0}"`)}`;
+    case "CircularReference":
+      return `Circular reference ${c.bold(`"${kind._0}"`)}`;
+    case "AmbiguousUnion":
+      return `Ambiguous union (anyOf/oneOf cannot be distinguished)`;
+    case "InvalidJson":
+      return `Invalid JSON: ${kind._0}`;
+    default:
+      return kind.TAG + (kind._0 ? `: ${kind._0}` : "");
+  }
+}
+
+function formatParseError(error, index) {
+  const pathStr =
+    error.location?.path?.length > 0
+      ? c.cyan("#/" + error.location.path.join("/"))
+      : c.cyan("#");
+
+  const lines = [];
+  lines.push(`  ${c.dim(`${index + 1}.`)} ${pathStr}`);
+  lines.push(`     ${formatErrorKind(error.kind)}`);
+
+  if (error.hint) {
+    lines.push(`     ${c.dim("Hint:")} ${c.italic(error.hint)}`);
+  }
+
+  return lines.join("\n");
+}
+
+// ─── Warning formatting ─────────────────────────────────────────────────────
+
+function formatWarning(warning) {
+  // Warnings from collectUnionWarnings look like:
+  // "⚠ floatOrDict: anyOf [float, Dict] without discriminator, @tag("_tag") may not work at runtime"
+  // "⚠ modelInfoOrDict: anyOf without discriminator, simplified to modelInfo"
+  const cleaned = warning.replace(/^⚠\s*/, "");
+  return `  ${sym.warning} ${c.yellow(cleaned)}`;
+}
+
+// ─── Main generate ───────────────────────────────────────────────────────────
+
 function generate(inputPath, outputPath) {
-  // Read input file
+  const start = performance.now();
+
+  header();
+
+  // ── Check input file exists ──
   if (!fs.existsSync(inputPath)) {
-    console.error(`Error: Input file not found: ${inputPath}`);
+    err(`  ${sym.error} ${c.boldRed("File not found:")} ${c.cyan(inputPath)}`);
+
+    const similar = findSimilarFiles(inputPath);
+    if (similar.length > 0) {
+      blank();
+      err(`  ${c.dim("Did you mean?")}`);
+      similar.forEach((f) => {
+        err(`    ${sym.bullet} ${c.cyan(f)}`);
+      });
+    }
+
+    blank();
     process.exit(1);
   }
 
-  const doc = JSON.parse(fs.readFileSync(inputPath, "utf8"));
+  // ── Read & parse JSON ──
+  let doc;
+  try {
+    const raw = fs.readFileSync(inputPath, "utf8");
+    doc = JSON.parse(raw);
+  } catch (e) {
+    err(`  ${sym.error} ${c.boldRed("Invalid JSON")} in ${c.cyan(inputPath)}`);
+    blank();
+
+    if (e instanceof SyntaxError) {
+      // Extract useful part of the message
+      const msg = e.message.replace(/^Unexpected/, "Unexpected");
+      err(`     ${c.red(msg)}`);
+    } else {
+      err(`     ${c.red(e.message)}`);
+    }
+
+    blank();
+    err(`  ${c.dim("Tip:")} Validate your JSON at ${c.cyan("https://jsonlint.com")}`);
+    blank();
+    process.exit(1);
+  }
 
-  // Parse and generate
+  // ── Parse OpenAPI document ──
   const result = OpenAPIParser.parseDocument(doc);
 
-  if (result.TAG === "Ok") {
-    const code = Codegen.generateModule(result._0);
+  if (result.TAG !== "Ok") {
+    const errors = result._0;
+    const count = errors.length;
 
-    // Ensure output directory exists
-    const outputDir = path.dirname(outputPath);
-    if (outputDir && !fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
+    err(
+      `  ${sym.error} ${c.boldRed(`${count} parse error${count !== 1 ? "s" : ""}`)} in ${c.cyan(inputPath)}`
+    );
+    blank();
+
+    errors.forEach((error, i) => {
+      err(formatParseError(error, i));
+      if (i < errors.length - 1) blank();
+    });
 
-    // Write main ReScript file
-    fs.writeFileSync(outputPath, code);
+    blank();
+    process.exit(1);
+  }
 
-    // Write Dict.gen.ts shim for @genType
-    const dictShimPath = path.join(outputDir || ".", "Dict.gen.ts");
-    fs.writeFileSync(dictShimPath, Codegen.generateDictShim());
+  const schemas = result._0;
+  const schemaCount = schemas.length;
 
-    // Write Nullable.res module (option<T> alias for sury compatibility)
-    const nullableResPath = path.join(outputDir || ".", "Nullable.res");
-    fs.writeFileSync(nullableResPath, Codegen.generateNullableModule());
+  log(`  ${sym.success} Parsed ${c.bold(String(schemaCount))} schema${schemaCount !== 1 ? "s" : ""} from ${c.cyan(inputPath)}`);
 
-    // Write Nullable.shim.ts for @genType.import (maps to T | null)
-    const nullableShimPath = path.join(outputDir || ".", "Nullable.shim.ts");
-    fs.writeFileSync(nullableShimPath, Codegen.generateNullableShim());
+  // ── Generate code ──
+  const { code, warnings } = Codegen.generateModuleWithDiagnostics(schemas);
 
-    console.log(`Generated ${result._0.length} types to ${outputPath}`);
-    console.log(`Generated shims: ${dictShimPath}, ${nullableShimPath}`);
-  } else {
-    console.error("Parse errors:");
-    result._0.forEach((err) => {
-      const location = err.location?.path?.join(".") || "root";
-      console.error(`  [${location}] ${err.kind.TAG}: ${err.kind._0 || ""}`);
+  // ── Print warnings ──
+  if (warnings.length > 0) {
+    blank();
+    warnings.forEach((w) => {
+      log(formatWarning(w));
     });
-    process.exit(1);
   }
+
+  // ── Ensure output directory exists ──
+  const outputDir = path.dirname(outputPath);
+  if (outputDir && outputDir !== "." && !fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // ── Count generated types ──
+  const typeCount = (code.match(/^type\s/gm) || []).length;
+
+  // ── Write files ──
+  fs.writeFileSync(outputPath, code);
+
+  const dictShimPath = path.join(outputDir || ".", "Dict.gen.ts");
+  fs.writeFileSync(dictShimPath, Codegen.generateDictShim());
+
+  const nullableResPath = path.join(outputDir || ".", "Nullable.res");
+  fs.writeFileSync(nullableResPath, Codegen.generateNullableModule());
+
+  const nullableShimPath = path.join(outputDir || ".", "Nullable.shim.ts");
+  fs.writeFileSync(nullableShimPath, Codegen.generateNullableShim());
+
+  // ── Success output ──
+  blank();
+  log(`  ${sym.success} Generated ${c.bold(String(typeCount))} type${typeCount !== 1 ? "s" : ""}`);
+  blank();
+  log(`  ${c.dim("Files written:")}`);
+  log(`    ${sym.bullet} ${c.cyan(outputPath)} ${c.dim("(main module)")}`);
+  log(`    ${sym.bullet} ${c.cyan(dictShimPath)} ${c.dim("(TS shim)")}`);
+  log(`    ${sym.bullet} ${c.cyan(nullableResPath)} ${c.dim("(ReScript module)")}`);
+  log(`    ${sym.bullet} ${c.cyan(nullableShimPath)} ${c.dim("(TS shim)")}`);
+  blank();
+  log(`  ${c.dim(`Done in ${elapsed(start)}`)}`);
+  blank();
 }
 
-// Main
-const options = parseArgs(args);
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+const options = parseArgs(process.argv.slice(2));
 
 if (!options.input) {
-  console.error("Error: Input file required\n");
-  printHelp();
+  header();
+  err(`  ${sym.error} ${c.boldRed("No input file specified")}`);
+  blank();
+  err(`  ${c.dim("Usage:")} osury ${c.cyan("<input.json>")} ${c.dim("[output.res]")}`);
+  err(`  ${c.dim("Help:")}  osury ${c.cyan("--help")}`);
+  blank();
   process.exit(1);
 }
 

package/package.json

@@ -2,10 +2,10 @@
   "name": "osury",
   "type": "module",
   "description": "Generate ReScript types with Sury schemas from OpenAPI specifications",
-  "version": "0.16.0",
+  "version": "0.17.1",
   "license": "MIT",
   "bin": {
-    "osury": "./bin/osury.mjs"
+    "osury": "bin/osury.mjs"
   },
   "files": [
     "bin/",
@@ -21,6 +21,7 @@
     "res:build": "rescript",
     "res:dev": "rescript watch",
     "codegen": "node scripts/codegen.mjs",
+    "demo": "npm --prefix demo run dev",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
     "prepublishOnly": "npm run res:build && npm test"
   },
@@ -55,6 +56,6 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/greenteamer/osury"
+    "url": "git+https://github.com/greenteamer/osury.git"
   }
 }

package/src/Codegen.res.mjs

@@ -1,749 +1,14 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Core__Array from "@rescript/core/src/Core__Array.res.mjs";
+import * as CodegenShims from "./CodegenShims.res.mjs";
+import * as CodegenTypes from "./CodegenTypes.res.mjs";
 import * as Core__Option from "@rescript/core/src/Core__Option.res.mjs";
+import * as CodegenHelpers from "./CodegenHelpers.res.mjs";
+import * as CodegenTransforms from "./CodegenTransforms.res.mjs";
 
-let reservedKeywords = [
-  "type",
-  "let",
-  "rec",
-  "and",
-  "as",
-  "open",
-  "include",
-  "module",
-  "sig",
-  "struct",
-  "exception",
-  "external",
-  "if",
-  "else",
-  "switch",
-  "while",
-  "for",
-  "try",
-  "catch",
-  "when",
-  "true",
-  "false",
-  "assert",
-  "lazy",
-  "constraint",
-  "functor",
-  "class",
-  "method",
-  "object",
-  "private",
-  "public",
-  "virtual",
-  "mutable",
-  "new",
-  "inherit",
-  "initializer",
-  "val",
-  "with",
-  "match",
-  "of",
-  "fun",
-  "function",
-  "in",
-  "do",
-  "done",
-  "begin",
-  "end",
-  "then",
-  "to",
-  "downto",
-  "or",
-  "land",
-  "lor",
-  "lxor",
-  "lsl",
-  "lsr",
-  "asr",
-  "mod",
-  "await",
-  "async"
-];
-
-function isReservedKeyword(name) {
-  return reservedKeywords.includes(name);
-}
-
-function lcFirst(s) {
-  if (s.length === 0) {
-    return s;
-  }
-  let first = s.charAt(0).toLowerCase();
-  let rest = s.slice(1);
-  return first + rest;
-}
-
-function generateType(schema) {
-  if (typeof schema !== "object") {
-    switch (schema) {
-      case "String" :
-        return "string";
-      case "Number" :
-        return "float";
-      case "Integer" :
-        return "int";
-      case "Boolean" :
-        return "bool";
-      case "Null" :
-        return "unit";
-    }
-  } else {
-    switch (schema._tag) {
-      case "Optional" :
-        return `option<` + generateType(schema._0) + `>`;
-      case "Nullable" :
-        return `Nullable.t<` + generateType(schema._0) + `>`;
-      case "Object" :
-        return generateRecord(schema._0);
-      case "Array" :
-        return `array<` + generateType(schema._0) + `>`;
-      case "Ref" :
-        return lcFirst(schema._0);
-      case "Enum" :
-        let variants = schema._0.map(v => `#` + v).join(" | ");
-        return `[` + variants + `]`;
-      case "PolyVariant" :
-        return generatePolyVariant(schema._0);
-      case "Dict" :
-        return `Dict.t<` + generateType(schema._0) + `>`;
-      case "Union" :
-        return generateUnion(schema._0);
-    }
-  }
-}
-
-function isOptionalType(schema) {
-  if (typeof schema !== "object") {
-    return false;
-  }
-  switch (schema._tag) {
-    case "Optional" :
-    case "Nullable" :
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isNullableType(schema) {
-  if (typeof schema !== "object") {
-    return false;
-  } else {
-    return schema._tag === "Nullable";
-  }
-}
-
-function generateRecord(fields) {
-  if (fields.length === 0) {
-    return "{}";
-  }
-  let fieldStrs = fields.map(field => {
-    let typeStr = generateType(field.type);
-    let optionalType = field.required || isOptionalType(field.type) ? typeStr : `option<` + typeStr + `>`;
-    let finalType = isNullableType(field.type) ? `@s.null ` + optionalType : optionalType;
-    let asAttr = reservedKeywords.includes(field.name) ? `@as("` + field.name + `") ` : "";
-    let fieldName = reservedKeywords.includes(field.name) ? field.name + `_` : field.name;
-    return asAttr + fieldName + `: ` + finalType;
-  });
-  return `{\n  ` + fieldStrs.join(",\n  ") + `\n}`;
-}
-
-function generatePolyVariant(cases) {
-  let caseStrs = cases.map(c => {
-    let payloadStr = generateType(c.payload);
-    return `#` + c._tag + `(` + payloadStr + `)`;
-  });
-  return `[` + caseStrs.join(" | ") + `]`;
-}
-
-function ucFirst(s) {
-  if (s.length === 0) {
-    return s;
-  }
-  let first = s.charAt(0).toUpperCase();
-  let rest = s.slice(1);
-  return first + rest;
-}
-
-function getTagForType(t) {
-  if (typeof t !== "object") {
-    switch (t) {
-      case "String" :
-        return "String";
-      case "Number" :
-        return "Float";
-      case "Integer" :
-        return "Int";
-      case "Boolean" :
-        return "Bool";
-      case "Null" :
-        return "Null";
-    }
-  } else {
-    switch (t._tag) {
-      case "Optional" :
-        return `Option` + getTagForType(t._0);
-      case "Nullable" :
-        return `Null` + getTagForType(t._0);
-      case "Object" :
-        return "Object";
-      case "Array" :
-        return `Array` + getTagForType(t._0);
-      case "Ref" :
-        return ucFirst(t._0);
-      case "Enum" :
-        return "Enum";
-      case "PolyVariant" :
-        return "Variant";
-      case "Dict" :
-        return "Dict";
-      case "Union" :
-        return "Union";
-    }
-  }
-}
-
-function generateUnion(types) {
-  let caseStrs = types.map(t => {
-    let tag = getTagForType(t);
-    let payload = generateType(t);
-    return `#` + tag + `(` + payload + `)`;
-  });
-  return `[` + caseStrs.join(" | ") + `]`;
-}
-
-function hasUnion(_schema) {
-  while (true) {
-    let schema = _schema;
-    if (typeof schema !== "object") {
-      return false;
-    }
-    switch (schema._tag) {
-      case "Object" :
-        return schema._0.some(f => hasUnion(f.type));
-      case "PolyVariant" :
-        return schema._0.some(c => hasUnion(c.payload));
-      case "Optional" :
-      case "Nullable" :
-      case "Array" :
-      case "Dict" :
-        _schema = schema._0;
-        continue;
-      case "Union" :
-        return true;
-      default:
-        return false;
-    }
-  };
-}
-
-function isPrimitiveOnlyUnion(types) {
-  return types.every(t => {
-    if (typeof t === "object") {
-      return false;
-    }
-    switch (t) {
-      case "String" :
-      case "Number" :
-      case "Integer" :
-      case "Boolean" :
-        return true;
-      default:
-        return false;
-    }
-  });
-}
-
-function generateInlineRecord(refName, schemasDict) {
-  let other = schemasDict[refName];
-  if (other !== undefined) {
-    if (typeof other !== "object" || other._tag !== "Object") {
-      return generateType(other);
-    } else {
-      return generateRecord(other._0);
-    }
-  } else {
-    return lcFirst(refName);
-  }
-}
-
-function generateInlineVariantBody(types, schemasDict, tagsDict) {
-  return types.map(t => {
-    if (typeof t === "object" && t._tag === "Ref") {
-      let name = t._0;
-      let tagValue = tagsDict[name];
-      let tag = tagValue !== undefined ? ucFirst(tagValue) : ucFirst(name);
-      let inlineRecord = generateInlineRecord(name, schemasDict);
-      return tag + `(` + inlineRecord + `)`;
-    }
-    let tag$1 = getTagForType(t);
-    let payload = generateType(t);
-    return tag$1 + `(` + payload + `)`;
-  }).join(" | ");
-}
-
-function isRefPlusDictUnion(types) {
-  if (types.length !== 2) {
-    return;
-  }
-  let hasDict = types.some(t => {
-    if (typeof t !== "object") {
-      return false;
-    }
-    if (t._tag !== "Dict") {
-      return false;
-    }
-    let tmp = t._0;
-    if (typeof tmp !== "object") {
-      return tmp === "String";
-    } else {
-      return false;
-    }
-  });
-  let refName = Core__Array.findMap(types, t => {
-    if (typeof t !== "object" || t._tag !== "Ref") {
-      return;
-    } else {
-      return t._0;
-    }
-  });
-  if (hasDict) {
-    return refName;
-  }
-}
-
-function isPrimitivePlusDictUnion(types) {
-  if (types.length !== 2) {
-    return;
-  }
-  let hasDict = types.some(t => {
-    if (typeof t !== "object") {
-      return false;
-    }
-    if (t._tag !== "Dict") {
-      return false;
-    }
-    let tmp = t._0;
-    if (typeof tmp !== "object") {
-      return tmp === "String";
-    } else {
-      return false;
-    }
-  });
-  let primitiveName = Core__Array.findMap(types, t => {
-    if (typeof t === "object") {
-      return;
-    }
-    switch (t) {
-      case "String" :
-        return "string";
-      case "Number" :
-        return "float";
-      case "Integer" :
-        return "int";
-      case "Boolean" :
-        return "bool";
-      default:
-        return;
-    }
-  });
-  if (hasDict) {
-    return primitiveName;
-  }
-}
-
-function getUnionName(types) {
-  let names = types.map(t => {
-    if (typeof t !== "object") {
-      switch (t) {
-        case "String" :
-          return "string";
-        case "Number" :
-          return "float";
-        case "Integer" :
-          return "int";
-        case "Boolean" :
-          return "bool";
-        case "Null" :
-          return "null";
-      }
-    } else {
-      switch (t._tag) {
-        case "Array" :
-          return "array";
-        case "Ref" :
-          return lcFirst(t._0);
-        case "Dict" :
-          return "dict";
-        default:
-          return "unknown";
-      }
-    }
-  });
-  if (names.length === 0) {
-    return "emptyUnion";
-  }
-  let first = Core__Option.getOr(names[0], "unknown");
-  let rest = names.slice(1);
-  return first + rest.map(n => "Or" + ucFirst(n)).join("");
-}
-
-function extractUnionsFromType(_schema) {
-  while (true) {
-    let schema = _schema;
-    if (typeof schema !== "object") {
-      return [];
-    }
-    switch (schema._tag) {
-      case "Object" :
-        return schema._0.flatMap(field => extractUnionsFromType(field.type));
-      case "Optional" :
-      case "Nullable" :
-      case "Array" :
-      case "Dict" :
-        _schema = schema._0;
-        continue;
-      case "Union" :
-        let types = schema._0;
-        let match = isRefPlusDictUnion(types);
-        if (match !== undefined) {
-          return [];
-        }
-        let name = getUnionName(types);
-        return [{
-            name: name,
-            schema: schema
-          }];
-      default:
-        return [];
-    }
-  };
-}
-
-function extractUnions(_parentName, schema) {
-  if (typeof schema !== "object") {
-    return [];
-  } else if (schema._tag === "Object") {
-    return schema._0.flatMap(field => extractUnionsFromType(field.type));
-  } else {
-    return [];
-  }
-}
-
-function replaceUnionInType(schema) {
-  if (typeof schema !== "object") {
-    return schema;
-  }
-  switch (schema._tag) {
-    case "Optional" :
-      return {
-        _tag: "Optional",
-        _0: replaceUnionInType(schema._0)
-      };
-    case "Nullable" :
-      return {
-        _tag: "Nullable",
-        _0: replaceUnionInType(schema._0)
-      };
-    case "Object" :
-      let newFields = schema._0.map(field => {
-        let newType = replaceUnionInType(field.type);
-        return {
-          name: field.name,
-          type: newType,
-          required: field.required
-        };
-      });
-      return {
-        _tag: "Object",
-        _0: newFields
-      };
-    case "Array" :
-      return {
-        _tag: "Array",
-        _0: replaceUnionInType(schema._0)
-      };
-    case "Dict" :
-      return {
-        _tag: "Dict",
-        _0: replaceUnionInType(schema._0)
-      };
-    case "Union" :
-      let types = schema._0;
-      let refName = isRefPlusDictUnion(types);
-      if (refName !== undefined) {
-        return {
-          _tag: "Ref",
-          _0: refName
-        };
-      } else {
-        return {
-          _tag: "Ref",
-          _0: getUnionName(types)
-        };
-      }
-    default:
-      return schema;
-  }
-}
-
-function replaceUnions(_parentName, schema) {
-  if (typeof schema !== "object") {
-    return schema;
-  }
-  if (schema._tag !== "Object") {
-    return schema;
-  }
-  let newFields = schema._0.map(field => {
-    let newType = replaceUnionInType(field.type);
-    return {
-      name: field.name,
-      type: newType,
-      required: field.required
-    };
-  });
-  return {
-    _tag: "Object",
-    _0: newFields
-  };
-}
-
-function getDependencies(_schema) {
-  while (true) {
-    let schema = _schema;
-    if (typeof schema !== "object") {
-      return [];
-    }
-    switch (schema._tag) {
-      case "Object" :
-        return schema._0.flatMap(f => getDependencies(f.type));
-      case "Ref" :
-        return [schema._0];
-      case "Enum" :
-        return [];
-      case "PolyVariant" :
-        return schema._0.flatMap(c => getDependencies(c.payload));
-      case "Optional" :
-      case "Nullable" :
-      case "Array" :
-      case "Dict" :
-        _schema = schema._0;
-        continue;
-      case "Union" :
-        return schema._0.flatMap(getDependencies);
-    }
-  };
-}
-
-function topologicalSort(schemas) {
-  let schemaMap = {};
-  schemas.forEach(s => {
-    schemaMap[s.name] = s;
-  });
-  let deps = {};
-  schemas.forEach(s => {
-    let refNames = getDependencies(s.schema);
-    let validRefs = refNames.filter(name => Core__Option.isSome(schemaMap[name]));
-    deps[s.name] = validRefs;
-  });
-  let outDegree = {};
-  schemas.forEach(s => {
-    let myDeps = Core__Option.getOr(deps[s.name], []);
-    outDegree[s.name] = myDeps.length;
-  });
-  let reverseDeps = {};
-  schemas.forEach(s => {
-    reverseDeps[s.name] = [];
-  });
-  Object.entries(deps).forEach(param => {
-    let name = param[0];
-    param[1].forEach(refName => {
-      let arr = reverseDeps[refName];
-      if (arr !== undefined) {
-        arr.push(name);
-        return;
-      }
-    });
-  });
-  let queue = schemas.filter(s => Core__Option.getOr(outDegree[s.name], 0) === 0).map(s => s.name);
-  let result = [];
-  let visited = {};
-  let process = () => {
-    while (true) {
-      let name = queue.shift();
-      if (name === undefined) {
-        return;
-      }
-      if (Core__Option.isNone(visited[name])) {
-        visited[name] = true;
-        let schema = schemaMap[name];
-        if (schema !== undefined) {
-          result.push(schema);
-        }
-        let dependents = reverseDeps[name];
-        if (dependents !== undefined) {
-          dependents.forEach(depName => {
-            let current = Core__Option.getOr(outDegree[depName], 0);
-            outDegree[depName] = current - 1 | 0;
-            if ((current - 1 | 0) === 0) {
-              queue.push(depName);
-              return;
-            }
-          });
-        }
-      }
-      continue;
-    };
-  };
-  process();
-  schemas.forEach(s => {
-    if (Core__Option.isNone(visited[s.name])) {
-      result.push(s);
-      return;
-    }
-  });
-  return result;
-}
-
-function buildSkipSchemaSet(schemas) {
-  let skipSet = {};
-  schemas.forEach(s => {
-    if (hasUnion(s.schema)) {
-      skipSet[s.name] = true;
-      return;
-    }
-  });
-  let changed = {
-    contents: true
-  };
-  while (changed.contents) {
-    changed.contents = false;
-    schemas.forEach(s => {
-      if (!Core__Option.isNone(skipSet[s.name])) {
-        return;
-      }
-      let refs = getDependencies(s.schema);
-      let refsSkipSchema = refs.some(refName => Core__Option.isSome(skipSet[refName]));
-      if (refsSkipSchema) {
-        skipSet[s.name] = true;
-        changed.contents = true;
-        return;
-      }
-    });
-  };
-  return skipSet;
-}
-
-function generateVariantBody(types) {
-  return types.map(t => {
-    let tag = getTagForType(t);
-    let payload = generateType(t);
-    return tag + `(` + payload + `)`;
-  }).join(" | ");
-}
-
-function generateTypeDefWithSkipSet(namedSchema, _skipSet, schemasDict, tagsDict) {
-  let typeName = lcFirst(namedSchema.name);
-  let types = namedSchema.schema;
-  if (typeof types === "object" && types._tag === "Union") {
-    let types$1 = types._0;
-    if (isPrimitiveOnlyUnion(types$1)) {
-      let variantBody = generateVariantBody(types$1);
-      return `@genType
-@tag("_tag")
-@unboxed
-@schema
-type ` + typeName + ` = ` + variantBody;
-    }
-    let variantBody$1 = generateInlineVariantBody(types$1, schemasDict, tagsDict);
-    return `@genType
-@tag("_tag")
-@schema
-type ` + typeName + ` = ` + variantBody$1;
-  }
-  let typeBody = generateType(namedSchema.schema);
-  return `@genType
-@schema
-type ` + typeName + ` = ` + typeBody;
-}
-
-function generateTypeDef(namedSchema) {
-  let typeName = lcFirst(namedSchema.name);
-  let types = namedSchema.schema;
-  if (typeof types === "object" && types._tag === "Union") {
-    let variantBody = generateVariantBody(types._0);
-    return `@genType
-@tag("_tag")
-@unboxed
-@schema
-type ` + typeName + ` = ` + variantBody;
-  }
-  let annotations = hasUnion(namedSchema.schema) ? "@genType" : "@genType\n@schema";
-  let typeBody = generateType(namedSchema.schema);
-  return annotations + `
-type ` + typeName + ` = ` + typeBody;
-}
-
-function collectUnionWarnings(schemas) {
-  let seen = {};
-  let warnings = [];
-  let findUnions = _schema => {
-    while (true) {
-      let schema = _schema;
-      if (typeof schema !== "object") {
-        return [];
-      }
-      switch (schema._tag) {
-        case "Object" :
-          return schema._0.flatMap(f => findUnions(f.type));
-        case "Optional" :
-        case "Nullable" :
-        case "Array" :
-        case "Dict" :
-          _schema = schema._0;
-          continue;
-        case "Union" :
-          return [schema._0];
-        default:
-          return [];
-      }
-    };
-  };
-  schemas.forEach(s => {
-    let unions = findUnions(s.schema);
-    unions.forEach(types => {
-      let unionName = getUnionName(types);
-      if (!Core__Option.isNone(seen[unionName])) {
-        return;
-      }
-      seen[unionName] = true;
-      let refName = isRefPlusDictUnion(types);
-      if (refName !== undefined) {
-        warnings.push(`⚠ ` + unionName + `: anyOf without discriminator, simplified to ` + lcFirst(refName));
-        return;
-      }
-      let primName = isPrimitivePlusDictUnion(types);
-      if (primName !== undefined) {
-        warnings.push(`⚠ ` + unionName + `: anyOf [` + primName + `, Dict] without discriminator, @tag("_tag") may not work at runtime`);
-        return;
-      }
-    });
-  });
-  return warnings;
-}
-
-function generateModule(schemas) {
-  let warnings = collectUnionWarnings(schemas);
-  warnings.forEach(w => {
-    console.log(w);
-  });
-  let extractedUnions = schemas.flatMap(s => extractUnions(s.name, s.schema).map(extracted => ({
+function generateModuleWithDiagnostics(schemas) {
+  let warnings = CodegenTransforms.collectUnionWarnings(schemas);
+  let extractedUnions = schemas.flatMap(s => CodegenTransforms.extractUnions(s.name, s.schema).map(extracted => ({
     name: extracted.name,
     schema: extracted.schema,
     discriminatorTag: undefined
@@ -759,7 +24,7 @@ function generateModule(schemas) {
   });
   let modifiedSchemas = schemas.map(s => ({
     name: s.name,
-    schema: replaceUnions(s.name, s.schema),
+    schema: CodegenTransforms.replaceUnions(s.name, s.schema),
     discriminatorTag: s.discriminatorTag
   }));
   let allSchemas = uniqueUnions.concat(modifiedSchemas);
@@ -773,56 +38,92 @@ function generateModule(schemas) {
       return;
     }
   });
-  let sorted = topologicalSort(allSchemas);
+  let sorted = CodegenTransforms.topologicalSort(allSchemas);
   let skipSet = {};
-  let typeDefs = sorted.map(s => generateTypeDefWithSkipSet(s, skipSet, schemasDict, tagsDict)).join("\n\n");
-  return "module S = Sury\n\n" + typeDefs;
+  let typeDefs = sorted.map(s => CodegenTypes.generateTypeDefWithSkipSet(s, skipSet, schemasDict, tagsDict)).join("\n\n");
+  let code = "module S = Sury\n\n" + typeDefs;
+  return {
+    code: code,
+    warnings: warnings
+  };
 }
 
-function generateDictShim() {
-  return `// Generated by osury - Dict type shim for @genType
-export type t<T> = { [key: string]: T };
-`;
+function generateModule(schemas) {
+  let result = generateModuleWithDiagnostics(schemas);
+  result.warnings.forEach(w => {
+    console.log(w);
+  });
+  return result.code;
 }
 
-function generateNullableShim() {
-  return `/**
- * Type shim for ReScript Nullable.t
- *
- * This file is generated by osury (not by ReScript/genType).
- * It maps ReScript's option<T> to TypeScript's T | null for JSON nullable fields.
- *
- * ReScript side: Nullable.t<T> = option<T> (works with sury's S.null schema)
- * TypeScript side: t<T> = T | null (correct JSON null representation)
- */
-export type t<T> = T | null;
-`;
-}
+let lcFirst = CodegenHelpers.lcFirst;
 
-function generateNullableModule() {
-  return `// Generated by osury - Nullable type for JSON null values
-// This is option<T> internally but maps to T | null in TypeScript via shim
-@genType.import(("./Nullable.shim.ts", "t"))
-type t<'a> = option<'a>
-`;
-}
+let ucFirst = CodegenHelpers.ucFirst;
+
+let reservedKeywords = CodegenHelpers.reservedKeywords;
+
+let isReservedKeyword = CodegenHelpers.isReservedKeyword;
+
+let isOptionalType = CodegenHelpers.isOptionalType;
+
+let isNullableType = CodegenHelpers.isNullableType;
+
+let getTagForType = CodegenHelpers.getTagForType;
+
+let hasUnion = CodegenHelpers.hasUnion;
+
+let isPrimitiveOnlyUnion = CodegenHelpers.isPrimitiveOnlyUnion;
+
+let isRefPlusDictUnion = CodegenTransforms.isRefPlusDictUnion;
+
+let isPrimitivePlusDictUnion = CodegenTransforms.isPrimitivePlusDictUnion;
+
+let getUnionName = CodegenTransforms.getUnionName;
+
+let extractUnions = CodegenTransforms.extractUnions;
+
+let extractUnionsFromType = CodegenTransforms.extractUnionsFromType;
+
+let replaceUnions = CodegenTransforms.replaceUnions;
+
+let replaceUnionInType = CodegenTransforms.replaceUnionInType;
+
+let getDependencies = CodegenTransforms.getDependencies;
+
+let topologicalSort = CodegenTransforms.topologicalSort;
+
+let buildSkipSchemaSet = CodegenTransforms.buildSkipSchemaSet;
+
+let collectUnionWarnings = CodegenTransforms.collectUnionWarnings;
+
+let generateType = CodegenTypes.generateType;
+
+let generateTypeDef = CodegenTypes.generateTypeDef;
+
+let generateTypeDefWithSkipSet = CodegenTypes.generateTypeDefWithSkipSet;
+
+let generateVariantBody = CodegenTypes.generateVariantBody;
+
+let generateInlineVariantBody = CodegenTypes.generateInlineVariantBody;
+
+let generateInlineRecord = CodegenTypes.generateInlineRecord;
+
+let generateDictShim = CodegenShims.generateDictShim;
+
+let generateNullableShim = CodegenShims.generateNullableShim;
+
+let generateNullableModule = CodegenShims.generateNullableModule;
 
 export {
+  lcFirst,
+  ucFirst,
   reservedKeywords,
   isReservedKeyword,
-  lcFirst,
-  generateType,
   isOptionalType,
   isNullableType,
-  generateRecord,
-  generatePolyVariant,
-  ucFirst,
   getTagForType,
-  generateUnion,
   hasUnion,
   isPrimitiveOnlyUnion,
-  generateInlineRecord,
-  generateInlineVariantBody,
   isRefPlusDictUnion,
   isPrimitivePlusDictUnion,
   getUnionName,
@@ -833,13 +134,17 @@ export {
   getDependencies,
   topologicalSort,
   buildSkipSchemaSet,
-  generateVariantBody,
-  generateTypeDefWithSkipSet,
-  generateTypeDef,
   collectUnionWarnings,
-  generateModule,
+  generateType,
+  generateTypeDef,
+  generateTypeDefWithSkipSet,
+  generateVariantBody,
+  generateInlineVariantBody,
+  generateInlineRecord,
   generateDictShim,
   generateNullableShim,
   generateNullableModule,
+  generateModuleWithDiagnostics,
+  generateModule,
 }
 /* No side effect */