osury 0.28.0 → 1.0.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "osury",
   "type": "module",
   "description": "Generate ReScript types with Sury schemas from OpenAPI specifications",
-  "version": "0.28.0",
+  "version": "1.0.0",
   "license": "MIT",
   "bin": {
     "osury": "bin/osury.mjs"

package/src/BackendReScript.res.mjs

@@ -4,7 +4,7 @@ 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 quoteTag(tag) {
-  let needsQuoting = tag.split("").some(c => {
+  let needsQuoting = tag === "" || tag.split("").some(c => {
     let code = c.charCodeAt(0);
     return !(code >= 97.0 && code <= 122.0 || code >= 65.0 && code <= 90.0 || code >= 48.0 && code <= 57.0 || code === 95.0);
   });
@@ -32,7 +32,7 @@ function printPrimitive(p) {
 
 function printType(t) {
   if (typeof t !== "object") {
-    return "JSON.t";
+    return "@s.matches(S.json) JSON.t";
   }
   switch (t.TAG) {
     case "Primitive" :

package/src/Codegen.res.mjs

@@ -60,6 +60,16 @@ let hasUnion = CodegenHelpers.hasUnion;
 
 let isPrimitiveOnlyUnion = CodegenHelpers.isPrimitiveOnlyUnion;
 
+let collectInlineEnums = CodegenTransforms.collectInlineEnums;
+
+let resolveEnumNames = CodegenTransforms.resolveEnumNames;
+
+let camelize = CodegenTransforms.camelize;
+
+let replaceInlineEnums = CodegenTransforms.replaceInlineEnums;
+
+let buildExtractedEnumSchemas = CodegenTransforms.buildExtractedEnumSchemas;
+
 let isRefPlusDictUnion = CodegenTransforms.isRefPlusDictUnion;
 
 let isPrimitivePlusDictUnion = CodegenTransforms.isPrimitivePlusDictUnion;
@@ -116,6 +126,11 @@ export {
   getTagForType,
   hasUnion,
   isPrimitiveOnlyUnion,
+  collectInlineEnums,
+  resolveEnumNames,
+  camelize,
+  replaceInlineEnums,
+  buildExtractedEnumSchemas,
   isRefPlusDictUnion,
   isPrimitivePlusDictUnion,
   getUnionName,

package/src/CodegenTransforms.res.mjs

@@ -4,6 +4,246 @@ 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";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+
+function collectEnumsFromType(parentType, fieldPath, _schema) {
+  while (true) {
+    let schema = _schema;
+    if (typeof schema !== "object") {
+      return [];
+    }
+    switch (schema._tag) {
+      case "Object" :
+        return schema._0.flatMap(f => collectEnumsFromType(parentType, fieldPath.concat([f.name]), f.type));
+      case "Enum" :
+        if (fieldPath.length > 0) {
+          return [{
+              parentType: parentType,
+              fieldPath: fieldPath,
+              values: schema._0
+            }];
+        } else {
+          return [];
+        }
+      case "PolyVariant" :
+        return schema._0.flatMap(c => collectEnumsFromType(parentType, fieldPath, c.payload));
+      case "Optional" :
+      case "Nullable" :
+      case "Array" :
+      case "Dict" :
+        break;
+      case "Union" :
+        return schema._0.flatMap(t => collectEnumsFromType(parentType, fieldPath, t));
+      default:
+        return [];
+    }
+    _schema = schema._0;
+    continue;
+  };
+}
+
+function collectInlineEnums(schemas) {
+  return schemas.flatMap(s => {
+    let match = s.schema;
+    if (typeof match !== "object") {
+      return collectEnumsFromType(s.name, [], s.schema);
+    } else if (match._tag === "Enum") {
+      return [];
+    } else {
+      return collectEnumsFromType(s.name, [], s.schema);
+    }
+  });
+}
+
+function camelize(s) {
+  let parts = s.replace(/-/g, "_").split("_").filter(p => p !== "");
+  let first = parts[0];
+  if (first === undefined) {
+    return s;
+  }
+  let rest = parts.slice(1);
+  return CodegenHelpers.lcFirst(first) + rest.map(CodegenHelpers.ucFirst).join("");
+}
+
+function occurrenceKey(occ) {
+  return occ.parentType + "::" + occ.fieldPath.join("/");
+}
+
+function valuesCanonicalKey(values) {
+  let cmp = (a, b) => {
+    if (Primitive_object.lessthan(a, b)) {
+      return -1.0;
+    } else if (Primitive_object.greaterthan(a, b)) {
+      return 1.0;
+    } else {
+      return 0.0;
+    }
+  };
+  return values.toSorted(cmp).join("");
+}
+
+function leafFieldName(occ) {
+  let s = occ.fieldPath[occ.fieldPath.length - 1 | 0];
+  if (s !== undefined) {
+    return s;
+  } else {
+    return "unknown";
+  }
+}
+
+function replaceEnumsInType(parentType, fieldPath, names, schema) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  switch (schema._tag) {
+    case "Optional" :
+      return {
+        _tag: "Optional",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Nullable" :
+      return {
+        _tag: "Nullable",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Object" :
+      return {
+        _tag: "Object",
+        _0: schema._0.map(f => {
+          let newType = replaceEnumsInType(parentType, fieldPath.concat([f.name]), names, f.type);
+          return {
+            name: f.name,
+            type: newType,
+            required: f.required
+          };
+        })
+      };
+    case "Array" :
+      return {
+        _tag: "Array",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Enum" :
+      if (fieldPath.length <= 0) {
+        return schema;
+      }
+      let key = parentType + "::" + fieldPath.join("/");
+      let name = names[key];
+      if (name !== undefined) {
+        return {
+          _tag: "Ref",
+          _0: CodegenHelpers.ucFirst(name)
+        };
+      } else {
+        return schema;
+      }
+    case "PolyVariant" :
+      return {
+        _tag: "PolyVariant",
+        _0: schema._0.map(c => {
+          let payload = replaceEnumsInType(parentType, fieldPath, names, c.payload);
+          return {
+            _tag: c._tag,
+            payload: payload
+          };
+        })
+      };
+    case "Dict" :
+      return {
+        _tag: "Dict",
+        _0: replaceEnumsInType(parentType, fieldPath, names, schema._0)
+      };
+    case "Union" :
+      return {
+        _tag: "Union",
+        _0: schema._0.map(t => replaceEnumsInType(parentType, fieldPath, names, t))
+      };
+    default:
+      return schema;
+  }
+}
+
+function replaceInlineEnums(schemas, names) {
+  return schemas.map(s => {
+    let match = s.schema;
+    let newSchema;
+    let exit = 0;
+    if (typeof match !== "object" || match._tag !== "Enum") {
+      exit = 1;
+    } else {
+      newSchema = s.schema;
+    }
+    if (exit === 1) {
+      newSchema = replaceEnumsInType(s.name, [], names, s.schema);
+    }
+    return {
+      name: s.name,
+      schema: newSchema,
+      discriminatorTag: s.discriminatorTag,
+      discriminatorPropertyName: s.discriminatorPropertyName,
+      fieldDiscriminators: s.fieldDiscriminators
+    };
+  });
+}
+
+function buildExtractedEnumSchemas(occurrences, names) {
+  let seen = {};
+  let result = [];
+  occurrences.forEach(occ => {
+    let key = occurrenceKey(occ);
+    let name = names[key];
+    if (name === undefined) {
+      return;
+    }
+    let typeName = CodegenHelpers.ucFirst(name);
+    if (Core__Option.isNone(seen[typeName])) {
+      seen[typeName] = true;
+      result.push({
+        name: typeName,
+        schema: {
+          _tag: "Enum",
+          _0: occ.values
+        },
+        discriminatorTag: undefined,
+        discriminatorPropertyName: undefined,
+        fieldDiscriminators: undefined
+      });
+      return;
+    }
+  });
+  return result;
+}
+
+function resolveEnumNames(occurrences, topLevelNames) {
+  let topLevelSet = {};
+  topLevelNames.forEach(n => {
+    topLevelSet[CodegenHelpers.lcFirst(n)] = true;
+  });
+  let buckets = {};
+  occurrences.forEach(occ => {
+    let leaf = leafFieldName(occ);
+    let vKey = valuesCanonicalKey(occ.values);
+    let set = buckets[leaf];
+    if (set !== undefined) {
+      set[vKey] = true;
+      return;
+    }
+    let set$1 = {};
+    set$1[vKey] = true;
+    buckets[leaf] = set$1;
+  });
+  let result = {};
+  occurrences.forEach(occ => {
+    let leaf = leafFieldName(occ);
+    let camelized = camelize(leaf);
+    let distinctSets = Core__Option.mapOr(buckets[leaf], 1, set => Object.keys(set).length);
+    let collidesTopLevel = Core__Option.isSome(topLevelSet[camelized]);
+    let baseName = distinctSets > 1 || collidesTopLevel ? CodegenHelpers.lcFirst(occ.parentType) + CodegenHelpers.ucFirst(camelized) : camelized;
+    let name = CodegenHelpers.isReservedKeyword(baseName) ? baseName + "_" : baseName;
+    result[occurrenceKey(occ)] = name;
+  });
+  return result;
+}
 
 function isRefPlusDictUnion(types) {
   if (types.length !== 2) {
@@ -350,36 +590,20 @@ function buildSkipSchemaSet(schemas) {
   schemas.forEach(s => {
     let types = s.schema;
     let hasInlineProblem;
-    let exit = 0;
     if (typeof types !== "object") {
-      exit = 1;
+      hasInlineProblem = CodegenHelpers.hasUnion(s.schema);
     } else {
       switch (types._tag) {
         case "PolyVariant" :
-          hasInlineProblem = types._0.some(c => {
-            if (CodegenHelpers.hasUnion(c.payload)) {
-              return true;
-            } else {
-              return CodegenHelpers.hasUnknown(c.payload);
-            }
-          });
+          hasInlineProblem = types._0.some(c => CodegenHelpers.hasUnion(c.payload));
           break;
         case "Union" :
-          hasInlineProblem = types._0.some(t => {
-            if (CodegenHelpers.hasUnion(t)) {
-              return true;
-            } else {
-              return CodegenHelpers.hasUnknown(t);
-            }
-          });
+          hasInlineProblem = types._0.some(CodegenHelpers.hasUnion);
           break;
         default:
-          exit = 1;
+          hasInlineProblem = CodegenHelpers.hasUnion(s.schema);
       }
     }
-    if (exit === 1) {
-      hasInlineProblem = CodegenHelpers.hasUnion(s.schema) || CodegenHelpers.hasUnknown(s.schema);
-    }
     if (hasInlineProblem) {
       skipSet[s.name] = true;
       return;
@@ -543,6 +767,16 @@ function validateUnionDiscriminators(schemas) {
 }
 
 export {
+  collectEnumsFromType,
+  collectInlineEnums,
+  camelize,
+  occurrenceKey,
+  valuesCanonicalKey,
+  leafFieldName,
+  replaceEnumsInType,
+  replaceInlineEnums,
+  buildExtractedEnumSchemas,
+  resolveEnumNames,
   isRefPlusDictUnion,
   isPrimitivePlusDictUnion,
   getUnionName,

package/src/IRGen.res.mjs

@@ -301,7 +301,13 @@ function generate(schemas) {
     };
   }
   let warnings = CodegenTransforms.collectUnionWarnings(schemas);
-  let extractedUnions = schemas.flatMap(s => CodegenTransforms.extractUnions(s.name, s.schema).map(extracted => {
+  let enumOccurrences = CodegenTransforms.collectInlineEnums(schemas);
+  let topLevelNames = schemas.map(s => s.name);
+  let enumNames = CodegenTransforms.resolveEnumNames(enumOccurrences, topLevelNames);
+  let enumSchemas = CodegenTransforms.buildExtractedEnumSchemas(enumOccurrences, enumNames);
+  let schemasAfterEnumPromotion = CodegenTransforms.replaceInlineEnums(schemas, enumNames);
+  let schemas$1 = enumSchemas.concat(schemasAfterEnumPromotion);
+  let extractedUnions = schemas$1.flatMap(s => CodegenTransforms.extractUnions(s.name, s.schema).map(extracted => {
     let dict = s.fieldDiscriminators;
     let discriminatorPropertyName = dict !== undefined ? dict[extracted.name] : undefined;
     return {
@@ -321,7 +327,7 @@ function generate(schemas) {
       return true;
     }
   });
-  let modifiedSchemas = schemas.map(s => ({
+  let modifiedSchemas = schemas$1.map(s => ({
     name: s.name,
     schema: CodegenTransforms.replaceUnions(s.name, s.schema),
     discriminatorTag: s.discriminatorTag,

package/src/OpenAPIParser.res.mjs

@@ -516,6 +516,138 @@ function parsePathParameters(pathsJson) {
   };
 }
 
+function extractAllDiscriminatorMappings(json) {
+  let result = {};
+  let walk = j => {
+    if (Array.isArray(j)) {
+      j.forEach(walk);
+      return;
+    }
+    switch (typeof j) {
+      case "object" :
+        let match = j["oneOf"];
+        let match$1 = j["discriminator"];
+        if (Array.isArray(match) && typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
+          let match$2 = match$1["mapping"];
+          if (typeof match$2 === "object" && match$2 !== null && !Array.isArray(match$2)) {
+            Object.entries(match$2).forEach(param => {
+              let refValue = param[1];
+              if (typeof refValue !== "string") {
+                return;
+              }
+              let parts = refValue.split("/");
+              let schemaName = parts[parts.length - 1 | 0];
+              if (schemaName !== undefined) {
+                result[schemaName] = param[0];
+                return;
+              }
+            });
+          }
+        }
+        Object.entries(j).forEach(param => walk(param[1]));
+        return;
+      default:
+        return;
+    }
+  };
+  walk(json);
+  return result;
+}
+
+function rewriteVariantTagsInType(schema, tagByRef) {
+  if (typeof schema !== "object") {
+    return schema;
+  }
+  switch (schema._tag) {
+    case "Optional" :
+      return {
+        _tag: "Optional",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Nullable" :
+      return {
+        _tag: "Nullable",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Object" :
+      return {
+        _tag: "Object",
+        _0: schema._0.map(f => ({
+          name: f.name,
+          type: rewriteVariantTagsInType(f.type, tagByRef),
+          required: f.required
+        }))
+      };
+    case "Array" :
+      return {
+        _tag: "Array",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "PolyVariant" :
+      let newCases = schema._0.map(c => {
+        let refName = c.payload;
+        if (typeof refName !== "object") {
+          return {
+            _tag: c._tag,
+            payload: rewriteVariantTagsInType(refName, tagByRef)
+          };
+        }
+        if (refName._tag !== "Ref") {
+          return {
+            _tag: c._tag,
+            payload: rewriteVariantTagsInType(refName, tagByRef)
+          };
+        }
+        let actualTag = tagByRef[refName._0];
+        if (actualTag !== undefined && actualTag !== c._tag) {
+          return {
+            _tag: actualTag,
+            payload: c.payload
+          };
+        } else {
+          return c;
+        }
+      });
+      return {
+        _tag: "PolyVariant",
+        _0: newCases
+      };
+    case "Dict" :
+      return {
+        _tag: "Dict",
+        _0: rewriteVariantTagsInType(schema._0, tagByRef)
+      };
+    case "Union" :
+      return {
+        _tag: "Union",
+        _0: schema._0.map(t => rewriteVariantTagsInType(t, tagByRef))
+      };
+    default:
+      return schema;
+  }
+}
+
+function resolveRefTagsInPolyVariants(schemas, mappingByRef) {
+  let tagByRef = {};
+  schemas.forEach(s => {
+    let tag = s.discriminatorTag;
+    if (tag !== undefined) {
+      tagByRef[s.name] = tag;
+      return;
+    }
+  });
+  Object.entries(mappingByRef).forEach(param => {
+    tagByRef[param[0]] = param[1];
+  });
+  return schemas.map(s => ({
+    name: s.name,
+    schema: rewriteVariantTagsInType(s.schema, tagByRef),
+    discriminatorTag: s.discriminatorTag,
+    discriminatorPropertyName: s.discriminatorPropertyName,
+    fieldDiscriminators: s.fieldDiscriminators
+  }));
+}
+
 function parseDocument(json) {
   if (typeof json === "object" && json !== null && !Array.isArray(json)) {
     let componentsJson = json["components"];
@@ -533,12 +665,13 @@ function parseDocument(json) {
         TAG: "Ok",
         _0: []
       });
+    let mappingByRef = extractAllDiscriminatorMappings(json);
     let exit = 0;
     if (componentSchemas.TAG === "Ok" && pathSchemas.TAG === "Ok") {
       if (paramSchemas.TAG === "Ok") {
         return {
           TAG: "Ok",
-          _0: componentSchemas._0.concat(pathSchemas._0).concat(paramSchemas._0)
+          _0: resolveRefTagsInPolyVariants(componentSchemas._0.concat(pathSchemas._0).concat(paramSchemas._0), mappingByRef)
         };
       }
       exit = 2;
@@ -583,6 +716,9 @@ export {
   parseComponentSchemas,
   buildParamsObjectJson,
   parsePathParameters,
+  extractAllDiscriminatorMappings,
+  rewriteVariantTagsInType,
+  resolveRefTagsInPolyVariants,
   parseDocument,
 }
 /* No side effect */