osury 0.17.3 → 0.20.1

package/bin/osury.mjs

@@ -2,6 +2,9 @@
 
 import * as OpenAPIParser from "../src/OpenAPIParser.res.mjs";
 import * as Codegen from "../src/Codegen.res.mjs";
+import * as DomainConfig from "../src/DomainConfig.res.mjs";
+import * as DomainGen from "../src/DomainGen.res.mjs";
+import * as DomainBackend from "../src/DomainBackend.res.mjs";
 import fs from "fs";
 import path from "path";
 import { createRequire } from "module";
@@ -78,6 +81,7 @@ function printHelp() {
   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>")}`);
+  log(`    ${c.cyan("$")} osury domain ${c.dim("[options]")}`);
   blank();
   log(`  ${c.bold("Options")}`);
   log(`    ${c.cyan("-o")}, ${c.cyan("--output")}    Output file path ${c.dim("(default: ./Generated.res)")}`);
@@ -85,10 +89,16 @@ function printHelp() {
   log(`    ${c.cyan("-v")}, ${c.cyan("--version")}   Show version`);
   log(`    ${c.cyan("--no-color")}    Disable colored output`);
   blank();
+  log(`  ${c.bold("Domain options")}`);
+  log(`    ${c.cyan("--config")}      Config file path ${c.dim("(default: domain.config.json)")}`);
+  log(`    ${c.cyan("--api-module")}  API module name ${c.dim("(default: Api)")}`);
+  log(`    ${c.cyan("-o")}            Output directory ${c.dim("(default: src/domains/)")}`);
+  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`);
+  log(`    ${c.cyan("$")} osury domain --config domain.config.json --api-module Api`);
   blank();
 }
 
@@ -193,6 +203,8 @@ function formatErrorKind(kind) {
       return `Circular reference ${c.bold(`"${kind._0}"`)}`;
     case "AmbiguousUnion":
       return `Ambiguous union (anyOf/oneOf cannot be distinguished)`;
+    case "MissingDiscriminator":
+      return `Missing discriminator for union ${c.bold(`"${kind._0}"`)}`;
     case "InvalidJson":
       return `Invalid JSON: ${kind._0}`;
     default:
@@ -301,7 +313,27 @@ function generate(inputPath, outputPath) {
   log(`  ${sym.success} Parsed ${c.bold(String(schemaCount))} schema${schemaCount !== 1 ? "s" : ""} from ${c.cyan(inputPath)}`);
 
   // ── Generate code ──
-  const { code, warnings } = Codegen.generateModuleWithDiagnostics(schemas);
+  const genResult = Codegen.generateModuleWithDiagnostics(schemas);
+
+  if (genResult.TAG !== "Ok") {
+    const errors = genResult._0;
+    const count = errors.length;
+
+    err(
+      `  ${sym.error} ${c.boldRed(`${count} codegen error${count !== 1 ? "s" : ""}`)} in ${c.cyan(inputPath)}`
+    );
+    blank();
+
+    errors.forEach((error, i) => {
+      err(formatParseError(error, i));
+      if (i < errors.length - 1) blank();
+    });
+
+    blank();
+    process.exit(1);
+  }
+
+  const { code, warnings } = genResult._0;
 
   // ── Print warnings ──
   if (warnings.length > 0) {
@@ -346,18 +378,166 @@ function generate(inputPath, outputPath) {
   blank();
 }
 
-// ─── Entry point ─────────────────────────────────────────────────────────────
+// ─── Domain arg parsing ─────────────────────────────────────────────────────
+
+function parseDomainArgs(args) {
+  const options = {
+    config: "domain.config.json",
+    apiModule: "Api",
+    outputDir: "src/domains/",
+  };
+
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+
+    if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    } else if (arg === "--config") {
+      i++;
+      if (i >= args.length) {
+        header();
+        err(`  ${sym.error} ${c.boldRed("Missing value for --config")}`);
+        blank();
+        process.exit(1);
+      }
+      options.config = args[i];
+    } else if (arg === "--api-module") {
+      i++;
+      if (i >= args.length) {
+        header();
+        err(`  ${sym.error} ${c.boldRed("Missing value for --api-module")}`);
+        blank();
+        process.exit(1);
+      }
+      options.apiModule = args[i];
+    } else if (arg === "-o" || arg === "--output") {
+      i++;
+      if (i >= args.length) {
+        header();
+        err(`  ${sym.error} ${c.boldRed("Missing value for --output")}`);
+        blank();
+        process.exit(1);
+      }
+      options.outputDir = args[i];
+    } else if (arg === "--no-color") {
+      // already handled
+    }
+    i++;
+  }
 
-const options = parseArgs(process.argv.slice(2));
+  return options;
+}
+
+// ─── Domain generate ────────────────────────────────────────────────────────
+
+function generateDomain(options) {
+  const start = performance.now();
 
-if (!options.input) {
   header();
-  err(`  ${sym.error} ${c.boldRed("No input file specified")}`);
+  log(`  ${c.dim("Mode:")} domain module generation`);
   blank();
-  err(`  ${c.dim("Usage:")} osury ${c.cyan("<input.json>")} ${c.dim("[output.res]")}`);
-  err(`  ${c.dim("Help:")}  osury ${c.cyan("--help")}`);
+
+  // ── Check config file exists ──
+  if (!fs.existsSync(options.config)) {
+    err(`  ${sym.error} ${c.boldRed("Config not found:")} ${c.cyan(options.config)}`);
+    blank();
+    process.exit(1);
+  }
+
+  // ── Read & parse config JSON ──
+  let configJson;
+  try {
+    const raw = fs.readFileSync(options.config, "utf8");
+    configJson = JSON.parse(raw);
+  } catch (e) {
+    err(`  ${sym.error} ${c.boldRed("Invalid JSON")} in ${c.cyan(options.config)}`);
+    blank();
+    if (e instanceof SyntaxError) {
+      err(`     ${c.red(e.message)}`);
+    } else {
+      err(`     ${c.red(e.message)}`);
+    }
+    blank();
+    process.exit(1);
+  }
+
+  // ── Parse domain config ──
+  const parseResult = DomainConfig.parse(configJson);
+
+  if (parseResult.TAG !== "Ok") {
+    const errors = parseResult._0;
+    const count = errors.length;
+
+    err(
+      `  ${sym.error} ${c.boldRed(`${count} config error${count !== 1 ? "s" : ""}`)} in ${c.cyan(options.config)}`
+    );
+    blank();
+
+    errors.forEach((error, i) => {
+      err(formatParseError(error, i));
+      if (i < errors.length - 1) blank();
+    });
+
+    blank();
+    process.exit(1);
+  }
+
+  const config = parseResult._0;
+  const moduleCount = config.modules.length;
+  log(`  ${sym.success} Parsed ${c.bold(String(moduleCount))} domain module${moduleCount !== 1 ? "s" : ""} from ${c.cyan(options.config)}`);
+
+  // ── Generate domain modules ──
+  const modules = DomainGen.generate(config, options.apiModule);
+
+  // ── Ensure output directory exists ──
+  if (!fs.existsSync(options.outputDir)) {
+    fs.mkdirSync(options.outputDir, { recursive: true });
+  }
+
+  // ── Write each module ──
+  const writtenFiles = [];
+  modules.forEach((mod) => {
+    const code = DomainBackend.printModule(mod);
+    const outputPath = path.join(options.outputDir, mod.output);
+    fs.writeFileSync(outputPath, code);
+    writtenFiles.push(outputPath);
+  });
+
+  // ── Success output ──
+  blank();
+  log(`  ${sym.success} Generated ${c.bold(String(writtenFiles.length))} domain module${writtenFiles.length !== 1 ? "s" : ""}`);
+  blank();
+  log(`  ${c.dim("Files written:")}`);
+  writtenFiles.forEach((f) => {
+    log(`    ${sym.bullet} ${c.cyan(f)}`);
+  });
+  blank();
+  log(`  ${c.dim(`Done in ${elapsed(start)}`)}`);
   blank();
-  process.exit(1);
 }
 
-generate(options.input, options.output);
+// ─── Entry point ─────────────────────────────────────────────────────────────
+
+const rawArgs = process.argv.slice(2);
+
+// Check for "domain" subcommand
+if (rawArgs[0] === "domain") {
+  const domainOptions = parseDomainArgs(rawArgs.slice(1));
+  generateDomain(domainOptions);
+} else {
+  const options = parseArgs(rawArgs);
+
+  if (!options.input) {
+    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);
+  }
+
+  generate(options.input, options.output);
+}

package/package.json

@@ -2,22 +2,29 @@
   "name": "osury",
   "type": "module",
   "description": "Generate ReScript types with Sury schemas from OpenAPI specifications",
-  "version": "0.17.3",
+  "version": "0.20.1",
   "license": "MIT",
   "bin": {
     "osury": "bin/osury.mjs"
   },
   "files": [
     "bin/",
+    "src/BackendReScript.res.mjs",
     "src/Codegen.res.mjs",
     "src/CodegenHelpers.res.mjs",
     "src/CodegenShims.res.mjs",
     "src/CodegenTransforms.res.mjs",
     "src/CodegenTypes.res.mjs",
     "src/Errors.res.mjs",
+    "src/IR.res.mjs",
+    "src/IRGen.res.mjs",
     "src/OpenAPIParser.res.mjs",
     "src/Schema.res.mjs",
     "src/Schema.gen.tsx",
+    "src/DomainConfig.res.mjs",
+    "src/DomainIR.res.mjs",
+    "src/DomainGen.res.mjs",
+    "src/DomainBackend.res.mjs",
     "README.md"
   ],
   "scripts": {

package/src/BackendReScript.res.mjs

@@ -0,0 +1,144 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Core__Array from "@rescript/core/src/Core__Array.res.mjs";
+import * as Core__Option from "@rescript/core/src/Core__Option.res.mjs";
+
+function printPrimitive(p) {
+  switch (p) {
+    case "PString" :
+      return "string";
+    case "PFloat" :
+      return "float";
+    case "PInt" :
+      return "int";
+    case "PBool" :
+      return "bool";
+    case "PUnit" :
+      return "unit";
+  }
+}
+
+function printType(t) {
+  if (typeof t !== "object") {
+    return "JSON.t";
+  }
+  switch (t.TAG) {
+    case "Primitive" :
+      return printPrimitive(t._0);
+    case "Option" :
+      return `option<` + printType(t._0) + `>`;
+    case "Nullable" :
+      return `Nullable.t<` + printType(t._0) + `>`;
+    case "Array" :
+      return `array<` + printType(t._0) + `>`;
+    case "Dict" :
+      return `Dict.t<` + printType(t._0) + `>`;
+    case "Named" :
+      return t._0;
+    case "Enum" :
+      let variants = t._0.map(v => `#` + v).join(" | ");
+      return `[` + variants + `]`;
+    case "InlineRecord" :
+      return printRecord(t._0);
+    case "InlineVariant" :
+      return printVariantCases(t._0);
+  }
+}
+
+function printField(field) {
+  let typeStr = printType(field.type_);
+  let fieldType = Core__Array.reduce(field.annotations, typeStr, (acc, ann) => {
+    if (typeof ann !== "object" && ann === "SNull") {
+      return `@s.null ` + acc;
+    } else {
+      return acc;
+    }
+  });
+  let asAttr = Core__Option.getOr(Core__Array.findMap(field.annotations, ann => {
+    if (typeof ann !== "object" || ann.TAG !== "As") {
+      return;
+    } else {
+      return `@as("` + ann._0 + `") `;
+    }
+  }), "");
+  return asAttr + field.name + `: ` + fieldType;
+}
+
+function printRecord(fields) {
+  if (fields.length === 0) {
+    return "{}";
+  }
+  let fieldStrs = fields.map(printField);
+  return `{\n  ` + fieldStrs.join(",\n  ") + `\n}`;
+}
+
+function printVariantCase(c) {
+  let payloadStr = printType(c.payload);
+  return c.tag + `(` + payloadStr + `)`;
+}
+
+function printVariantCases(cases) {
+  let caseStrs = cases.map(printVariantCase);
+  return `[` + caseStrs.map(c => `#` + c).join(" | ") + `]`;
+}
+
+function printAnnotation(ann) {
+  if (typeof ann === "object") {
+    if (ann.TAG === "Tag") {
+      return `@tag("` + ann._0 + `")`;
+    } else {
+      return;
+    }
+  }
+  switch (ann) {
+    case "GenType" :
+      return "@genType";
+    case "Schema" :
+      return "@schema";
+    case "Unboxed" :
+      return "@unboxed";
+    case "SNull" :
+      return;
+  }
+}
+
+function printAnnotations(annotations) {
+  return Core__Array.filterMap(annotations, printAnnotation).join("\n");
+}
+
+function printTypeDef(typeDef) {
+  let annotations = printAnnotations(typeDef.annotations);
+  let fields = typeDef.kind;
+  let body;
+  switch (fields.TAG) {
+    case "RecordDef" :
+      body = printRecord(fields._0);
+      break;
+    case "VariantDef" :
+      body = fields._0.map(printVariantCase).join(" | ");
+      break;
+    case "AliasDef" :
+      body = printType(fields._0);
+      break;
+  }
+  return annotations + `\ntype ` + typeDef.name + ` = ` + body;
+}
+
+function print(module_) {
+  let typeDefs = module_.types.map(printTypeDef).join("\n\n");
+  return module_.preamble + "\n\n" + typeDefs;
+}
+
+export {
+  printPrimitive,
+  printType,
+  printField,
+  printRecord,
+  printVariantCase,
+  printVariantCases,
+  printAnnotation,
+  printAnnotations,
+  printTypeDef,
+  print,
+}
+/* No side effect */

package/src/Codegen.res.mjs

@@ -1,59 +1,45 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as IRGen from "./IRGen.res.mjs";
+import * as Errors from "./Errors.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 BackendReScript from "./BackendReScript.res.mjs";
 import * as CodegenTransforms from "./CodegenTransforms.res.mjs";
 
 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
-  })));
-  let seen = {};
-  let uniqueUnions = extractedUnions.filter(u => {
-    if (Core__Option.isSome(seen[u.name])) {
-      return false;
-    } else {
-      seen[u.name] = true;
-      return true;
-    }
-  });
-  let modifiedSchemas = schemas.map(s => ({
-    name: s.name,
-    schema: CodegenTransforms.replaceUnions(s.name, s.schema),
-    discriminatorTag: s.discriminatorTag
-  }));
-  let allSchemas = uniqueUnions.concat(modifiedSchemas);
-  let schemasDict = {};
-  let tagsDict = {};
-  allSchemas.forEach(s => {
-    schemasDict[s.name] = s.schema;
-    let tag = s.discriminatorTag;
-    if (tag !== undefined) {
-      tagsDict[s.name] = tag;
-      return;
-    }
-  });
-  let sorted = CodegenTransforms.topologicalSort(allSchemas);
-  let skipSet = {};
-  let typeDefs = sorted.map(s => CodegenTypes.generateTypeDefWithSkipSet(s, skipSet, schemasDict, tagsDict)).join("\n\n");
-  let code = "module S = Sury\n\n" + typeDefs;
+  let irModule = IRGen.generate(schemas);
+  if (irModule.TAG !== "Ok") {
+    return {
+      TAG: "Error",
+      _0: irModule._0
+    };
+  }
+  let irModule$1 = irModule._0;
+  let code = BackendReScript.print(irModule$1);
   return {
-    code: code,
-    warnings: warnings
+    TAG: "Ok",
+    _0: {
+      code: code,
+      warnings: irModule$1.warnings
+    }
   };
 }
 
 function generateModule(schemas) {
   let result = generateModuleWithDiagnostics(schemas);
-  result.warnings.forEach(w => {
-    console.log(w);
+  if (result.TAG === "Ok") {
+    let result$1 = result._0;
+    result$1.warnings.forEach(w => {
+      console.log(w);
+    });
+    return result$1.code;
+  }
+  result._0.forEach(e => {
+    console.error(Errors.formatError(e));
   });
-  return result.code;
+  return "";
 }
 
 let lcFirst = CodegenHelpers.lcFirst;
@@ -96,6 +82,8 @@ let buildSkipSchemaSet = CodegenTransforms.buildSkipSchemaSet;
 
 let collectUnionWarnings = CodegenTransforms.collectUnionWarnings;
 
+let validateUnionDiscriminators = CodegenTransforms.validateUnionDiscriminators;
+
 let generateType = CodegenTypes.generateType;
 
 let generateTypeDef = CodegenTypes.generateTypeDef;
@@ -135,6 +123,7 @@ export {
   topologicalSort,
   buildSkipSchemaSet,
   collectUnionWarnings,
+  validateUnionDiscriminators,
   generateType,
   generateTypeDef,
   generateTypeDefWithSkipSet,

package/src/CodegenHelpers.res.mjs

@@ -120,6 +120,8 @@ function getTagForType(t) {
         return "Bool";
       case "Null" :
         return "Null";
+      case "Unknown" :
+        return "Unknown";
     }
   } else {
     switch (t._tag) {
@@ -170,6 +172,29 @@ function hasUnion(_schema) {
   };
 }
 
+function hasUnknown(_schema) {
+  while (true) {
+    let schema = _schema;
+    if (typeof schema !== "object") {
+      return schema === "Unknown";
+    }
+    switch (schema._tag) {
+      case "Object" :
+        return schema._0.some(f => hasUnknown(f.type));
+      case "PolyVariant" :
+        return schema._0.some(c => hasUnknown(c.payload));
+      case "Optional" :
+      case "Nullable" :
+      case "Array" :
+      case "Dict" :
+        _schema = schema._0;
+        continue;
+      default:
+        return false;
+    }
+  };
+}
+
 function isPrimitiveOnlyUnion(types) {
   return types.every(t => {
     if (typeof t === "object") {
@@ -196,6 +221,7 @@ export {
   isNullableType,
   getTagForType,
   hasUnion,
+  hasUnknown,
   isPrimitiveOnlyUnion,
 }
 /* No side effect */

package/src/CodegenTransforms.res.mjs

@@ -1,5 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Errors from "./Errors.res.mjs";
 import * as Core__Array from "@rescript/core/src/Core__Array.res.mjs";
 import * as Core__Option from "@rescript/core/src/Core__Option.res.mjs";
 import * as CodegenHelpers from "./CodegenHelpers.res.mjs";
@@ -88,6 +89,8 @@ function getUnionName(types) {
           return "bool";
         case "Null" :
           return "null";
+        default:
+          return "unknown";
       }
     } else {
       switch (t._tag) {
@@ -330,7 +333,7 @@ function topologicalSort(schemas) {
 function buildSkipSchemaSet(schemas) {
   let skipSet = {};
   schemas.forEach(s => {
-    if (CodegenHelpers.hasUnion(s.schema)) {
+    if (CodegenHelpers.hasUnion(s.schema) || CodegenHelpers.hasUnknown(s.schema)) {
       skipSet[s.name] = true;
       return;
     }
@@ -404,6 +407,94 @@ function collectUnionWarnings(schemas) {
   return warnings;
 }
 
+function validateUnionDiscriminators(schemas) {
+  let seen = {};
+  let errors = [];
+  let schemasDict = {};
+  schemas.forEach(s => {
+    schemasDict[s.name] = s.schema;
+  });
+  let tagsDict = {};
+  schemas.forEach(s => {
+    let tag = s.discriminatorTag;
+    if (tag !== undefined) {
+      tagsDict[s.name] = tag;
+      return;
+    }
+  });
+  let fieldDiscsDict = {};
+  schemas.forEach(s => {
+    let dict = s.fieldDiscriminators;
+    if (dict !== undefined) {
+      Object.entries(dict).forEach(param => {
+        fieldDiscsDict[param[0]] = param[1];
+      });
+      return;
+    }
+  });
+  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;
+      if (CodegenHelpers.isPrimitiveOnlyUnion(types)) {
+        return;
+      }
+      let match = isRefPlusDictUnion(types);
+      if (match !== undefined) {
+        return;
+      }
+      let match$1 = isPrimitivePlusDictUnion(types);
+      if (match$1 !== undefined) {
+        return;
+      }
+      if (!Core__Option.isNone(fieldDiscsDict[unionName])) {
+        return;
+      }
+      let allRefsHaveTags = types.every(t => {
+        if (typeof t !== "object" || t._tag !== "Ref") {
+          return true;
+        } else {
+          return Core__Option.isSome(tagsDict[t._0]);
+        }
+      });
+      if (!allRefsHaveTags) {
+        errors.push(Errors.makeError({
+          TAG: "MissingDiscriminator",
+          _0: unionName
+        }, undefined, "Add discriminator: { propertyName: \"type\" } to the anyOf/oneOf schema, or use the _tag convention with const values", undefined));
+        return;
+      }
+    });
+  });
+  return errors;
+}
+
 export {
   isRefPlusDictUnion,
   isPrimitivePlusDictUnion,
@@ -416,5 +507,6 @@ export {
   topologicalSort,
   buildSkipSchemaSet,
   collectUnionWarnings,
+  validateUnionDiscriminators,
 }
 /* No side effect */