@f3liz/rescript-autogen-openapi 0.1.6 → 0.2.0

package/lib/es6/src/generators/IRToTypeGenerator.mjs

@@ -75,7 +75,23 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
         }
       case "Union" :
         let types = irType._0;
-        let match = Stdlib_Array.reduce(types, [
+        let nonNullTypes = types.filter(t => {
+          if (typeof t !== "object") {
+            return t !== "Null";
+          }
+          if (t.TAG !== "Literal") {
+            return true;
+          }
+          let tmp = t._0;
+          return typeof tmp === "object";
+        });
+        let hasNull = nonNullTypes.length < types.length;
+        if (hasNull && nonNullTypes.length === 1) {
+          let inner = recurse(nonNullTypes[0]);
+          return `option<` + inner + `>`;
+        }
+        let effectiveTypes = hasNull ? nonNullTypes : types;
+        let match = Stdlib_Array.reduce(effectiveTypes, [
           false,
           false,
           undefined,
@@ -100,10 +116,10 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
           }
         });
         let arrayItemType = match[2];
-        if (match[0] && match[1] && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown"))) {
-          return `array<` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `>`;
-        }
-        if (types.every(t => {
+        let result;
+        if (match[0] && match[1] && effectiveTypes.length === 2 && SchemaIR.equals(Stdlib_Option.getOr(arrayItemType, "Unknown"), Stdlib_Option.getOr(match[3], "Unknown"))) {
+          result = `array<` + recurse(Stdlib_Option.getOr(arrayItemType, "Unknown")) + `>`;
+        } else if (effectiveTypes.every(t => {
             if (typeof t !== "object") {
               return false;
             }
@@ -116,8 +132,8 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
             } else {
               return tmp.TAG === "StringLiteral";
             }
-          }) && types.length !== 0 && types.length <= 50) {
-          let variants = types.map(t => {
+          }) && effectiveTypes.length !== 0 && effectiveTypes.length <= 50) {
+          let variants = effectiveTypes.map(t => {
             if (typeof t !== "object") {
               return "#Unknown";
             }
@@ -131,26 +147,155 @@ function generateTypeWithContext(ctx, depthOpt, irType) {
               return `#` + JsConvertCase.toPascalCase(s._0);
             }
           }).join(" | ");
-          return `[` + variants + `]`;
+          result = `[` + variants + `]`;
+        } else if (effectiveTypes.length !== 0) {
+          let hasPrimitives = {
+            contents: false
+          };
+          let variantCases = effectiveTypes.map((t, i) => {
+            let match;
+            let exit = 0;
+            if (typeof t !== "object") {
+              if (t === "Boolean") {
+                hasPrimitives.contents = true;
+                match = [
+                  "Bool",
+                  "bool"
+                ];
+              } else {
+                exit = 1;
+              }
+            } else {
+              switch (t.TAG) {
+                case "String" :
+                  hasPrimitives.contents = true;
+                  match = [
+                    "String",
+                    "string"
+                  ];
+                  break;
+                case "Number" :
+                  hasPrimitives.contents = true;
+                  match = [
+                    "Float",
+                    "float"
+                  ];
+                  break;
+                case "Integer" :
+                  hasPrimitives.contents = true;
+                  match = [
+                    "Int",
+                    "int"
+                  ];
+                  break;
+                case "Array" :
+                  match = [
+                    "Array",
+                    `array<` + recurse(t.items) + `>`
+                  ];
+                  break;
+                case "Object" :
+                  match = [
+                    "Object",
+                    recurse(t)
+                  ];
+                  break;
+                case "Reference" :
+                  let ref = t._0;
+                  let name = Stdlib_Option.getOr(ref.split("/")[ref.split("/").length - 1 | 0], "");
+                  match = [
+                    JsConvertCase.toPascalCase(name),
+                    recurse(t)
+                  ];
+                  break;
+                default:
+                  exit = 1;
+              }
+            }
+            if (exit === 1) {
+              match = [
+                `V` + i.toString(),
+                recurse(t)
+              ];
+            }
+            return `  | ` + match[0] + `(` + match[1] + `)`;
+          });
+          let unboxedAttr = hasPrimitives.contents ? "@unboxed " : "";
+          result = unboxedAttr + `[\n` + variantCases.join("\n") + `\n]`;
+        } else {
+          result = "JSON.t";
+        }
+        if (hasNull) {
+          return `option<` + result + `>`;
+        } else {
+          return result;
         }
-        GenerationContext.addWarning(ctx, {
-          TAG: "ComplexUnionSimplified",
-          location: ctx.path,
-          types: types.map(SchemaIR.toString).join(" | ")
-        });
-        return "JSON.t";
       case "Intersection" :
         let types$1 = irType._0;
-        if (types$1.every(t => typeof t !== "object" ? false : t.TAG === "Reference") && types$1.length !== 0) {
+        if (types$1.every(t => {
+            if (typeof t !== "object") {
+              return false;
+            } else {
+              return t.TAG === "Reference";
+            }
+          }) && types$1.length !== 0) {
           return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
-        } else {
-          GenerationContext.addWarning(ctx, {
-            TAG: "IntersectionNotFullySupported",
-            location: ctx.path,
-            note: "Complex intersection"
-          });
-          return "JSON.t";
         }
+        let match$1 = Stdlib_Array.reduce(types$1, [
+          [],
+          []
+        ], (param, t) => {
+          let nonObj = param[1];
+          let props = param[0];
+          if (typeof t !== "object") {
+            return [
+              props,
+              nonObj.concat([t])
+            ];
+          } else if (t.TAG === "Object") {
+            return [
+              props.concat(t.properties),
+              nonObj
+            ];
+          } else {
+            return [
+              props,
+              nonObj.concat([t])
+            ];
+          }
+        });
+        let nonObjectTypes = match$1[1];
+        let objectProps = match$1[0];
+        if (objectProps.length !== 0 && nonObjectTypes.length === 0) {
+          let fields$1 = objectProps.map(param => {
+            let name = param[0];
+            let typeCode = recurse(param[1]);
+            let finalType = param[2] ? typeCode : `option<` + typeCode + `>`;
+            let camelName = JsConvertCase.toCamelCase(name);
+            let escapedName = CodegenUtils.escapeKeyword(camelName);
+            let aliasAnnotation = escapedName !== name ? `@as("` + name + `") ` : "";
+            return `  ` + aliasAnnotation + escapedName + `: ` + finalType + `,`;
+          }).join("\n");
+          return `{\n` + fields$1 + `\n}`;
+        }
+        if (nonObjectTypes.length !== 0 && objectProps.length === 0) {
+          return recurse(Stdlib_Option.getOr(types$1[types$1.length - 1 | 0], "Unknown"));
+        }
+        GenerationContext.addWarning(ctx, {
+          TAG: "IntersectionNotFullySupported",
+          location: ctx.path,
+          note: "Mixed object/non-object intersection"
+        });
+        let fields$2 = objectProps.map(param => {
+          let name = param[0];
+          let typeCode = recurse(param[1]);
+          let finalType = param[2] ? typeCode : `option<` + typeCode + `>`;
+          let camelName = JsConvertCase.toCamelCase(name);
+          let escapedName = CodegenUtils.escapeKeyword(camelName);
+          let aliasAnnotation = escapedName !== name ? `@as("` + name + `") ` : "";
+          return `  ` + aliasAnnotation + escapedName + `: ` + finalType + `,`;
+        }).join("\n");
+        return `{\n` + fields$2 + `\n}`;
       case "Reference" :
         let ref = irType._0;
         let available = ctx.availableSchemas;

package/lib/es6/src/types/CodegenError.d.ts

@@ -0,0 +1,66 @@
+export type context = {
+    readonly path: string;
+    readonly operation: string;
+    readonly schema: (undefined | unknown);
+};
+export type t = {
+    TAG: "SpecResolutionError";
+    readonly url: string;
+    readonly message: string;
+} | {
+    TAG: "SchemaParseError";
+    readonly context: context;
+    readonly reason: string;
+} | {
+    TAG: "ReferenceError";
+    readonly ref: string;
+    readonly context: context;
+} | {
+    TAG: "ValidationError";
+    readonly schema: string;
+    readonly input: unknown;
+    readonly issues: string[];
+} | {
+    TAG: "CircularSchemaError";
+    readonly ref: string;
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "FileWriteError";
+    readonly filePath: string;
+    readonly message: string;
+} | {
+    TAG: "InvalidConfigError";
+    readonly field: string;
+    readonly message: string;
+} | {
+    TAG: "UnknownError";
+    readonly message: string;
+    readonly context: (undefined | context);
+};
+export type Warning_t = {
+    TAG: "FallbackToJson";
+    readonly reason: string;
+    readonly context: context;
+} | {
+    TAG: "UnsupportedFeature";
+    readonly feature: string;
+    readonly fallback: string;
+    readonly location: string;
+} | {
+    TAG: "DepthLimitReached";
+    readonly depth: number;
+    readonly path: string;
+} | {
+    TAG: "MissingSchema";
+    readonly ref: string;
+    readonly location: string;
+} | {
+    TAG: "IntersectionNotFullySupported";
+    readonly location: string;
+    readonly note: string;
+} | {
+    TAG: "ComplexUnionSimplified";
+    readonly location: string;
+    readonly types: string;
+};

package/lib/es6/src/types/Config.d.ts

@@ -0,0 +1,31 @@
+export type generationStrategy = "Separate" | "SharedBase";
+export type breakingChangeHandling = "Error" | "Warn" | "Ignore";
+export type forkSpecConfig = {
+    readonly name: string;
+    readonly specPath: string;
+};
+export type generationTargets = {
+    readonly rescriptApi: boolean;
+    readonly rescriptWrapper: boolean;
+    readonly typescriptDts: boolean;
+    readonly typescriptWrapper: boolean;
+};
+export type t = {
+    readonly specPath: string;
+    readonly forkSpecs: (undefined | forkSpecConfig[]);
+    readonly outputDir: string;
+    readonly strategy: generationStrategy;
+    readonly modulePerTag: boolean;
+    readonly includeTags: (undefined | string[]);
+    readonly excludeTags: (undefined | string[]);
+    readonly generateDiffReport: boolean;
+    readonly breakingChangeHandling: breakingChangeHandling;
+    readonly generateDocOverrides: (undefined | boolean);
+    readonly docOverrideDir: (undefined | string);
+    readonly targets: (undefined | generationTargets);
+    readonly dtsOutputDir: (undefined | string);
+    readonly wrapperOutputDir: (undefined | string);
+    readonly baseInstanceName: (undefined | string);
+    readonly baseModulePrefix: (undefined | string);
+};
+export declare const make: (specPath: string, outputDir: string, strategy: (undefined | generationStrategy), modulePerTag: (undefined | boolean), includeTags: (undefined | string[]), excludeTags: (undefined | string[]), generateDiffReport: (undefined | boolean), breakingChangeHandling: (undefined | breakingChangeHandling), forkSpecs: (undefined | forkSpecConfig[]), generateDocOverrides: (undefined | boolean), docOverrideDir: (undefined | string), targets: (undefined | generationTargets), dtsOutputDir: (undefined | string), wrapperOutputDir: (undefined | string), baseInstanceName: (undefined | string), baseModulePrefix: (undefined | string), _17: void) => t;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f3liz/rescript-autogen-openapi",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Generate ReScript code with Sury schemas from OpenAPI 3.1 specs. Supports multiple forks with diff/merge capabilities.",
   "keywords": [
     "rescript",
@@ -16,7 +16,8 @@
   "license": "MPL-2.0",
   "files": [
     "src/**/*.res",
-    "lib/es6/**/*.mjs",
+    "lib/es6/src/**/*.mjs",
+    "lib/es6/src/**/*.d.ts",
     "rescript.json",
     "README.md",
     "LICENSE"
@@ -25,23 +26,27 @@
     "url": "https://github.com/f3liz-dev/rescript-autogen-openapi"
   },
   "scripts": {
-    "build": "rescript",
+    "build": "rescript && node scripts/generate-dts.mjs",
     "clean": "rescript clean",
     "watch": "rescript build -w",
-    "test": "node --test"
+    "test": "node --test",
+    "prepublishOnly": "npm run build && npm test"
   },
   "main": "lib/es6/src/Codegen.mjs",
+  "types": "lib/es6/src/Codegen.d.ts",
   "type": "module",
   "dependencies": {
     "@readme/openapi-parser": "^5.5.0",
     "js-convert-case": "^4.2.0",
-    "pathe": "^2.0.3",
-    "sury": "11.0.0-alpha.4"
+    "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "rescript": "^12.1.0"
+    "rescript": "^12.1.0",
+    "sury": "11.0.0-alpha.4",
+    "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "rescript": "^12.0.0"
+    "rescript": "^12.0.0",
+    "sury": ">=11.0.0-alpha.4"
   }
 }

package/rescript.json

@@ -13,6 +13,12 @@
     }
   ],
   "suffix": ".mjs",
+  "gentypeconfig": {
+    "language": "typescript",
+    "module": "es6",
+    "importPath": "relative",
+    "generatedFileExtension": ".gen.ts"
+  },
   "dependencies": [],
   "warnings": {
     "number": "-44-102"

package/src/Codegen.res

@@ -7,6 +7,7 @@ open Types
 @val external promiseAll: array<promise<'a>> => promise<array<'a>> = "Promise.all"
 
 // Generate code from a single spec (pure - returns data)
+@genType
 let generateSingleSpecPure = (~spec: openAPISpec, ~config: generationConfig): result<Pipeline.t, codegenError> => {
   try {
     let targets = config.targets->Option.getOr(Config.defaultTargets())
@@ -54,6 +55,7 @@ let generateSingleSpecPure = (~spec: openAPISpec, ~config: generationConfig): re
 }
 
 // Generate code from a single spec (with side effects)
+@genType
 let generateSingleSpec = async (~spec: openAPISpec, ~config: generationConfig): generationResult => {
   switch generateSingleSpecPure(~spec, ~config) {
   | Result.Error(err) => Result.Error(err)
@@ -140,6 +142,7 @@ let processForkPure = (~baseSpec: openAPISpec, ~baseEndpoints: array<endpoint>,
 }
 
 // Generate code from multiple specs (pure - returns data)
+@genType
 let generateMultiSpecPure = (~baseSpec: openAPISpec, ~forkSpecs: array<forkSpec>, ~config: generationConfig): result<Pipeline.t, codegenError> => {
   try {
     let baseEndpoints = OpenAPIParser.getAllEndpoints(baseSpec)
@@ -169,6 +172,7 @@ let generateMultiSpecPure = (~baseSpec: openAPISpec, ~forkSpecs: array<forkSpec>
 }
 
 // Generate code from multiple specs (with side effects)
+@genType
 let generateMultiSpec = async (~baseSpec: openAPISpec, ~forkSpecs: array<forkSpec>, ~config: generationConfig): generationResult =>
   switch generateMultiSpecPure(~baseSpec, ~forkSpecs, ~config) {
   | Result.Error(err) => Result.Error(err)
@@ -179,6 +183,7 @@ let generateMultiSpec = async (~baseSpec: openAPISpec, ~forkSpecs: array<forkSpe
   }
 
 // Compare two specs and generate diff report
+@genType
 let compareSpecs = async (~baseSpec, ~forkSpec, ~baseName="base", ~forkName="fork", ~outputPath=?) => {
   let diff = SpecDiffer.generateDiff(~baseSpec, ~forkSpec, ~baseEndpoints=OpenAPIParser.getAllEndpoints(baseSpec), ~forkEndpoints=OpenAPIParser.getAllEndpoints(forkSpec))
   outputPath->Option.forEach(path => {
@@ -188,6 +193,7 @@ let compareSpecs = async (~baseSpec, ~forkSpec, ~baseName="base", ~forkName="for
 }
 
 // Main generation function
+@genType
 let generate = async (config: generationConfig): generationResult => {
   switch await SchemaRefResolver.resolve(config.specPath) {
   | Result.Error(message) => Result.Error(SpecResolutionError({url: config.specPath, message}))
@@ -207,6 +213,7 @@ let generate = async (config: generationConfig): generationResult => {
   }
 }
 
+@genType
 let createDefaultConfig = (url, outputDir): generationConfig => ({
   specPath: url, outputDir, strategy: SharedBase, includeTags: None, excludeTags: None,
   modulePerTag: true, generateDiffReport: true, breakingChangeHandling: Warn,
@@ -215,8 +222,10 @@ let createDefaultConfig = (url, outputDir): generationConfig => ({
   baseInstanceName: None, baseModulePrefix: None,
 })
 
+@genType
 let generateFromUrl = async (~url, ~outputDir, ~config=?) => 
   await generate({...config->Option.getOr(createDefaultConfig(url, outputDir)), specPath: url})
 
+@genType
 let generateFromFile = async (~filePath, ~outputDir, ~config=?) => 
   await generate({...config->Option.getOr(createDefaultConfig(filePath, outputDir)), specPath: filePath})

package/src/Types.res

@@ -3,6 +3,7 @@
 // Types.res - Core OpenAPI and generation types (refactored & compact)
 
 // ============= JSON Schema Types =============
+@genType
 type rec jsonSchemaType =
   | String
   | Number
@@ -13,6 +14,7 @@ type rec jsonSchemaType =
   | Null
   | Unknown
 
+@genType
 and jsonSchema = {
   @as("type") type_: option<jsonSchemaType>,
   properties: option<dict<jsonSchema>>,
@@ -34,25 +36,30 @@ and jsonSchema = {
 }
 
 // ============= OpenAPI 3.1 Types =============
+@genType
 type httpMethod = [#GET | #POST | #PUT | #PATCH | #DELETE | #HEAD | #OPTIONS]
 
+@genType
 type mediaType = {
   schema: option<jsonSchema>,
   example: option<JSON.t>,
   examples: option<dict<JSON.t>>,
 }
 
+@genType
 type requestBody = {
   description: option<string>,
   content: dict<mediaType>,
   required: option<bool>,
 }
 
+@genType
 type response = {
   description: string,
   content: option<dict<mediaType>>,
 }
 
+@genType
 type parameter = {
   name: string,
   @as("in") in_: string,
@@ -61,6 +68,7 @@ type parameter = {
   schema: option<jsonSchema>,
 }
 
+@genType
 type operation = {
   operationId: option<string>,
   summary: option<string>,
@@ -71,6 +79,7 @@ type operation = {
   parameters: option<array<parameter>>,
 }
 
+@genType
 type endpoint = {
   path: string,
   method: string,
@@ -83,6 +92,7 @@ type endpoint = {
   parameters: option<array<parameter>>,
 }
 
+@genType
 type pathItem = {
   get: option<operation>,
   post: option<operation>,
@@ -94,14 +104,17 @@ type pathItem = {
   parameters: option<array<parameter>>,
 }
 
+@genType
 type components = {schemas: option<dict<jsonSchema>>}
 
+@genType
 type info = {
   title: string,
   version: string,
   description: option<string>,
 }
 
+@genType
 type openAPISpec = {
   openapi: string,
   info: info,
@@ -111,32 +124,40 @@ type openAPISpec = {
 
 // ============= Re-exports from focused modules =============
 // Config types
+@genType
 type generationStrategy = Config.generationStrategy =
   | Separate
   | SharedBase
 
+@genType
 type breakingChangeHandling = Config.breakingChangeHandling = | Error | Warn | Ignore
+@genType
 type forkSpecConfig = Config.forkSpecConfig = {name: string, specPath: string}
+@genType
 type generationTargets = Config.generationTargets = {
   rescriptApi: bool,
   rescriptWrapper: bool,
   typescriptDts: bool,
   typescriptWrapper: bool,
 }
+@genType
 type generationConfig = Config.t
 
+@genType
 type forkSpec = {
   name: string,
   spec: openAPISpec,
 }
 
 // Error types - use `=` syntax to re-export constructors
+@genType
 type errorContext = CodegenError.context = {
   path: string,
   operation: string,
   schema: option<JSON.t>,
 }
 
+@genType
 type codegenError = CodegenError.t =
   | SpecResolutionError({url: string, message: string})
   | SchemaParseError({context: errorContext, reason: string})
@@ -147,6 +168,7 @@ type codegenError = CodegenError.t =
   | InvalidConfigError({field: string, message: string})
   | UnknownError({message: string, context: option<errorContext>})
 
+@genType
 type warning = CodegenError.Warning.t =
   | FallbackToJson({reason: string, context: errorContext})
   | UnsupportedFeature({feature: string, fallback: string, location: string})
@@ -156,6 +178,7 @@ type warning = CodegenError.Warning.t =
   | ComplexUnionSimplified({location: string, types: string})
 
 // ============= Diff Types =============
+@genType
 type endpointDiff = {
   path: string,
   method: string,
@@ -164,11 +187,13 @@ type endpointDiff = {
   breakingChange: bool,
 }
 
+@genType
 type schemaDiff = {
   name: string,
   breakingChange: bool,
 }
 
+@genType
 type specDiff = {
   addedEndpoints: array<endpoint>,
   removedEndpoints: array<endpoint>,
@@ -179,12 +204,14 @@ type specDiff = {
 }
 
 // ============= Generation Result Types =============
+@genType
 type generationSuccess = {
   generatedFiles: array<string>,
   diff: option<specDiff>,
   warnings: array<warning>,
 }
 
+@genType
 type generationResult = result<generationSuccess, codegenError>
 
 // ============= Re-export helper modules =============

package/src/core/FileSystem.res

@@ -8,6 +8,7 @@
 @module("pathe") external dirname: string => string = "dirname"
 
 // Represents a file to be written
+@genType
 type fileToWrite = {
   path: string,
   content: string,

package/src/core/Pipeline.res

@@ -3,6 +3,7 @@
 // Pipeline.res - Compact data transformation pipeline
 open Types
 
+@genType
 type t = {
   files: array<FileSystem.fileToWrite>,
   warnings: array<warning>,