@f3liz/rescript-autogen-openapi 0.1.0

package/lib/es6/src/core/SchemaIR.mjs

@@ -0,0 +1,355 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+
+function isOptional(irType) {
+  if (typeof irType !== "object") {
+    return false;
+  } else {
+    return irType.TAG === "Option";
+  }
+}
+
+function unwrapOption(irType) {
+  if (typeof irType !== "object" || irType.TAG !== "Option") {
+    return irType;
+  } else {
+    return irType._0;
+  }
+}
+
+function makeOptional(irType) {
+  if (typeof irType !== "object" || irType.TAG !== "Option") {
+    return {
+      TAG: "Option",
+      _0: irType
+    };
+  } else {
+    return irType;
+  }
+}
+
+function isSimpleType(_irType) {
+  while (true) {
+    let irType = _irType;
+    if (typeof irType !== "object") {
+      return irType !== "Unknown";
+    }
+    switch (irType.TAG) {
+      case "Array" :
+        _irType = irType.items;
+        continue;
+      case "Object" :
+      case "Union" :
+      case "Intersection" :
+        return false;
+      case "Option" :
+        _irType = irType._0;
+        continue;
+      default:
+        return true;
+    }
+  };
+}
+
+function complexityScore(_irType) {
+  while (true) {
+    let irType = _irType;
+    if (typeof irType !== "object") {
+      return 1;
+    }
+    switch (irType.TAG) {
+      case "Array" :
+        return 1 + complexityScore(irType.items) | 0;
+      case "Object" :
+        let propsScore = Stdlib_Array.reduce(irType.properties.map(param => complexityScore(param[1])), 0, (acc, score) => acc + score | 0);
+        return 5 + propsScore | 0;
+      case "Union" :
+        let typesScore = Stdlib_Array.reduce(irType._0.map(complexityScore), 0, (acc, score) => acc + score | 0);
+        return 2 + typesScore | 0;
+      case "Intersection" :
+        let typesScore$1 = Stdlib_Array.reduce(irType._0.map(complexityScore), 0, (acc, score) => acc + score | 0);
+        return 3 + typesScore$1 | 0;
+      case "Option" :
+        _irType = irType._0;
+        continue;
+      default:
+        return 1;
+    }
+  };
+}
+
+function extractComplexTypes(baseName, irType, thresholdOpt) {
+  let threshold = thresholdOpt !== undefined ? thresholdOpt : 10;
+  let score = complexityScore(irType);
+  if (score <= threshold) {
+    return [
+      irType,
+      []
+    ];
+  }
+  if (typeof irType !== "object") {
+    return [
+      irType,
+      []
+    ];
+  }
+  switch (irType.TAG) {
+    case "Array" :
+      let match = extractComplexTypes(baseName + `_Item`, irType.items, threshold);
+      return [
+        {
+          TAG: "Array",
+          items: match[0],
+          constraints: irType.constraints
+        },
+        match[1]
+      ];
+    case "Object" :
+      let match$1 = Stdlib_Array.reduce(irType.properties.map(param => {
+        let propName = param[0];
+        let propBaseName = baseName + `_` + propName;
+        let match = extractComplexTypes(propBaseName, param[1], threshold);
+        return [
+          [
+            propName,
+            match[0],
+            param[2]
+          ],
+          match[1]
+        ];
+      }), [
+        [],
+        []
+      ], (param, param$1) => [
+        param[0].concat([param$1[0]]),
+        param[1].concat(param$1[1])
+      ]);
+      let newType_0 = match$1[0];
+      let newType_1 = irType.additionalProperties;
+      let newType = {
+        TAG: "Object",
+        properties: newType_0,
+        additionalProperties: newType_1
+      };
+      return [
+        {
+          TAG: "Reference",
+          _0: `#/components/schemas/` + baseName
+        },
+        match$1[1].concat([{
+            name: baseName,
+            description: undefined,
+            type_: newType
+          }])
+      ];
+    case "Union" :
+      let match$2 = Stdlib_Array.reduce(irType._0.map((type_, i) => extractComplexTypes(baseName + `_Variant` + i.toString(), type_, threshold)), [
+        [],
+        []
+      ], (param, param$1) => [
+        param[0].concat([param$1[0]]),
+        param[1].concat(param$1[1])
+      ]);
+      return [
+        {
+          TAG: "Union",
+          _0: match$2[0]
+        },
+        match$2[1]
+      ];
+    case "Option" :
+      let match$3 = extractComplexTypes(baseName, irType._0, threshold);
+      return [
+        {
+          TAG: "Option",
+          _0: match$3[0]
+        },
+        match$3[1]
+      ];
+    default:
+      return [
+        irType,
+        []
+      ];
+  }
+}
+
+function equals(_a, _b) {
+  while (true) {
+    let b = _b;
+    let a = _a;
+    if (typeof a !== "object") {
+      switch (a) {
+        case "Boolean" :
+          if (typeof b !== "object") {
+            return b === "Boolean";
+          } else {
+            return false;
+          }
+        case "Null" :
+          if (typeof b !== "object") {
+            return b === "Null";
+          } else {
+            return false;
+          }
+        case "Unknown" :
+          if (typeof b !== "object") {
+            return b === "Unknown";
+          } else {
+            return false;
+          }
+      }
+    } else {
+      switch (a.TAG) {
+        case "String" :
+          if (typeof b !== "object") {
+            return false;
+          } else {
+            return b.TAG === "String";
+          }
+        case "Number" :
+          if (typeof b !== "object") {
+            return false;
+          } else {
+            return b.TAG === "Number";
+          }
+        case "Integer" :
+          if (typeof b !== "object") {
+            return false;
+          } else {
+            return b.TAG === "Integer";
+          }
+        case "Array" :
+          if (typeof b !== "object") {
+            return false;
+          }
+          if (b.TAG !== "Array") {
+            return false;
+          }
+          _b = b.items;
+          _a = a.items;
+          continue;
+        case "Literal" :
+          if (typeof b !== "object") {
+            return false;
+          }
+          if (b.TAG !== "Literal") {
+            return false;
+          }
+          let litB = b._0;
+          let litA = a._0;
+          if (typeof litA !== "object") {
+            return typeof litB !== "object";
+          }
+          switch (litA.TAG) {
+            case "StringLiteral" :
+              if (typeof litB !== "object" || litB.TAG !== "StringLiteral") {
+                return false;
+              } else {
+                return litA._0 === litB._0;
+              }
+            case "NumberLiteral" :
+              if (typeof litB !== "object" || litB.TAG !== "NumberLiteral") {
+                return false;
+              } else {
+                return litA._0 === litB._0;
+              }
+            case "BooleanLiteral" :
+              if (typeof litB !== "object" || litB.TAG !== "BooleanLiteral") {
+                return false;
+              } else {
+                return litA._0 === litB._0;
+              }
+          }
+        case "Reference" :
+          if (typeof b !== "object" || b.TAG !== "Reference") {
+            return false;
+          } else {
+            return a._0 === b._0;
+          }
+        case "Option" :
+          if (typeof b !== "object") {
+            return false;
+          }
+          if (b.TAG !== "Option") {
+            return false;
+          }
+          _b = b._0;
+          _a = a._0;
+          continue;
+        default:
+          return false;
+      }
+    }
+  };
+}
+
+function toString(irType) {
+  if (typeof irType !== "object") {
+    switch (irType) {
+      case "Boolean" :
+        return "Boolean";
+      case "Null" :
+        return "Null";
+      case "Unknown" :
+        return "Unknown";
+    }
+  } else {
+    switch (irType.TAG) {
+      case "String" :
+        return "String";
+      case "Number" :
+        return "Number";
+      case "Integer" :
+        return "Integer";
+      case "Array" :
+        return `Array<` + toString(irType.items) + `>`;
+      case "Object" :
+        let props = irType.properties.map(param => {
+          let req = param[2] ? "" : "?";
+          return param[0] + req + `: ` + toString(param[1]);
+        }).join(", ");
+        return `{ ` + props + ` }`;
+      case "Literal" :
+        let s = irType._0;
+        if (typeof s !== "object") {
+          return "null";
+        }
+        switch (s.TAG) {
+          case "StringLiteral" :
+            return `"` + s._0 + `"`;
+          case "NumberLiteral" :
+            return s._0.toString();
+          case "BooleanLiteral" :
+            if (s._0) {
+              return "true";
+            } else {
+              return "false";
+            }
+        }
+      case "Union" :
+        let typeStrs = irType._0.map(toString).join(" | ");
+        return `(` + typeStrs + `)`;
+      case "Intersection" :
+        let typeStrs$1 = irType._0.map(toString).join(" & ");
+        return `(` + typeStrs$1 + `)`;
+      case "Reference" :
+        return irType._0;
+      case "Option" :
+        return `Option<` + toString(irType._0) + `>`;
+    }
+  }
+}
+
+export {
+  isOptional,
+  unwrapOption,
+  makeOptional,
+  isSimpleType,
+  complexityScore,
+  extractComplexTypes,
+  equals,
+  toString,
+}
+/* No side effect */