osury 0.26.0 → 0.28.0

package/package.json

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

package/src/CodegenTransforms.res.mjs

@@ -348,7 +348,39 @@ function topologicalSort(schemas) {
 function buildSkipSchemaSet(schemas) {
   let skipSet = {};
   schemas.forEach(s => {
-    if (CodegenHelpers.hasUnion(s.schema) || CodegenHelpers.hasUnknown(s.schema)) {
+    let types = s.schema;
+    let hasInlineProblem;
+    let exit = 0;
+    if (typeof types !== "object") {
+      exit = 1;
+    } else {
+      switch (types._tag) {
+        case "PolyVariant" :
+          hasInlineProblem = types._0.some(c => {
+            if (CodegenHelpers.hasUnion(c.payload)) {
+              return true;
+            } else {
+              return CodegenHelpers.hasUnknown(c.payload);
+            }
+          });
+          break;
+        case "Union" :
+          hasInlineProblem = types._0.some(t => {
+            if (CodegenHelpers.hasUnion(t)) {
+              return true;
+            } else {
+              return CodegenHelpers.hasUnknown(t);
+            }
+          });
+          break;
+        default:
+          exit = 1;
+      }
+    }
+    if (exit === 1) {
+      hasInlineProblem = CodegenHelpers.hasUnion(s.schema) || CodegenHelpers.hasUnknown(s.schema);
+    }
+    if (hasInlineProblem) {
       skipSet[s.name] = true;
       return;
     }

package/src/IRGen.res.mjs

@@ -166,16 +166,17 @@ function convertToIrTypeDef(namedSchema, schemasDict, tagsDict, skipSchemaSet) {
             payload: payload
           };
         });
+        let baseAnnotations = [
+          "GenType",
+          {
+            TAG: "Tag",
+            _0: tagName
+          }
+        ];
+        let annotations = shouldSkipSchema ? baseAnnotations : baseAnnotations.concat(["Schema"]);
         return {
           name: typeName,
-          annotations: [
-            "GenType",
-            {
-              TAG: "Tag",
-              _0: tagName
-            },
-            "Schema"
-          ],
+          annotations: annotations,
           kind: {
             TAG: "VariantDef",
             _0: irCases
@@ -192,17 +193,18 @@ function convertToIrTypeDef(namedSchema, schemasDict, tagsDict, skipSchemaSet) {
               payload: payload
             };
           });
+          let baseAnnotations$1 = [
+            "GenType",
+            {
+              TAG: "Tag",
+              _0: tagName
+            },
+            "Unboxed"
+          ];
+          let annotations$1 = shouldSkipSchema ? baseAnnotations$1 : baseAnnotations$1.concat(["Schema"]);
           return {
             name: typeName,
-            annotations: [
-              "GenType",
-              {
-                TAG: "Tag",
-                _0: tagName
-              },
-              "Unboxed",
-              "Schema"
-            ],
+            annotations: annotations$1,
             kind: {
               TAG: "VariantDef",
               _0: irCases$1
@@ -244,16 +246,17 @@ function convertToIrTypeDef(namedSchema, schemasDict, tagsDict, skipSchemaSet) {
             payload: payload$1
           };
         });
+        let baseAnnotations$2 = [
+          "GenType",
+          {
+            TAG: "Tag",
+            _0: tagName
+          }
+        ];
+        let annotations$2 = shouldSkipSchema ? baseAnnotations$2 : baseAnnotations$2.concat(["Schema"]);
         return {
           name: typeName,
-          annotations: [
-            "GenType",
-            {
-              TAG: "Tag",
-              _0: tagName
-            },
-            "Schema"
-          ],
+          annotations: annotations$2,
           kind: {
             TAG: "VariantDef",
             _0: irCases$2
@@ -278,13 +281,13 @@ function convertToIrTypeDef(namedSchema, schemasDict, tagsDict, skipSchemaSet) {
         _0: convertType(namedSchema.schema)
       });
   }
-  let annotations = shouldSkipSchema ? ["GenType"] : [
+  let annotations$3 = shouldSkipSchema ? ["GenType"] : [
       "GenType",
       "Schema"
     ];
   return {
     name: typeName,
-    annotations: annotations,
+    annotations: annotations$3,
     kind: kind
   };
 }

package/src/OpenAPIParser.res.mjs

@@ -375,6 +375,147 @@ function parseComponentSchemas(componentsJson) {
   };
 }
 
+function buildParamsObjectJson(params) {
+  let properties = {};
+  let required = [];
+  params.forEach(param => {
+    if (typeof param !== "object" || param === null || Array.isArray(param)) {
+      return;
+    }
+    let match = param["in"];
+    let location = typeof match === "string" ? match : undefined;
+    let isQueryOrPath;
+    if (location !== undefined) {
+      switch (location) {
+        case "path" :
+        case "query" :
+          isQueryOrPath = true;
+          break;
+        default:
+          isQueryOrPath = false;
+      }
+    } else {
+      isQueryOrPath = false;
+    }
+    if (!isQueryOrPath) {
+      return;
+    }
+    let match$1 = param["name"];
+    let match$2 = param["schema"];
+    if (match$1 === undefined) {
+      return;
+    }
+    if (typeof match$1 !== "string") {
+      return;
+    }
+    if (match$2 === undefined) {
+      return;
+    }
+    properties[match$1] = match$2;
+    let match$3 = param["required"];
+    let isRequired = match$3 === true;
+    let pathRequired = location === "path";
+    if (isRequired || pathRequired) {
+      required.push(match$1);
+      return;
+    }
+  });
+  if (Object.entries(properties).length === 0) {
+    return;
+  }
+  let obj = {};
+  obj["type"] = "object";
+  obj["properties"] = properties;
+  obj["required"] = required;
+  return obj;
+}
+
+function parsePathParameters(pathsJson) {
+  if (typeof pathsJson !== "object" || pathsJson === null || Array.isArray(pathsJson)) {
+    return {
+      TAG: "Ok",
+      _0: []
+    };
+  }
+  let results = Object.entries(pathsJson).flatMap(param => {
+    let methodsJson = param[1];
+    let path = param[0];
+    if (typeof methodsJson === "object" && methodsJson !== null && !Array.isArray(methodsJson)) {
+      return Core__Array.filterMap(Object.entries(methodsJson), param => {
+        let opJson = param[1];
+        let method = param[0];
+        let httpMethods = [
+          "get",
+          "post",
+          "put",
+          "patch",
+          "delete"
+        ];
+        if (!httpMethods.includes(method)) {
+          return;
+        }
+        if (typeof opJson !== "object" || opJson === null || Array.isArray(opJson)) {
+          return;
+        }
+        let match = opJson["parameters"];
+        if (match === undefined) {
+          return;
+        }
+        if (!Array.isArray(match)) {
+          return;
+        }
+        let objJson = buildParamsObjectJson(match);
+        if (objJson === undefined) {
+          return;
+        }
+        let name = ucFirst(method) + pathToName(path) + "Params";
+        let schemaType = Schema.parse(objJson);
+        if (schemaType.TAG === "Ok") {
+          return {
+            TAG: "Ok",
+            _0: {
+              name: name,
+              schema: schemaType._0,
+              discriminatorTag: undefined,
+              discriminatorPropertyName: undefined,
+              fieldDiscriminators: undefined
+            }
+          };
+        } else {
+          return {
+            TAG: "Error",
+            _0: schemaType._0
+          };
+        }
+      });
+    } else {
+      return [];
+    }
+  });
+  let errors = Core__Array.filterMap(results, r => {
+    if (r.TAG === "Ok") {
+      return;
+    } else {
+      return r._0;
+    }
+  }).flat();
+  if (errors.length > 0) {
+    return {
+      TAG: "Error",
+      _0: errors
+    };
+  }
+  let schemas = Core__Array.filterMap(results, r => {
+    if (r.TAG === "Ok") {
+      return r._0;
+    }
+  });
+  return {
+    TAG: "Ok",
+    _0: schemas
+  };
+}
+
 function parseDocument(json) {
   if (typeof json === "object" && json !== null && !Array.isArray(json)) {
     let componentsJson = json["components"];
@@ -387,29 +528,38 @@ function parseDocument(json) {
         TAG: "Ok",
         _0: []
       });
-    if (componentSchemas.TAG === "Ok") {
-      if (pathSchemas.TAG === "Ok") {
+    let pathsJson$1 = json["paths"];
+    let paramSchemas = pathsJson$1 !== undefined ? parsePathParameters(pathsJson$1) : ({
+        TAG: "Ok",
+        _0: []
+      });
+    let exit = 0;
+    if (componentSchemas.TAG === "Ok" && pathSchemas.TAG === "Ok") {
+      if (paramSchemas.TAG === "Ok") {
         return {
           TAG: "Ok",
-          _0: componentSchemas._0.concat(pathSchemas._0)
-        };
-      } else {
-        return {
-          TAG: "Error",
-          _0: pathSchemas._0
+          _0: componentSchemas._0.concat(pathSchemas._0).concat(paramSchemas._0)
         };
       }
-    }
-    let e = componentSchemas._0;
-    if (pathSchemas.TAG === "Ok") {
-      return {
-        TAG: "Error",
-        _0: e
-      };
+      exit = 2;
     } else {
+      exit = 2;
+    }
+    if (exit === 2) {
+      let errs = Core__Array.filterMap([
+        componentSchemas,
+        pathSchemas,
+        paramSchemas
+      ], r => {
+        if (r.TAG === "Ok") {
+          return;
+        } else {
+          return r._0;
+        }
+      }).flat();
       return {
         TAG: "Error",
-        _0: e.concat(pathSchemas._0)
+        _0: errs
       };
     }
   }
@@ -431,6 +581,8 @@ export {
   extractDiscriminatorPropertyName,
   extractDiscriminatorTag,
   parseComponentSchemas,
+  buildParamsObjectJson,
+  parsePathParameters,
   parseDocument,
 }
 /* No side effect */