@forklaunch/validator 0.3.13 → 0.4.0

package/lib/src/typebox/index.js

@@ -1 +1,448 @@
-export * from './staticSchemaValidator';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/typebox/index.ts
+var typebox_exports = {};
+__export(typebox_exports, {
+  SchemaValidator: () => SchemaValidator,
+  any: () => any,
+  array: () => array,
+  bigint: () => bigint,
+  boolean: () => boolean,
+  date: () => date,
+  email: () => email,
+  enum_: () => enum_,
+  isSchema: () => isSchema,
+  literal: () => literal,
+  never: () => never,
+  nullish: () => nullish,
+  number: () => number,
+  openapi: () => openapi,
+  optional: () => optional,
+  parse: () => parse,
+  schemify: () => schemify,
+  string: () => string,
+  symbol: () => symbol,
+  union: () => union,
+  unknown: () => unknown,
+  uri: () => uri,
+  uuid: () => uuid,
+  validate: () => validate
+});
+module.exports = __toCommonJS(typebox_exports);
+
+// src/typebox/typeboxSchemaValidator.ts
+var import_typebox = require("@sinclair/typebox");
+var import_compiler = require("@sinclair/typebox/compiler");
+var import_errors = require("@sinclair/typebox/errors");
+var import_value = require("@sinclair/typebox/value");
+(0, import_errors.SetErrorFunction)((params) => {
+  switch (params.errorType) {
+    case import_errors.ValueErrorType.Union:
+    case import_errors.ValueErrorType.Array:
+    case import_errors.ValueErrorType.String:
+    case import_errors.ValueErrorType.Number:
+      return params.schema.errorType ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? "s" : ""}` : (0, import_errors.DefaultErrorFunction)(params);
+    default:
+      return (0, import_errors.DefaultErrorFunction)(params);
+  }
+});
+var TypeboxSchemaValidator = class {
+  _Type;
+  _SchemaCatchall;
+  _ValidSchemaObject;
+  string = import_typebox.Type.String();
+  // uuid = Type.String({ format: 'uuid' });
+  uuid = import_typebox.Type.String({
+    pattern: "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$",
+    errorType: "uuid"
+  });
+  uri = import_typebox.Type.String({
+    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
+    errorType: "uri"
+  });
+  email = import_typebox.Type.String({
+    pattern: `(?:[a-z0-9!#$%&'*+/=?^_{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_{|}~-]+)*|"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)])`,
+    errorType: "email"
+  });
+  number = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.Number(),
+        import_typebox.Type.String({ pattern: "^[0-9]+$" }),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Null(),
+        import_typebox.Type.Date(),
+        import_typebox.Type.BigInt()
+      ],
+      {
+        errorType: "number-like",
+        openapiType: import_typebox.Type.Number()
+      }
+    )
+  ).Decode((value) => {
+    if (typeof value !== "number") {
+      const num = Number(value);
+      if (isNaN(num)) {
+        throw new Error("Invalid number");
+      } else {
+        return num;
+      }
+    }
+    return value;
+  }).Encode(Number);
+  bigint = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.BigInt(),
+        import_typebox.Type.Number(),
+        import_typebox.Type.String({ pattern: "^[0-9]+$" }),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Date()
+      ],
+      {
+        errorType: "BigInt-like",
+        openapiType: import_typebox.Type.BigInt()
+      }
+    )
+  ).Decode((value) => {
+    if (typeof value !== "bigint") {
+      try {
+        return BigInt(value instanceof Date ? value.getTime() : value);
+      } catch {
+        throw new Error("Invalid bigint");
+      }
+    }
+    return value;
+  }).Encode(BigInt);
+  boolean = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.String({
+          pattern: "^(t|T)(r|R)(u|U)(e|E)$|^(f|F)(a|A)(l|L)(s|S)(e|E)$"
+        })
+      ],
+      {
+        errorType: "boolean-like",
+        openapiType: import_typebox.Type.Boolean()
+      }
+    )
+  ).Decode((value) => {
+    if (typeof value === "string") {
+      if (value.toLowerCase() === "true") return true;
+      if (value.toLowerCase() === "false") return false;
+    } else {
+      return value;
+    }
+  }).Encode(Boolean);
+  date = import_typebox.Type.Transform(
+    import_typebox.Type.Union(
+      [
+        import_typebox.Type.Date(),
+        import_typebox.Type.Number(),
+        import_typebox.Type.String({
+          pattern: "^\\d{4}(-\\d{2}){0,2}(T\\d{2}:\\d{2}(:\\d{2}(\\.\\d{1,3})?)?(Z|([+-]\\d{2}:\\d{2}))?)?$|^\\d{1,2}\\/\\d{1,2}\\/\\d{4}$|^\\d{4}\\/\\d{1,2}\\/\\d{1,2}$|^\\d+$"
+        }),
+        import_typebox.Type.Boolean(),
+        import_typebox.Type.Null()
+      ],
+      {
+        errorType: "date",
+        openapiType: import_typebox.Type.Date()
+      }
+    )
+  ).Decode((value) => {
+    if (!(value instanceof Date)) {
+      if (value === null || typeof value === "boolean") {
+        return /* @__PURE__ */ new Date(value ? 1 : 0);
+      }
+      return new Date(value);
+    }
+    return value;
+  }).Encode((value) => new Date(value));
+  symbol = import_typebox.Type.Symbol();
+  nullish = import_typebox.Type.Union([import_typebox.Type.Void(), import_typebox.Type.Null(), import_typebox.Type.Undefined()], {
+    errorType: "nullish"
+  });
+  any = import_typebox.Type.Any();
+  unknown = import_typebox.Type.Unknown();
+  never = import_typebox.Type.Never();
+  /**
+   * Extracts the error type of a schema for error messages.
+   *
+   * @param {TCatchall} schema - A schema that contains some type information.
+   * @returns The type of the schema for error messages.
+   */
+  errorType(schema) {
+    if (Object.hasOwn(schema, "errorType")) {
+      return schema.errorType;
+    } else if (import_typebox.KindGuard.IsLiteral(schema)) {
+      return schema.const;
+    }
+    return schema[import_typebox.Kind].toLowerCase();
+  }
+  /**
+   * Pretty print TypeBox errors.
+   *
+   * @param {ValueError[]} errors
+   * @returns
+   */
+  prettyPrintTypeBoxErrors(errors) {
+    if (!errors || errors.length === 0) return;
+    const errorMessages = errors.map((err, index) => {
+      const path = err.path.length > 0 ? err.path.split("/").slice(1).join(" > ") : "root";
+      return `${index + 1}. Path: ${path}
+   Message: ${err.message}`;
+    });
+    return `Validation failed with the following errors:
+${errorMessages.join("\n\n")}`;
+  }
+  /**
+   * Compiles schema if this exists, for optimal performance.
+   *
+   * @param {TObject<TProperties>} schema - The schema to compile.
+   * @returns {TypeCheck<T>} - The compiled schema.
+   */
+  compile(schema) {
+    return import_compiler.TypeCompiler.Compile(schema);
+  }
+  /**
+   * Convert a schema to a TypeBox schema.
+   * @param {TIdiomaticSchema} schema - The schema to convert.
+   * @returns {TResolve<T>} The resolved schema.
+   */
+  schemify(schema) {
+    if (typeof schema === "string" || typeof schema === "number" || typeof schema === "boolean") {
+      return import_typebox.Type.Literal(schema);
+    }
+    if (import_typebox.KindGuard.IsSchema(schema) || schema instanceof import_compiler.TypeCheck) {
+      return schema;
+    }
+    const newSchema = {};
+    Object.getOwnPropertyNames(schema).forEach((key) => {
+      if (import_typebox.KindGuard.IsSchema(schema[key])) {
+        newSchema[key] = schema[key];
+      } else {
+        const schemified = this.schemify(schema[key]);
+        newSchema[key] = schemified;
+      }
+    });
+    return import_typebox.Type.Object(newSchema);
+  }
+  /**
+   * Make a schema optional.
+   * @param {TIdiomaticSchema} schema - The schema to make optional.
+   * @returns {TOptional<TResolve<T>>} The optional schema.
+   */
+  optional(schema) {
+    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    return import_typebox.Type.Optional(schemified);
+  }
+  /**
+   * Create an array schema.
+   * @param {TIdiomaticSchema} schema - The schema to use for array items.
+   * @returns {TArray<TResolve<T>>} The array schema.
+   */
+  array(schema) {
+    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    return import_typebox.Type.Array(schemified, {
+      errorType: `array of ${this.errorType(schemified)}`
+    });
+  }
+  /**
+   * Create a union schema.
+   * @param {TUnionContainer} schemas - The schemas to union.
+   * @returns {TUnion<UnionTResolve<T>>} The union schema.
+   *
+   * WARNING: If "nullish" or TUndefined is included in the union, the key will still be expected.
+   * This is a limitation of TypeBox. Consider using "optional" instead.
+   */
+  union(schemas) {
+    const unionTypes = schemas.map((schema) => {
+      return import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    });
+    return import_typebox.Type.Union(unionTypes, {
+      errorType: `any of ${unionTypes.map((s) => this.errorType(s)).join(", ")}`,
+      errorSuffix: true
+    });
+  }
+  /**
+   * Create a literal schema.
+   * @param {LiteralSchema} value - The literal value.
+   * @returns {TLiteral<T>} The literal schema.
+   */
+  literal(value) {
+    return import_typebox.Type.Literal(value, {
+      errorType: value
+    });
+  }
+  /**
+   * Create an enum schema.
+   * @param {Record<string, LiteralSchema>} schemaEnum - The enum schema.
+   * @returns {TUnion<UnionTResolve<T[]>>} The enum schema.
+   */
+  enum_(schemaEnum) {
+    return this.union(Object.values(schemaEnum));
+  }
+  /**
+   * Check if a value is a TypeBox object schema.
+   * @param {unknown} value - The value to check.
+   * @returns {boolean} True if the value is a TypeBox object schema.
+   */
+  isSchema(value) {
+    return import_typebox.KindGuard.IsSchema(value);
+  }
+  /**
+   * Validate a value against a schema.
+   *
+   * @param {TSchema} schema - The schema to validate against.
+   * @param {unknown} value - The value to validate.
+   * @returns {boolean} True if valid, otherwise false.
+   */
+  validate(schema, value) {
+    if (schema instanceof import_compiler.TypeCheck) {
+      return schema.Check(value);
+    } else {
+      const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      return import_value.Value.Check(schemified, value);
+    }
+  }
+  /**
+   * Parse a value against a schema.
+   *
+   * @param {TSchema} schema - The schema to validate against.
+   * @param {unknown} value - The value to validate.
+   * @returns {ParseResult<TResolve<T>>} The parsing result.
+   */
+  parse(schema, value) {
+    let errors = [];
+    let conversion;
+    if (schema instanceof import_compiler.TypeCheck) {
+      if (schema.Check(value)) {
+        conversion = schema.Decode(value);
+      } else {
+        errors = Array.from(schema.Errors(value));
+      }
+    } else {
+      const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      if (import_value.Value.Check(schemified, value)) {
+        conversion = import_value.Value.Decode(schemified, value);
+      } else {
+        errors = Array.from(import_value.Value.Errors(schemified, value));
+      }
+    }
+    return errors != null && errors.length === 0 ? {
+      ok: true,
+      value: conversion
+    } : {
+      ok: false,
+      error: this.prettyPrintTypeBoxErrors(errors)
+    };
+  }
+  /**
+   * Convert a schema to an OpenAPI schema object.
+   * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+   * @returns {SchemaObject} The OpenAPI schema object.
+   */
+  openapi(schema) {
+    const schemified = import_typebox.KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    if (Object.hasOwn(schemified, "openapiType") || import_typebox.KindGuard.IsLiteral(schemified)) {
+      return schemified.openapiType;
+    }
+    const newSchema = Object.assign({}, schemified);
+    if (Object.hasOwn(newSchema, "properties")) {
+      newSchema.properties = { ...schemified.properties };
+      if (newSchema.properties) {
+        Object.entries(newSchema.properties).forEach(([key, value]) => {
+          if (import_typebox.KindGuard.IsSchema(value) && newSchema.properties) {
+            newSchema.properties[key] = this.openapi(value);
+          }
+        });
+      }
+    }
+    return newSchema;
+  }
+};
+
+// src/typebox/staticSchemaValidator.ts
+var SchemaValidator = () => new TypeboxSchemaValidator();
+var StaticSchemaValidator = SchemaValidator();
+var string = StaticSchemaValidator.string;
+var uuid = StaticSchemaValidator.uuid;
+var uri = StaticSchemaValidator.uri;
+var email = StaticSchemaValidator.email;
+var number = StaticSchemaValidator.number;
+var bigint = StaticSchemaValidator.bigint;
+var boolean = StaticSchemaValidator.boolean;
+var date = StaticSchemaValidator.date;
+var symbol = StaticSchemaValidator.symbol;
+var nullish = StaticSchemaValidator.nullish;
+var any = StaticSchemaValidator.any;
+var unknown = StaticSchemaValidator.unknown;
+var never = StaticSchemaValidator.never;
+var schemify = StaticSchemaValidator.schemify.bind(
+  StaticSchemaValidator
+);
+var optional = StaticSchemaValidator.optional.bind(
+  StaticSchemaValidator
+);
+var array = StaticSchemaValidator.array.bind(StaticSchemaValidator);
+var union = StaticSchemaValidator.union.bind(StaticSchemaValidator);
+var literal = StaticSchemaValidator.literal.bind(
+  StaticSchemaValidator
+);
+var enum_ = StaticSchemaValidator.enum_.bind(StaticSchemaValidator);
+var isSchema = StaticSchemaValidator.isSchema.bind(
+  StaticSchemaValidator
+);
+var validate = StaticSchemaValidator.validate.bind(
+  StaticSchemaValidator
+);
+var parse = StaticSchemaValidator.parse.bind(StaticSchemaValidator);
+var openapi = StaticSchemaValidator.openapi.bind(
+  StaticSchemaValidator
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaValidator,
+  any,
+  array,
+  bigint,
+  boolean,
+  date,
+  email,
+  enum_,
+  isSchema,
+  literal,
+  never,
+  nullish,
+  number,
+  openapi,
+  optional,
+  parse,
+  schemify,
+  string,
+  symbol,
+  union,
+  unknown,
+  uri,
+  uuid,
+  validate
+});