osury 0.17.3 → 0.19.0

package/src/IRGen.res.mjs

@@ -0,0 +1,352 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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";
+
+function convertType(schema) {
+  if (typeof schema !== "object") {
+    switch (schema) {
+      case "String" :
+        return {
+          TAG: "Primitive",
+          _0: "PString"
+        };
+      case "Number" :
+        return {
+          TAG: "Primitive",
+          _0: "PFloat"
+        };
+      case "Integer" :
+        return {
+          TAG: "Primitive",
+          _0: "PInt"
+        };
+      case "Boolean" :
+        return {
+          TAG: "Primitive",
+          _0: "PBool"
+        };
+      case "Null" :
+        return {
+          TAG: "Primitive",
+          _0: "PUnit"
+        };
+      case "Unknown" :
+        return "JSON";
+    }
+  } else {
+    switch (schema._tag) {
+      case "Optional" :
+        return {
+          TAG: "Option",
+          _0: convertType(schema._0)
+        };
+      case "Nullable" :
+        return {
+          TAG: "Nullable",
+          _0: convertType(schema._0)
+        };
+      case "Object" :
+        return {
+          TAG: "InlineRecord",
+          _0: schema._0.map(convertField)
+        };
+      case "Array" :
+        return {
+          TAG: "Array",
+          _0: convertType(schema._0)
+        };
+      case "Ref" :
+        return {
+          TAG: "Named",
+          _0: CodegenHelpers.lcFirst(schema._0)
+        };
+      case "Enum" :
+        return {
+          TAG: "Enum",
+          _0: schema._0
+        };
+      case "PolyVariant" :
+        return {
+          TAG: "InlineVariant",
+          _0: schema._0.map(c => {
+            let payload = convertType(c.payload);
+            return {
+              tag: c._tag,
+              payload: payload
+            };
+          })
+        };
+      case "Dict" :
+        return {
+          TAG: "Dict",
+          _0: convertType(schema._0)
+        };
+      case "Union" :
+        return {
+          TAG: "InlineVariant",
+          _0: schema._0.map(t => {
+            let tag = CodegenHelpers.getTagForType(t);
+            let payload = convertType(t);
+            return {
+              tag: tag,
+              payload: payload
+            };
+          })
+        };
+    }
+  }
+}
+
+function convertField(field) {
+  let baseType = convertType(field.type);
+  let wrappedType = field.required || CodegenHelpers.isOptionalType(field.type) ? baseType : ({
+      TAG: "Option",
+      _0: baseType
+    });
+  let annotations = [];
+  if (CodegenHelpers.isNullableType(field.type)) {
+    annotations.push("SNull");
+  }
+  if (CodegenHelpers.isReservedKeyword(field.name)) {
+    annotations.push({
+      TAG: "As",
+      _0: field.name
+    });
+  }
+  let fieldName = CodegenHelpers.isReservedKeyword(field.name) ? field.name + "_" : field.name;
+  return {
+    name: fieldName,
+    annotations: annotations,
+    type_: wrappedType
+  };
+}
+
+function convertToIrTypeDef(namedSchema, schemasDict, tagsDict, skipSchemaSet) {
+  let typeName = CodegenHelpers.lcFirst(namedSchema.name);
+  let tagName = Core__Option.getOr(namedSchema.discriminatorPropertyName, "_tag");
+  let shouldSkipSchema = Core__Option.isSome(skipSchemaSet[namedSchema.name]);
+  let cases = namedSchema.schema;
+  if (typeof cases === "object") {
+    switch (cases._tag) {
+      case "PolyVariant" :
+        let irCases = cases._0.map(c => {
+          let refName = c.payload;
+          let payload;
+          if (typeof refName !== "object" || refName._tag !== "Ref") {
+            payload = convertType(refName);
+          } else {
+            let refName$1 = refName._0;
+            let other = schemasDict[refName$1];
+            payload = other !== undefined ? (
+                typeof other !== "object" || other._tag !== "Object" ? convertType(other) : ({
+                    TAG: "InlineRecord",
+                    _0: other._0.map(convertField)
+                  })
+              ) : ({
+                TAG: "Named",
+                _0: CodegenHelpers.lcFirst(refName$1)
+              });
+          }
+          return {
+            tag: CodegenHelpers.ucFirst(c._tag),
+            payload: payload
+          };
+        });
+        let annotations = shouldSkipSchema ? [
+            "GenType",
+            {
+              TAG: "Tag",
+              _0: tagName
+            }
+          ] : [
+            "GenType",
+            {
+              TAG: "Tag",
+              _0: tagName
+            },
+            "Schema"
+          ];
+        return {
+          name: typeName,
+          annotations: annotations,
+          kind: {
+            TAG: "VariantDef",
+            _0: irCases
+          }
+        };
+      case "Union" :
+        let types = cases._0;
+        if (CodegenHelpers.isPrimitiveOnlyUnion(types)) {
+          let irCases$1 = types.map(t => {
+            let tag = CodegenHelpers.getTagForType(t);
+            let payload = convertType(t);
+            return {
+              tag: tag,
+              payload: payload
+            };
+          });
+          let annotations$1 = shouldSkipSchema ? [
+              "GenType",
+              {
+                TAG: "Tag",
+                _0: tagName
+              },
+              "Unboxed"
+            ] : [
+              "GenType",
+              {
+                TAG: "Tag",
+                _0: tagName
+              },
+              "Unboxed",
+              "Schema"
+            ];
+          return {
+            name: typeName,
+            annotations: annotations$1,
+            kind: {
+              TAG: "VariantDef",
+              _0: irCases$1
+            }
+          };
+        }
+        let irCases$2 = types.map(t => {
+          if (typeof t === "object" && t._tag === "Ref") {
+            let name = t._0;
+            let tagValue = tagsDict[name];
+            let tag = tagValue !== undefined ? CodegenHelpers.ucFirst(tagValue) : CodegenHelpers.ucFirst(name);
+            let other = schemasDict[name];
+            let payload = other !== undefined ? (
+                typeof other !== "object" || other._tag !== "Object" ? convertType(other) : ({
+                    TAG: "InlineRecord",
+                    _0: other._0.map(convertField)
+                  })
+              ) : ({
+                TAG: "Named",
+                _0: CodegenHelpers.lcFirst(name)
+              });
+            return {
+              tag: tag,
+              payload: payload
+            };
+          }
+          let tag$1 = CodegenHelpers.getTagForType(t);
+          let payload$1 = convertType(t);
+          return {
+            tag: tag$1,
+            payload: payload$1
+          };
+        });
+        let annotations$2 = shouldSkipSchema ? [
+            "GenType",
+            {
+              TAG: "Tag",
+              _0: tagName
+            }
+          ] : [
+            "GenType",
+            {
+              TAG: "Tag",
+              _0: tagName
+            },
+            "Schema"
+          ];
+        return {
+          name: typeName,
+          annotations: annotations$2,
+          kind: {
+            TAG: "VariantDef",
+            _0: irCases$2
+          }
+        };
+    }
+  }
+  let fields = namedSchema.schema;
+  let kind;
+  kind = typeof fields !== "object" || fields._tag !== "Object" ? ({
+      TAG: "AliasDef",
+      _0: convertType(namedSchema.schema)
+    }) : ({
+      TAG: "RecordDef",
+      _0: fields._0.map(convertField)
+    });
+  let annotations$3 = shouldSkipSchema ? ["GenType"] : [
+      "GenType",
+      "Schema"
+    ];
+  return {
+    name: typeName,
+    annotations: annotations$3,
+    kind: kind
+  };
+}
+
+function generate(schemas) {
+  let validationErrors = CodegenTransforms.validateUnionDiscriminators(schemas);
+  if (validationErrors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: validationErrors
+    };
+  }
+  let warnings = CodegenTransforms.collectUnionWarnings(schemas);
+  let extractedUnions = schemas.flatMap(s => CodegenTransforms.extractUnions(s.name, s.schema).map(extracted => {
+    let dict = s.fieldDiscriminators;
+    let discriminatorPropertyName = dict !== undefined ? dict[extracted.name] : undefined;
+    return {
+      name: extracted.name,
+      schema: extracted.schema,
+      discriminatorTag: undefined,
+      discriminatorPropertyName: discriminatorPropertyName,
+      fieldDiscriminators: 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,
+    discriminatorPropertyName: s.discriminatorPropertyName,
+    fieldDiscriminators: s.fieldDiscriminators
+  }));
+  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 skipSchemaSet = CodegenTransforms.buildSkipSchemaSet(allSchemas);
+  let sorted = CodegenTransforms.topologicalSort(allSchemas);
+  let irTypes = sorted.map(s => convertToIrTypeDef(s, schemasDict, tagsDict, skipSchemaSet));
+  return {
+    TAG: "Ok",
+    _0: {
+      preamble: "module S = Sury",
+      types: irTypes,
+      warnings: warnings
+    }
+  };
+}
+
+export {
+  convertType,
+  convertField,
+  convertToIrTypeDef,
+  generate,
+}
+/* No side effect */

package/src/OpenAPIParser.res.mjs

@@ -3,6 +3,7 @@
 import * as Errors from "./Errors.res.mjs";
 import * as Schema from "./Schema.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";
 
 function pathToName(path) {
   return path.split("/").filter(s => {
@@ -92,7 +93,9 @@ function parsePathResponses(pathsJson) {
             _0: {
               name: name,
               schema: schemaType._0,
-              discriminatorTag: undefined
+              discriminatorTag: undefined,
+              discriminatorPropertyName: undefined,
+              fieldDiscriminators: undefined
             }
           };
         } else {
@@ -130,6 +133,86 @@ function parsePathResponses(pathsJson) {
   };
 }
 
+function extractFieldDiscriminators(schemaJson) {
+  let result = {};
+  if (typeof schemaJson === "object" && schemaJson !== null && !Array.isArray(schemaJson)) {
+    let match = schemaJson["properties"];
+    if (typeof match === "object" && match !== null && !Array.isArray(match)) {
+      Object.entries(match).forEach(param => {
+        let propJson = param[1];
+        if (typeof propJson !== "object" || propJson === null || Array.isArray(propJson)) {
+          return;
+        }
+        let match = propJson["anyOf"];
+        let match$1 = propJson["discriminator"];
+        if (match === undefined) {
+          return;
+        }
+        if (!Array.isArray(match)) {
+          return;
+        }
+        if (match$1 === undefined) {
+          return;
+        }
+        if (typeof match$1 !== "object" || match$1 === null || Array.isArray(match$1)) {
+          return;
+        }
+        let match$2 = match$1["propertyName"];
+        if (match$2 === undefined) {
+          return;
+        }
+        if (typeof match$2 !== "string") {
+          return;
+        }
+        let memberNames = Core__Array.filterMap(match, item => {
+          if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            return;
+          }
+          let match = item["$ref"];
+          if (match === undefined) {
+            return;
+          }
+          if (typeof match !== "string") {
+            return;
+          }
+          let parts = match.split("/");
+          return parts[parts.length - 1 | 0];
+        });
+        if (memberNames.length < 2) {
+          return;
+        }
+        let lcNames = memberNames.map(n => {
+          let first = n.charAt(0).toLowerCase();
+          let rest = n.slice(1);
+          return first + rest;
+        });
+        let firstName = Core__Option.getOr(lcNames[0], "unknown");
+        let restNames = lcNames.slice(1);
+        let unionName = firstName + restNames.map(n => "Or" + ucFirst(n)).join("");
+        result[unionName] = match$2;
+      });
+    }
+  }
+  return result;
+}
+
+function extractDiscriminatorPropertyName(schemaJson) {
+  if (typeof schemaJson !== "object" || schemaJson === null || Array.isArray(schemaJson)) {
+    return;
+  }
+  let match = schemaJson["discriminator"];
+  if (match === undefined) {
+    return;
+  }
+  if (typeof match !== "object" || match === null || Array.isArray(match)) {
+    return;
+  }
+  let match$1 = match["propertyName"];
+  if (typeof match$1 === "string") {
+    return match$1;
+  }
+}
+
 function extractDiscriminatorTag(schemaJson) {
   if (typeof schemaJson !== "object" || schemaJson === null || Array.isArray(schemaJson)) {
     return;
@@ -169,6 +252,9 @@ function parseComponentSchemas(componentsJson) {
       let results = entries.map(param => {
         let schemaJson = param[1];
         let discriminatorTag = extractDiscriminatorTag(schemaJson);
+        let discriminatorPropertyName = extractDiscriminatorPropertyName(schemaJson);
+        let fieldDiscs = extractFieldDiscriminators(schemaJson);
+        let fieldDiscriminators = Object.entries(fieldDiscs).length > 0 ? fieldDiscs : undefined;
         let schemaType = Schema.parse(schemaJson);
         if (schemaType.TAG === "Ok") {
           return {
@@ -176,7 +262,9 @@ function parseComponentSchemas(componentsJson) {
             _0: {
               name: param[0],
               schema: schemaType._0,
-              discriminatorTag: discriminatorTag
+              discriminatorTag: discriminatorTag,
+              discriminatorPropertyName: discriminatorPropertyName,
+              fieldDiscriminators: fieldDiscriminators
             }
           };
         } else {
@@ -280,6 +368,8 @@ export {
   pathToName,
   ucFirst,
   parsePathResponses,
+  extractFieldDiscriminators,
+  extractDiscriminatorPropertyName,
   extractDiscriminatorTag,
   parseComponentSchemas,
   parseDocument,