osury 1.0.1 → 1.2.0

package/src/Schema.res.mjs

@@ -1,877 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-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 Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-
-function isNullType(json) {
-  if (typeof json !== "object" || json === null || Array.isArray(json)) {
-    return false;
-  }
-  let match = json["type"];
-  return match === "null";
-}
-
-function hasDefault(json) {
-  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
-    return Core__Option.isSome(json["default"]);
-  } else {
-    return false;
-  }
-}
-
-function extractRefName(refPath) {
-  let parts = refPath.split("/");
-  return Core__Option.getOr(parts[parts.length - 1 | 0], refPath);
-}
-
-function parseEnumValues(arr) {
-  let values = Core__Array.filterMap(arr, item => {
-    if (typeof item === "string") {
-      return item;
-    }
-  });
-  if (values.length === arr.length) {
-    return values;
-  }
-}
-
-function extractTagFromConst(dict) {
-  let match = dict["_tag"];
-  if (match === undefined) {
-    return;
-  }
-  if (typeof match !== "object" || match === null || Array.isArray(match)) {
-    return;
-  }
-  let match$1 = match["const"];
-  if (typeof match$1 === "string") {
-    return match$1;
-  }
-}
-
-function extractTagFromProperty(dict, propertyName) {
-  let match = dict[propertyName];
-  if (match === undefined) {
-    return;
-  }
-  if (typeof match !== "object" || match === null || Array.isArray(match)) {
-    return;
-  }
-  let match$1 = match["const"];
-  if (typeof match$1 === "string") {
-    return match$1;
-  }
-}
-
-function extractDiscriminatorPropertyName(dict) {
-  let match = dict["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 parseSchema(json) {
-  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
-    return parseObject(json);
-  }
-  return {
-    TAG: "Error",
-    _0: [Errors.makeError({
-        TAG: "InvalidJson",
-        _0: "expected object"
-      }, undefined, undefined, undefined)]
-  };
-}
-
-function parsePrimitiveType(dict) {
-  let match = dict["type"];
-  if (match !== undefined) {
-    if (Array.isArray(match)) {
-      let typeStrings = Core__Array.filterMap(match, t => {
-        if (typeof t === "string") {
-          return t;
-        }
-      });
-      let hasNull = typeStrings.includes("null");
-      let nonNullTypes = typeStrings.filter(t => t !== "null");
-      if (!hasNull) {
-        return {
-          TAG: "Error",
-          _0: [Errors.makeError({
-              TAG: "UnsupportedFeature",
-              _0: "type array without null"
-            }, undefined, undefined, undefined)]
-        };
-      }
-      if (nonNullTypes.length !== 1) {
-        return {
-          TAG: "Error",
-          _0: [Errors.makeError({
-              TAG: "InvalidJson",
-              _0: "type array must have exactly one non-null type"
-            }, undefined, undefined, undefined)]
-        };
-      }
-      let nonNullType = nonNullTypes[0];
-      let newDict = Object.fromEntries(Object.entries(dict).map(param => {
-        let k = param[0];
-        if (k === "type") {
-          return [
-            k,
-            nonNullType
-          ];
-        } else {
-          return [
-            k,
-            param[1]
-          ];
-        }
-      }));
-      let inner = parsePrimitiveType(newDict);
-      if (inner.TAG === "Ok") {
-        return {
-          TAG: "Ok",
-          _0: {
-            _tag: "Nullable",
-            _0: inner._0
-          }
-        };
-      } else {
-        return {
-          TAG: "Error",
-          _0: inner._0
-        };
-      }
-    }
-    switch (typeof match) {
-      case "string" :
-        switch (match) {
-          case "array" :
-            return parseArrayType(dict);
-          case "boolean" :
-            return {
-              TAG: "Ok",
-              _0: "Boolean"
-            };
-          case "integer" :
-            return {
-              TAG: "Ok",
-              _0: "Integer"
-            };
-          case "null" :
-            return {
-              TAG: "Ok",
-              _0: "Null"
-            };
-          case "number" :
-            return {
-              TAG: "Ok",
-              _0: "Number"
-            };
-          case "object" :
-            return parseObjectType(dict);
-          case "string" :
-            let match$1 = dict["const"];
-            let exit = 0;
-            if (match$1 !== undefined) {
-              if (typeof match$1 === "string") {
-                return {
-                  TAG: "Ok",
-                  _0: {
-                    _tag: "Enum",
-                    _0: [match$1]
-                  }
-                };
-              }
-              exit = 2;
-            } else {
-              exit = 2;
-            }
-            if (exit === 2) {
-              let match$2 = dict["enum"];
-              if (match$2 === undefined) {
-                return {
-                  TAG: "Ok",
-                  _0: "String"
-                };
-              }
-              let exit$1 = 0;
-              if (Array.isArray(match$2)) {
-                let values = parseEnumValues(match$2);
-                if (values !== undefined) {
-                  return {
-                    TAG: "Ok",
-                    _0: {
-                      _tag: "Enum",
-                      _0: values
-                    }
-                  };
-                } else {
-                  return {
-                    TAG: "Error",
-                    _0: [Errors.makeError({
-                        TAG: "InvalidJson",
-                        _0: "enum values must be strings"
-                      }, undefined, undefined, undefined)]
-                  };
-                }
-              }
-              exit$1 = 3;
-              if (exit$1 === 3) {
-                return {
-                  TAG: "Error",
-                  _0: [Errors.makeError({
-                      TAG: "InvalidJson",
-                      _0: "enum must be an array"
-                    }, undefined, undefined, undefined)]
-                };
-              }
-            }
-            break;
-          default:
-            return {
-              TAG: "Error",
-              _0: [Errors.unknownType(match, undefined, undefined, undefined)]
-            };
-        }
-        break;
-    }
-    return {
-      TAG: "Error",
-      _0: [Errors.makeError({
-          TAG: "InvalidJson",
-          _0: "type must be a string or array"
-        }, undefined, undefined, undefined)]
-    };
-  }
-  let match$3 = dict["properties"];
-  if (match$3 !== undefined) {
-    return parseObjectType(dict);
-  } else {
-    return {
-      TAG: "Ok",
-      _0: "Unknown"
-    };
-  }
-}
-
-function parseArrayType(dict) {
-  let itemSchema = dict["items"];
-  if (itemSchema === undefined) {
-    return {
-      TAG: "Error",
-      _0: [Errors.missingField("items", undefined, "array type requires items schema", undefined)]
-    };
-  }
-  let itemType = parseSchema(itemSchema);
-  if (itemType.TAG === "Ok") {
-    return {
-      TAG: "Ok",
-      _0: {
-        _tag: "Array",
-        _0: itemType._0
-      }
-    };
-  } else {
-    return {
-      TAG: "Error",
-      _0: itemType._0
-    };
-  }
-}
-
-function parseAnyOf(items) {
-  let hasNull = items.some(isNullType);
-  let nonNullItems = items.filter(item => !isNullType(item));
-  if (hasNull && nonNullItems.length === 1) {
-    let match = nonNullItems[0];
-    if (match === undefined) {
-      return {
-        TAG: "Error",
-        _0: [Errors.makeError({
-            TAG: "InvalidJson",
-            _0: "anyOf with only null types"
-          }, undefined, undefined, undefined)]
-      };
-    }
-    if (typeof match === "object" && match !== null && !Array.isArray(match)) {
-      let innerType = parseObject(match);
-      if (innerType.TAG === "Ok") {
-        return {
-          TAG: "Ok",
-          _0: {
-            _tag: "Nullable",
-            _0: innerType._0
-          }
-        };
-      } else {
-        return {
-          TAG: "Error",
-          _0: innerType._0
-        };
-      }
-    }
-    return {
-      TAG: "Error",
-      _0: [Errors.makeError({
-          TAG: "InvalidJson",
-          _0: "anyOf item must be object"
-        }, undefined, undefined, undefined)]
-    };
-  }
-  if (!hasNull && nonNullItems.length >= 2) {
-    let results = nonNullItems.map(parseSchema);
-    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 types = Core__Array.filterMap(results, r => {
-      if (r.TAG === "Ok") {
-        return r._0;
-      }
-    });
-    return {
-      TAG: "Ok",
-      _0: {
-        _tag: "Union",
-        _0: types
-      }
-    };
-  }
-  if (!(hasNull && nonNullItems.length >= 2)) {
-    return {
-      TAG: "Error",
-      _0: [Errors.makeError({
-          TAG: "InvalidJson",
-          _0: "anyOf must have at least 2 items"
-        }, undefined, undefined, undefined)]
-    };
-  }
-  let results$1 = nonNullItems.map(parseSchema);
-  let errors$1 = Core__Array.filterMap(results$1, r => {
-    if (r.TAG === "Ok") {
-      return;
-    } else {
-      return r._0;
-    }
-  }).flat();
-  if (errors$1.length > 0) {
-    return {
-      TAG: "Error",
-      _0: errors$1
-    };
-  }
-  let types$1 = Core__Array.filterMap(results$1, r => {
-    if (r.TAG === "Ok") {
-      return r._0;
-    }
-  });
-  return {
-    TAG: "Ok",
-    _0: {
-      _tag: "Nullable",
-      _0: {
-        _tag: "Union",
-        _0: types$1
-      }
-    }
-  };
-}
-
-function parseObjectType(dict) {
-  let valueSchema = dict["additionalProperties"];
-  let exit = 0;
-  if (valueSchema !== undefined) {
-    switch (typeof valueSchema) {
-      case "boolean" :
-        if (valueSchema) {
-          return {
-            TAG: "Ok",
-            _0: {
-              _tag: "Dict",
-              _0: "String"
-            }
-          };
-        }
-        exit = 1;
-        break;
-      case "object" :
-        let valueType = parseSchema(valueSchema);
-        if (valueType.TAG === "Ok") {
-          return {
-            TAG: "Ok",
-            _0: {
-              _tag: "Dict",
-              _0: valueType._0
-            }
-          };
-        } else {
-          return {
-            TAG: "Error",
-            _0: valueType._0
-          };
-        }
-      default:
-        exit = 1;
-    }
-  } else {
-    exit = 1;
-  }
-  if (exit === 1) {
-    let match = dict["required"];
-    let requiredFields = match !== undefined ? (
-        Array.isArray(match) ? Core__Array.filterMap(match, item => {
-            if (typeof item === "string") {
-              return item;
-            }
-          }) : []
-      ) : [];
-    let match$1 = dict["properties"];
-    if (match$1 === undefined) {
-      return {
-        TAG: "Ok",
-        _0: {
-          _tag: "Object",
-          _0: []
-        }
-      };
-    }
-    let exit$1 = 0;
-    if (typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
-      let entries = Object.entries(match$1).filter(param => param[0] !== "_tag");
-      let results = entries.map(param => {
-        let propSchema = param[1];
-        let name = param[0];
-        let propType = parseSchema(propSchema);
-        if (propType.TAG === "Ok") {
-          return {
-            TAG: "Ok",
-            _0: {
-              name: name,
-              type: propType._0,
-              required: requiredFields.includes(name) || hasDefault(propSchema)
-            }
-          };
-        } else {
-          return {
-            TAG: "Error",
-            _0: propType._0
-          };
-        }
-      });
-      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 fields = Core__Array.filterMap(results, r => {
-        if (r.TAG === "Ok") {
-          return r._0;
-        }
-      });
-      return {
-        TAG: "Ok",
-        _0: {
-          _tag: "Object",
-          _0: fields
-        }
-      };
-    }
-    exit$1 = 2;
-    if (exit$1 === 2) {
-      return {
-        TAG: "Error",
-        _0: [Errors.makeError({
-            TAG: "InvalidJson",
-            _0: "properties must be an object"
-          }, undefined, undefined, undefined)]
-      };
-    }
-  }
-}
-
-function parseAllOf(items) {
-  let results = items.map(parseSchema);
-  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 allFields = Core__Array.filterMap(results, r => {
-    if (r.TAG !== "Ok") {
-      return;
-    }
-    let fields = r._0;
-    if (typeof fields !== "object" || fields._tag !== "Object") {
-      return;
-    } else {
-      return fields._0;
-    }
-  }).flat();
-  return {
-    TAG: "Ok",
-    _0: {
-      _tag: "Object",
-      _0: allFields
-    }
-  };
-}
-
-function parseOneOf(items, discriminatorPropertyNameOpt) {
-  let discriminatorPropertyName = discriminatorPropertyNameOpt !== undefined ? Primitive_option.valFromOption(discriminatorPropertyNameOpt) : undefined;
-  let propName = Core__Option.getOr(discriminatorPropertyName, "_tag");
-  let caseResults = items.map(item => {
-    if (typeof item === "object" && item !== null && !Array.isArray(item)) {
-      let match = item["$ref"];
-      let exit = 0;
-      if (match !== undefined) {
-        if (typeof match === "string") {
-          let name = extractRefName(match);
-          return {
-            TAG: "Ok",
-            _0: {
-              _tag: name,
-              payload: {
-                _tag: "Ref",
-                _0: name
-              }
-            }
-          };
-        }
-        exit = 2;
-      } else {
-        exit = 2;
-      }
-      if (exit === 2) {
-        let match$1 = item["properties"];
-        let exit$1 = 0;
-        if (match$1 !== undefined) {
-          if (typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1)) {
-            let tag = extractTagFromProperty(match$1, propName);
-            if (tag === undefined) {
-              return {
-                TAG: "Error",
-                _0: [Errors.makeError({
-                    TAG: "MissingRequiredField",
-                    _0: propName + " with const"
-                  }, undefined, undefined, undefined)]
-              };
-            }
-            let match$2 = item["required"];
-            let requiredFields = match$2 !== undefined ? (
-                Array.isArray(match$2) ? Core__Array.filterMap(match$2, i => {
-                    if (typeof i === "string") {
-                      return i;
-                    }
-                  }) : []
-              ) : [];
-            let entries = Object.entries(match$1).filter(param => param[0] !== propName);
-            let fieldResults = entries.map(param => {
-              let name = param[0];
-              let propType = parseSchema(param[1]);
-              if (propType.TAG === "Ok") {
-                return {
-                  TAG: "Ok",
-                  _0: {
-                    name: name,
-                    type: propType._0,
-                    required: requiredFields.includes(name)
-                  }
-                };
-              } else {
-                return {
-                  TAG: "Error",
-                  _0: propType._0
-                };
-              }
-            });
-            let errors = Core__Array.filterMap(fieldResults, r => {
-              if (r.TAG === "Ok") {
-                return;
-              } else {
-                return r._0;
-              }
-            }).flat();
-            if (errors.length > 0) {
-              return {
-                TAG: "Error",
-                _0: errors
-              };
-            }
-            let fields = Core__Array.filterMap(fieldResults, r => {
-              if (r.TAG === "Ok") {
-                return r._0;
-              }
-            });
-            return {
-              TAG: "Ok",
-              _0: {
-                _tag: tag,
-                payload: {
-                  _tag: "Object",
-                  _0: fields
-                }
-              }
-            };
-          }
-          exit$1 = 3;
-        } else {
-          exit$1 = 3;
-        }
-        if (exit$1 === 3) {
-          return {
-            TAG: "Error",
-            _0: [Errors.makeError({
-                TAG: "InvalidJson",
-                _0: "oneOf item must have properties"
-              }, undefined, undefined, undefined)]
-          };
-        }
-      }
-    }
-    return {
-      TAG: "Error",
-      _0: [Errors.makeError({
-          TAG: "InvalidJson",
-          _0: "oneOf item must be object"
-        }, undefined, undefined, undefined)]
-    };
-  });
-  let errors = Core__Array.filterMap(caseResults, r => {
-    if (r.TAG === "Ok") {
-      return;
-    } else {
-      return r._0;
-    }
-  }).flat();
-  if (errors.length > 0) {
-    return {
-      TAG: "Error",
-      _0: errors
-    };
-  }
-  let cases = Core__Array.filterMap(caseResults, r => {
-    if (r.TAG === "Ok") {
-      return r._0;
-    }
-  });
-  return {
-    TAG: "Ok",
-    _0: {
-      _tag: "PolyVariant",
-      _0: cases
-    }
-  };
-}
-
-function applyNullable(dict, result) {
-  let match = dict["nullable"];
-  if (match === undefined) {
-    return result;
-  }
-  if (typeof match !== "boolean") {
-    return result;
-  }
-  if (!match) {
-    return result;
-  }
-  if (result.TAG !== "Ok") {
-    return result;
-  }
-  let t = result._0;
-  if (typeof t !== "object" || t._tag !== "Nullable") {
-    return {
-      TAG: "Ok",
-      _0: {
-        _tag: "Nullable",
-        _0: t
-      }
-    };
-  } else {
-    return {
-      TAG: "Ok",
-      _0: t
-    };
-  }
-}
-
-function parseObject(dict) {
-  let match = dict["$ref"];
-  if (match !== undefined) {
-    if (typeof match === "string") {
-      return applyNullable(dict, {
-        TAG: "Ok",
-        _0: {
-          _tag: "Ref",
-          _0: extractRefName(match)
-        }
-      });
-    }
-    return {
-      TAG: "Error",
-      _0: [Errors.makeError({
-          TAG: "InvalidJson",
-          _0: "$ref must be a string"
-        }, undefined, undefined, undefined)]
-    };
-  }
-  let match$1 = dict["oneOf"];
-  if (match$1 !== undefined) {
-    if (Array.isArray(match$1)) {
-      let hasNull = match$1.some(isNullType);
-      let nonNullItems = match$1.filter(item => !isNullType(item));
-      if (hasNull && nonNullItems.length === 1) {
-        let match$2 = nonNullItems[0];
-        if (match$2 === undefined) {
-          return {
-            TAG: "Error",
-            _0: [Errors.makeError({
-                TAG: "InvalidJson",
-                _0: "oneOf with only null types"
-              }, undefined, undefined, undefined)]
-          };
-        }
-        let exit = 0;
-        if (typeof match$2 === "object" && match$2 !== null && !Array.isArray(match$2)) {
-          let innerType = parseObject(match$2);
-          if (innerType.TAG === "Ok") {
-            return {
-              TAG: "Ok",
-              _0: {
-                _tag: "Nullable",
-                _0: innerType._0
-              }
-            };
-          } else {
-            return {
-              TAG: "Error",
-              _0: innerType._0
-            };
-          }
-        }
-        exit = 2;
-        if (exit === 2) {
-          return {
-            TAG: "Error",
-            _0: [Errors.makeError({
-                TAG: "InvalidJson",
-                _0: "oneOf item must be object"
-              }, undefined, undefined, undefined)]
-          };
-        }
-      } else {
-        if (hasNull && nonNullItems.length >= 2) {
-          let discriminatorPropName = extractDiscriminatorPropertyName(dict);
-          let inner = parseOneOf(nonNullItems, Primitive_option.some(discriminatorPropName));
-          if (inner.TAG === "Ok") {
-            return {
-              TAG: "Ok",
-              _0: {
-                _tag: "Nullable",
-                _0: inner._0
-              }
-            };
-          } else {
-            return {
-              TAG: "Error",
-              _0: inner._0
-            };
-          }
-        }
-        let discriminatorPropName$1 = extractDiscriminatorPropertyName(dict);
-        return parseOneOf(match$1, Primitive_option.some(discriminatorPropName$1));
-      }
-    }
-    return {
-      TAG: "Error",
-      _0: [Errors.makeError({
-          TAG: "InvalidJson",
-          _0: "oneOf must be an array"
-        }, undefined, undefined, undefined)]
-    };
-  }
-  let match$3 = dict["allOf"];
-  if (match$3 !== undefined) {
-    if (Array.isArray(match$3)) {
-      return parseAllOf(match$3);
-    }
-    return {
-      TAG: "Error",
-      _0: [Errors.makeError({
-          TAG: "InvalidJson",
-          _0: "allOf must be an array"
-        }, undefined, undefined, undefined)]
-    };
-  }
-  let match$4 = dict["anyOf"];
-  if (match$4 === undefined) {
-    return applyNullable(dict, parsePrimitiveType(dict));
-  }
-  if (Array.isArray(match$4)) {
-    return parseAnyOf(match$4);
-  }
-  return {
-    TAG: "Error",
-    _0: [Errors.makeError({
-        TAG: "InvalidJson",
-        _0: "anyOf must be an array"
-      }, undefined, undefined, undefined)]
-  };
-}
-
-let parse = parseSchema;
-
-export {
-  isNullType,
-  hasDefault,
-  extractRefName,
-  parseEnumValues,
-  extractTagFromConst,
-  extractTagFromProperty,
-  extractDiscriminatorPropertyName,
-  parseSchema,
-  parsePrimitiveType,
-  parseArrayType,
-  parseAnyOf,
-  parseObjectType,
-  parseAllOf,
-  parseOneOf,
-  applyNullable,
-  parseObject,
-  parse,
-}
-/* No side effect */