@forklaunch/validator 0.3.12 → 0.4.0

package/lib/src/typebox/index.mjs

@@ -0,0 +1,406 @@
+// src/typebox/typeboxSchemaValidator.ts
+import {
+  Kind,
+  KindGuard,
+  Type
+} from "@sinclair/typebox";
+import { TypeCheck, TypeCompiler } from "@sinclair/typebox/compiler";
+import {
+  DefaultErrorFunction,
+  SetErrorFunction,
+  ValueErrorType
+} from "@sinclair/typebox/errors";
+import { Value } from "@sinclair/typebox/value";
+SetErrorFunction((params) => {
+  switch (params.errorType) {
+    case ValueErrorType.Union:
+    case ValueErrorType.Array:
+    case ValueErrorType.String:
+    case ValueErrorType.Number:
+      return params.schema.errorType ? `Expected ${params.schema.errorType} value${params.schema.errorSuffix ? "s" : ""}` : DefaultErrorFunction(params);
+    default:
+      return DefaultErrorFunction(params);
+  }
+});
+var TypeboxSchemaValidator = class {
+  _Type;
+  _SchemaCatchall;
+  _ValidSchemaObject;
+  string = Type.String();
+  // uuid = Type.String({ format: 'uuid' });
+  uuid = 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 = Type.String({
+    pattern: "^[a-zA-Z][a-zA-Z\\d+-.]*:[^\\s]*$",
+    errorType: "uri"
+  });
+  email = 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 = Type.Transform(
+    Type.Union(
+      [
+        Type.Number(),
+        Type.String({ pattern: "^[0-9]+$" }),
+        Type.Boolean(),
+        Type.Null(),
+        Type.Date(),
+        Type.BigInt()
+      ],
+      {
+        errorType: "number-like",
+        openapiType: 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 = Type.Transform(
+    Type.Union(
+      [
+        Type.BigInt(),
+        Type.Number(),
+        Type.String({ pattern: "^[0-9]+$" }),
+        Type.Boolean(),
+        Type.Date()
+      ],
+      {
+        errorType: "BigInt-like",
+        openapiType: 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 = Type.Transform(
+    Type.Union(
+      [
+        Type.Boolean(),
+        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: 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 = Type.Transform(
+    Type.Union(
+      [
+        Type.Date(),
+        Type.Number(),
+        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+$"
+        }),
+        Type.Boolean(),
+        Type.Null()
+      ],
+      {
+        errorType: "date",
+        openapiType: 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 = Type.Symbol();
+  nullish = Type.Union([Type.Void(), Type.Null(), Type.Undefined()], {
+    errorType: "nullish"
+  });
+  any = Type.Any();
+  unknown = Type.Unknown();
+  never = 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 (KindGuard.IsLiteral(schema)) {
+      return schema.const;
+    }
+    return schema[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 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 Type.Literal(schema);
+    }
+    if (KindGuard.IsSchema(schema) || schema instanceof TypeCheck) {
+      return schema;
+    }
+    const newSchema = {};
+    Object.getOwnPropertyNames(schema).forEach((key) => {
+      if (KindGuard.IsSchema(schema[key])) {
+        newSchema[key] = schema[key];
+      } else {
+        const schemified = this.schemify(schema[key]);
+        newSchema[key] = schemified;
+      }
+    });
+    return 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 = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    return 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 = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    return 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 KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    });
+    return 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 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 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 TypeCheck) {
+      return schema.Check(value);
+    } else {
+      const schemified = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      return 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 TypeCheck) {
+      if (schema.Check(value)) {
+        conversion = schema.Decode(value);
+      } else {
+        errors = Array.from(schema.Errors(value));
+      }
+    } else {
+      const schemified = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+      if (Value.Check(schemified, value)) {
+        conversion = Value.Decode(schemified, value);
+      } else {
+        errors = Array.from(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 = KindGuard.IsSchema(schema) ? schema : this.schemify(schema);
+    if (Object.hasOwn(schemified, "openapiType") || 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 (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
+);
+export {
+  SchemaValidator,
+  any,
+  array,
+  bigint,
+  boolean,
+  date,
+  email,
+  enum_,
+  isSchema,
+  literal,
+  never,
+  nullish,
+  number,
+  openapi,
+  optional,
+  parse,
+  schemify,
+  string,
+  symbol,
+  union,
+  unknown,
+  uri,
+  uuid,
+  validate
+};

package/lib/src/zod/index.d.mts

@@ -0,0 +1,106 @@
+import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
+import { Z as ZodSchemaValidator, a as ZodIdiomaticSchema, b as ZodResolve, c as ZodUnionContainer, U as UnionZodResolve, L as LiteralSchema, d as ZodCatchall, P as ParseResult } from '../../index-V6qNDTlr.mjs';
+import * as zod from 'zod';
+import '@forklaunch/common';
+import '@sinclair/typebox';
+import '@sinclair/typebox/compiler';
+
+/**
+ * Factory function for creating a ZodSchemaValidator instance.
+ * @returns {ZodSchemaValidator} The ZodSchemaValidator instance.
+ */
+declare const SchemaValidator: () => ZodSchemaValidator;
+/**
+ * Zod schema definition for string type.
+ */
+declare const string: zod.ZodString;
+/**
+ * Zod schema definition for UUID type.
+ */
+declare const uuid: zod.ZodString;
+/**
+ * Zod schema definition for email type.
+ */
+declare const email: zod.ZodString;
+/**
+ * Zod schema definition for URI type.
+ */
+declare const uri: zod.ZodString;
+/**
+ * Zod schema definition for number type.
+ */
+declare const number: zod.ZodNumber;
+/**
+ * Zod schema definition for bigint type.
+ */
+declare const bigint: zod.ZodBigInt;
+/**
+ * Zod schema definition for boolean type.
+ */
+declare const boolean: zod.ZodEffects<zod.ZodBoolean, boolean, unknown>;
+/**
+ * Zod schema definition for date type.
+ */
+declare const date: zod.ZodDate;
+/**
+ * Zod schema definition for symbol type.
+ */
+declare const symbol: zod.ZodSymbol;
+/**
+ * Zod schema definition for undefined, null, void types.
+ */
+declare const nullish: zod.ZodUnion<[zod.ZodVoid, zod.ZodNull, zod.ZodUndefined]>;
+/**
+ * Zod schema definition for any type.
+ */
+declare const any: zod.ZodAny;
+/**
+ * Zod schema definition for unknown type.
+ */
+declare const unknown: zod.ZodUnknown;
+/**
+ * Zod schema definition for never type.
+ */
+declare const never: zod.ZodNever;
+/**
+ * Transforms valid schema into Zod schema.
+ */
+declare const schemify: <T extends ZodIdiomaticSchema>(schema: T) => ZodResolve<T>;
+/**
+ * Makes a valid schema optional.
+ */
+declare const optional: <T extends ZodIdiomaticSchema>(schema: T) => zod.ZodOptional<ZodResolve<T>>;
+/**
+ * Defines an array for a valid schema.
+ */
+declare const array: <T extends ZodIdiomaticSchema>(schema: T) => zod.ZodArray<ZodResolve<T>>;
+/**
+ * Defines a union for a valid schema.
+ */
+declare const union: <T extends ZodUnionContainer>(schemas: T) => zod.ZodUnion<UnionZodResolve<T>>;
+/**
+ * Defines a literal for a valid schema.
+ */
+declare const literal: <T extends LiteralSchema>(value: T) => zod.ZodLiteral<ZodResolve<T>>;
+/**
+ * Defines an enum for a valid schema.
+ */
+declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => zod.ZodUnion<UnionZodResolve<[T, T, ...T[]]>>;
+/**
+ * Checks if a value is a Zod schema.
+ */
+declare const isSchema: (value: unknown) => value is zod.ZodSchema;
+/**
+ * Validates a value against a valid schema.
+ */
+declare const validate: <T extends ZodCatchall>(schema: T, value: unknown) => boolean;
+/**
+ * Parses a value to be conformant to a particular schema.
+ */
+declare const parse: <T extends ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>;
+/**
+ * Generates an OpenAPI schema object from a valid schema.
+ */
+declare const openapi: <T extends ZodIdiomaticSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
+
+export { SchemaValidator, ZodSchemaValidator, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };

package/lib/src/zod/index.d.ts

@@ -1,3 +1,106 @@
-export * from './staticSchemaValidator';
-export type { ZodSchemaValidator } from './zodSchemaValidator';
-//# sourceMappingURL=index.d.ts.map
+import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
+import { Z as ZodSchemaValidator, a as ZodIdiomaticSchema, b as ZodResolve, c as ZodUnionContainer, U as UnionZodResolve, L as LiteralSchema, d as ZodCatchall, P as ParseResult } from '../../index-V6qNDTlr.js';
+import * as zod from 'zod';
+import '@forklaunch/common';
+import '@sinclair/typebox';
+import '@sinclair/typebox/compiler';
+
+/**
+ * Factory function for creating a ZodSchemaValidator instance.
+ * @returns {ZodSchemaValidator} The ZodSchemaValidator instance.
+ */
+declare const SchemaValidator: () => ZodSchemaValidator;
+/**
+ * Zod schema definition for string type.
+ */
+declare const string: zod.ZodString;
+/**
+ * Zod schema definition for UUID type.
+ */
+declare const uuid: zod.ZodString;
+/**
+ * Zod schema definition for email type.
+ */
+declare const email: zod.ZodString;
+/**
+ * Zod schema definition for URI type.
+ */
+declare const uri: zod.ZodString;
+/**
+ * Zod schema definition for number type.
+ */
+declare const number: zod.ZodNumber;
+/**
+ * Zod schema definition for bigint type.
+ */
+declare const bigint: zod.ZodBigInt;
+/**
+ * Zod schema definition for boolean type.
+ */
+declare const boolean: zod.ZodEffects<zod.ZodBoolean, boolean, unknown>;
+/**
+ * Zod schema definition for date type.
+ */
+declare const date: zod.ZodDate;
+/**
+ * Zod schema definition for symbol type.
+ */
+declare const symbol: zod.ZodSymbol;
+/**
+ * Zod schema definition for undefined, null, void types.
+ */
+declare const nullish: zod.ZodUnion<[zod.ZodVoid, zod.ZodNull, zod.ZodUndefined]>;
+/**
+ * Zod schema definition for any type.
+ */
+declare const any: zod.ZodAny;
+/**
+ * Zod schema definition for unknown type.
+ */
+declare const unknown: zod.ZodUnknown;
+/**
+ * Zod schema definition for never type.
+ */
+declare const never: zod.ZodNever;
+/**
+ * Transforms valid schema into Zod schema.
+ */
+declare const schemify: <T extends ZodIdiomaticSchema>(schema: T) => ZodResolve<T>;
+/**
+ * Makes a valid schema optional.
+ */
+declare const optional: <T extends ZodIdiomaticSchema>(schema: T) => zod.ZodOptional<ZodResolve<T>>;
+/**
+ * Defines an array for a valid schema.
+ */
+declare const array: <T extends ZodIdiomaticSchema>(schema: T) => zod.ZodArray<ZodResolve<T>>;
+/**
+ * Defines a union for a valid schema.
+ */
+declare const union: <T extends ZodUnionContainer>(schemas: T) => zod.ZodUnion<UnionZodResolve<T>>;
+/**
+ * Defines a literal for a valid schema.
+ */
+declare const literal: <T extends LiteralSchema>(value: T) => zod.ZodLiteral<ZodResolve<T>>;
+/**
+ * Defines an enum for a valid schema.
+ */
+declare const enum_: <T extends LiteralSchema>(schemaEnum: Record<string, T>) => zod.ZodUnion<UnionZodResolve<[T, T, ...T[]]>>;
+/**
+ * Checks if a value is a Zod schema.
+ */
+declare const isSchema: (value: unknown) => value is zod.ZodSchema;
+/**
+ * Validates a value against a valid schema.
+ */
+declare const validate: <T extends ZodCatchall>(schema: T, value: unknown) => boolean;
+/**
+ * Parses a value to be conformant to a particular schema.
+ */
+declare const parse: <T extends ZodCatchall>(schema: T, value: unknown) => ParseResult<ZodResolve<T>>;
+/**
+ * Generates an OpenAPI schema object from a valid schema.
+ */
+declare const openapi: <T extends ZodIdiomaticSchema>(schema: T) => openapi3_ts_oas31.SchemaObject;
+
+export { SchemaValidator, ZodSchemaValidator, any, array, bigint, boolean, date, email, enum_, isSchema, literal, never, nullish, number, openapi, optional, parse, schemify, string, symbol, union, unknown, uri, uuid, validate };