@forklaunch/validator 0.2.9 → 0.3.1

package/dist/typebox/typebox.schemaValidator.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * This module provides a TypeScript-based schema definition using the TypeBox library.
+ * It includes various types, schema creation, validation, and OpenAPI integration.
+ *
+ * @module TypeboxSchemaValidator
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openapi = exports.validate = exports.literal = exports.union = exports.array = exports.optional = exports.schemify = exports.never = exports.unknown = exports.any = exports.empty = exports.symbol = exports.date = exports.boolean = exports.bigint = exports.number = exports.string = exports.TypeboxSchema = exports.TypeboxSchemaValidator = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const value_1 = require("@sinclair/typebox/value");
+/**
+ * Class representing a TypeBox schema definition.
+ * @implements {SchemaValidator}
+ */
+class TypeboxSchemaValidator {
+    _Type;
+    _SchemaCatchall;
+    _ValidSchemaObject;
+    string = typebox_1.Type.String();
+    number = typebox_1.Type.Number();
+    bigint = typebox_1.Type.BigInt();
+    boolean = typebox_1.Type.Boolean();
+    date = typebox_1.Type.Date();
+    symbol = typebox_1.Type.Symbol();
+    empty = typebox_1.Type.Union([typebox_1.Type.Void(), typebox_1.Type.Null(), typebox_1.Type.Undefined()]);
+    any = typebox_1.Type.Any();
+    unknown = typebox_1.Type.Unknown();
+    never = typebox_1.Type.Never();
+    /**
+     * 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 typebox_1.Type.Literal(schema);
+        }
+        if (typebox_1.Kind in schema) {
+            return schema;
+        }
+        const newSchema = {};
+        Object.getOwnPropertyNames(schema).forEach((key) => {
+            if (typeof schema[key] === 'object' && typebox_1.Kind in schema[key]) {
+                newSchema[key] = schema[key];
+            }
+            else {
+                const schemified = this.schemify(schema[key]);
+                newSchema[key] = schemified;
+            }
+        });
+        return typebox_1.Type.Object(newSchema);
+    }
+    /**
+     * Make a schema optional.
+     * @param {TIdiomaticSchema} schema - The schema to make optional.
+     * @returns {TOptional<TResolve<T>>} The optional schema.
+     */
+    optional(schema) {
+        if (typebox_1.Kind in schema) {
+            return typebox_1.Type.Optional(schema);
+        }
+        const schemified = this.schemify(schema);
+        return typebox_1.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) {
+        if (typebox_1.Kind in schema) {
+            return typebox_1.Type.Array(schema);
+        }
+        const schemified = this.schemify(schema);
+        return typebox_1.Type.Array(schemified);
+    }
+    /**
+     * Create a union schema.
+     * @param {TUnionContainer} schemas - The schemas to union.
+     * @returns {TUnion<UnionTResolve<T>>} The union schema.
+     *
+     * WARNING: If "empty" 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) => {
+            if (typebox_1.Kind in schema) {
+                return schema;
+            }
+            return this.schemify(schema);
+        });
+        return typebox_1.Type.Union(unionTypes);
+    }
+    /**
+     * Create a literal schema.
+     * @param {LiteralSchema} value - The literal value.
+     * @returns {TLiteral<T>} The literal schema.
+     */
+    literal(value) {
+        return typebox_1.Type.Literal(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 (typebox_1.Kind in schema) {
+            return value_1.Value.Check(schema, value);
+        }
+        const schemified = this.schemify(schema);
+        return value_1.Value.Check(schemified, value);
+    }
+    /**
+     * Convert a schema to an OpenAPI schema object.
+     * @param {TIdiomaticSchema | TSchema} schema - The schema to convert.
+     * @returns {SchemaObject} The OpenAPI schema object.
+     */
+    openapi(schema) {
+        return this.schemify(schema);
+    }
+}
+exports.TypeboxSchemaValidator = TypeboxSchemaValidator;
+/**
+ * Factory function for creating a TypeboxSchemaValidator instance.
+ * @returns {TypeboxSchemaValidator} The TypeboxSchemaValidator instance.
+ */
+const TypeboxSchema = () => new TypeboxSchemaValidator();
+exports.TypeboxSchema = TypeboxSchema;
+const SchemaValidator = (0, exports.TypeboxSchema)();
+/**
+ * TypeBox schema definition for string type.
+ */
+exports.string = SchemaValidator.string;
+/**
+ * TypeBox schema definition for number type.
+ */
+exports.number = SchemaValidator.number;
+/**
+ * TypeBox schema definition for bigint type.
+ */
+exports.bigint = SchemaValidator.bigint;
+/**
+ * TypeBox schema definition for boolean type.
+ */
+exports.boolean = SchemaValidator.boolean;
+/**
+ * TypeBox schema definition for date type.
+ */
+exports.date = SchemaValidator.date;
+/**
+ * TypeBox schema definition for symbol type.
+ */
+exports.symbol = SchemaValidator.symbol;
+/**
+ * TypeBox schema definition for undefined, null, void types.
+ */
+exports.empty = SchemaValidator.empty;
+/**
+ * TypeBox schema definition for any type.
+ */
+exports.any = SchemaValidator.any;
+/**
+ * TypeBox schema definition for unknown type.
+ */
+exports.unknown = SchemaValidator.unknown;
+/**
+ * TypeBox schema definition for never type.
+ */
+exports.never = SchemaValidator.never;
+/**
+ * Transforms valid schema into TypeBox schema.
+ */
+exports.schemify = SchemaValidator.schemify.bind(SchemaValidator);
+/**
+ * Makes a valid schema optional.
+ */
+exports.optional = SchemaValidator.optional.bind(SchemaValidator);
+/**
+ * Defines an array for a valid schema.
+ */
+exports.array = SchemaValidator.array.bind(SchemaValidator);
+/**
+ * Defines a union for a valid schema.
+ */
+exports.union = SchemaValidator.union.bind(SchemaValidator);
+/**
+ * Defines a literal for a valid schema.
+ */
+exports.literal = SchemaValidator.literal.bind(SchemaValidator);
+/**
+ * Validates a value against a valid schema.
+ */
+exports.validate = SchemaValidator.validate.bind(SchemaValidator);
+/**
+ * Generates an OpenAPI schema object from a valid schema.
+ */
+exports.openapi = SchemaValidator.openapi.bind(SchemaValidator);
+//# sourceMappingURL=typebox.schemaValidator.js.map

package/dist/typebox/typebox.schemaValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typebox.schemaValidator.js","sourceRoot":"","sources":["../../typebox/typebox.schemaValidator.ts"],"names":[],"mappings":"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"}

package/dist/typebox/types/typebox.schema.types.d.ts

@@ -53,11 +53,11 @@ export type UnionTResolve<T extends TUnionContainer> = T extends [
     }
 ] : [];
 /**
- * Resolves a schema type T to its resolved type. The depth is limited to 45 to prevent infinite recursion.
+ * Resolves a schema type T to its resolved type. The depth is limited to 22 to prevent infinite recursion.
  *
  * @template T - The schema type to resolve.
  * @template Depth - The current depth of the resolution.
  */
-export type TResolve<T, Depth extends number = 0> = Depth extends 45 ? TUnknown : T extends LiteralSchema ? TLiteral<T> : T extends TObject<TObjectShape> ? T : T extends TSchema ? T : T extends TKind ? T : T extends UnboxedTObjectSchema ? TObject<{
+export type TResolve<T, Depth extends number = 0> = Depth extends 22 ? TUnknown : T extends LiteralSchema ? TLiteral<T> : T extends TKind ? T : T extends TObject<TObjectShape> ? T : T extends UnboxedTObjectSchema ? TObject<{
     [K in keyof T]: TResolve<T[K], Increment<Depth>>;
 }> : TNever;

package/dist/types/schema.types.d.ts

@@ -5,13 +5,26 @@ import { ZodResolve, ZodSchemaTranslate } from '../zod/types/zod.schema.types';
 /**
  * Interface representing a schema validator.
  *
- * @template UnionContainer - The type for union schemas.
- * @template IdiomaticSchema<unknown> - The type for idiomatic schemas.
- * @template Catchall - The catch-all type for all schemas.
+ * @template SchematicFunction - The function type for schemifying a schema.
+ * @template OptionalFunction - The function type for making a schema optional.
+ * @template ArrayFunction - The function type for converting a schema into an array.
+ * @template UnionFunction - The function type for unionizing multiple schemas.
+ * @template LiteralFunction - The function type for creating a literal schema.
+ * @template ValidationFunction - The function type for validating a value against a schema.
+ * @template OpenAPIFunction - The function type for converting a schema into an OpenAPI schema object.
  */
 export interface SchemaValidator<SchematicFunction = <T>(schema: T) => unknown, OptionalFunction = <T>(schema: T) => unknown, ArrayFunction = <T>(schema: T) => unknown, UnionFunction = <T>(schemas: T[]) => unknown, LiteralFunction = <T extends LiteralSchema>(schema: T) => unknown, ValidationFunction = <T>(schema: T, value: unknown) => boolean, OpenAPIFunction = <T>(schema: T) => SchemaObject> {
+    /**
+     * The type of the schema validator. Meant to be used with non-null assertions.
+     */
     _Type: unknown;
+    /**
+     * The catch-all type for the schema. Meant to be used with non-null assertions.
+     */
     _SchemaCatchall: unknown;
+    /**
+     * The valid schema object type. Meant to be used with non-null assertions.
+     */
     _ValidSchemaObject: unknown;
     /**
      * Validator for string type.
@@ -56,7 +69,6 @@ export interface SchemaValidator<SchematicFunction = <T>(schema: T) => unknown,
     /**
      * Converts a valid schema input into a schemified form.
      *
-     * @template T - The type of the idiomatic schema.
      * @param {T} schema - The schema to schemify.
      * @returns {unknown} - The schemified form of the schema.
      */
@@ -64,7 +76,6 @@ export interface SchemaValidator<SchematicFunction = <T>(schema: T) => unknown,
     /**
      * Converts a schema into an optional schema.
      *
-     * @template T - The type of the idiomatic schema.
      * @param {T} schema - The schema to make optional.
      * @returns {unknown} - The optional form of the schema.
      */
@@ -72,7 +83,6 @@ export interface SchemaValidator<SchematicFunction = <T>(schema: T) => unknown,
     /**
      * Converts a schema into an array schema.
      *
-     * @template T - The type of the idiomatic schema.
      * @param {T} schema - The schema to convert into an array.
      * @returns {unknown} - The array form of the schema.
      */
@@ -80,15 +90,13 @@ export interface SchemaValidator<SchematicFunction = <T>(schema: T) => unknown,
     /**
      * Converts multiple schemas into a union schema.
      *
-     * @template T - The type of the union container.
-     * @param {T} schemas - The schemas to unionize.
+     * @param {T[]} schemas - The schemas to unionize.
      * @returns {unknown} - The union form of the schemas.
      */
     union: UnionFunction;
     /**
      * Creates a literal schema from a value.
      *
-     * @template T - The type of the literal value.
      * @param {T} value - The literal value.
      * @returns {unknown} - The literal schema.
      */
@@ -96,7 +104,6 @@ export interface SchemaValidator<SchematicFunction = <T>(schema: T) => unknown,
     /**
      * Validates a value against a schema.
      *
-     * @template T - The type of the catch-all schema.
      * @param {T} schema - The schema to validate against.
      * @param {unknown} value - The value to validate.
      * @returns {boolean} - Whether the value is valid according to the schema.
@@ -105,29 +112,68 @@ export interface SchemaValidator<SchematicFunction = <T>(schema: T) => unknown,
     /**
      * Converts a schema into an OpenAPI schema object.
      *
-     * @template T - The type of the idiomatic schema.
      * @param {T} schema - The schema to convert.
      * @returns {SchemaObject} - The OpenAPI schema object.
      */
     openapi: OpenAPIFunction;
 }
+/**
+ * Type representing any schema validator.
+ */
 export type AnySchemaValidator = SchemaValidator<unknown, unknown, unknown, unknown, unknown, unknown, unknown> & {
+    /**
+     * The type of the schema resolver.
+     */
     _Type: keyof SchemaResolve<unknown>;
 };
+/**
+ * Interface representing schema resolution for different validation libraries.
+ *
+ * @template T - The type of the schema to resolve.
+ */
 export interface SchemaResolve<T> {
+    /**
+     * Schema resolution for Zod.
+     */
     Zod: ZodResolve<T>;
+    /**
+     * Schema resolution for TypeBox.
+     */
     TypeBox: TResolve<T>;
 }
+/**
+ * Interface representing schema translation for different validation libraries.
+ *
+ * @template T - The type of the schema to translate.
+ */
 export interface SchemaTranslate<T> {
+    /**
+     * Schema translation for Zod.
+     */
     Zod: ZodSchemaTranslate<T>;
+    /**
+     * Schema translation for TypeBox.
+     */
     TypeBox: TSchemaTranslate<T>;
 }
+/**
+ * Type representing the prettified schema translation.
+ *
+ * @template T - The type of the schema to translate.
+ * @template SV - The type of the schema validator.
+ */
 type SchemaPrettify<T, SV extends AnySchemaValidator> = Prettify<SchemaTranslate<T>[SV['_Type']]>;
+/**
+ * Type representing a schema, which can be a valid schema object or an idiomatic schema.
+ *
+ * @template T - The type of the schema.
+ * @template SV - The type of the schema validator.
+ */
 export type Schema<T extends SV['_ValidSchemaObject'] | IdiomaticSchema<SV>, SV extends AnySchemaValidator> = SchemaPrettify<SchemaResolve<T>[SV['_Type']], SV>;
 /**
  * Represents a schema for an unboxed object where each key can have an idiomatic schema.
  *
- * @template Catchall - The type to use for catch-all cases in the schema.
+ * @template SV - The type of the schema validator.
  */
 export type UnboxedObjectSchema<SV extends AnySchemaValidator> = {
     [key: KeyTypes]: IdiomaticSchema<SV>;
@@ -139,7 +185,7 @@ export type LiteralSchema = string | number | boolean;
 /**
  * Represents an idiomatic schema which can be an unboxed object schema, a literal schema, or a catch-all type.
  *
- * @template Catchall - The type to use for catch-all cases in the schema.
+ * @template SV - The type of the schema validator.
  */
 export type IdiomaticSchema<SV extends AnySchemaValidator> = UnboxedObjectSchema<SV> | LiteralSchema | SV['_SchemaCatchall'];
 /**

package/dist/zod/index.d.ts

@@ -1,147 +1 @@
-/**
- * This module provides a Zod-based schema definition.
- * It includes various types, schema creation, validation, and OpenAPI integration.
- *
- * @module ZodSchemaValidator
- */
-import { SchemaObject } from 'openapi3-ts/oas31';
-import { ZodArray, ZodLiteral, ZodObject, ZodOptional, ZodRawShape, ZodType, ZodUnion, z } from 'zod';
-import { LiteralSchema, SchemaValidator } from '../types/schema.types';
-import { UnionZodResolve, ZodCatchall, ZodIdiomaticSchema, ZodResolve, ZodUnionContainer } from './types/zod.schema.types';
-/**
- * Class representing a Zod schema definition.
- * @implements {SchemaValidator}
- */
-export declare class ZodSchemaValidator implements SchemaValidator<(<T extends ZodIdiomaticSchema>(schema: T) => ZodResolve<T>), <T extends ZodIdiomaticSchema>(schema: T) => ZodOptional<ZodResolve<T>>, <T extends ZodIdiomaticSchema>(schema: T) => ZodArray<ZodResolve<T>>, <T extends ZodUnionContainer>(schemas: T) => ZodUnion<UnionZodResolve<T>>, <T extends LiteralSchema>(value: T) => ZodLiteral<ZodResolve<T>>, <T extends ZodCatchall>(schema: T, value: unknown) => boolean, <T extends ZodIdiomaticSchema>(schema: T) => SchemaObject> {
-    _Type: 'Zod';
-    _SchemaCatchall: ZodType;
-    _ValidSchemaObject: ZodObject<ZodRawShape> | ZodArray<ZodObject<ZodRawShape>>;
-    string: z.ZodString;
-    number: z.ZodNumber;
-    bigint: z.ZodBigInt;
-    boolean: z.ZodBoolean;
-    date: z.ZodDate;
-    symbol: z.ZodSymbol;
-    empty: ZodUnion<[z.ZodVoid, z.ZodNull, z.ZodUndefined]>;
-    any: z.ZodAny;
-    unknown: z.ZodUnknown;
-    never: z.ZodNever;
-    /**
-     * Convert a schema to a Zod schema.
-     * @param {ZodIdiomaticSchema} schema - The schema to convert.
-     * @returns {ZodResolve<T>} The resolved schema.
-     */
-    schemify<T extends ZodIdiomaticSchema>(schema: T): ZodResolve<T>;
-    /**
-     * Make a schema optional.
-     * @param {ZodIdiomaticSchema} schema - The schema to make optional.
-     * @returns {ZodOptional<ZodResolve<T>>} The optional schema.
-     */
-    optional<T extends ZodIdiomaticSchema>(schema: T): ZodOptional<ZodResolve<T>>;
-    /**
-     * Create an array schema.
-     * @param {ZodIdiomaticSchema} schema - The schema to use for array items.
-     * @returns {ZodArray<ZodResolve<T>>} The array schema.
-     */
-    array<T extends ZodIdiomaticSchema>(schema: T): ZodArray<ZodResolve<T>>;
-    /**
-     * Create a union schema.
-     * @param {ZodUnionContainer} schemas - The schemas to union.
-     * @returns {ZodUnion<UnionZodResolve<T>>} The union schema.
-     */
-    union<T extends ZodUnionContainer>(schemas: T): ZodUnion<UnionZodResolve<T>>;
-    /**
-     * Create a literal schema.
-     * @param {LiteralSchema} value - The literal value.
-     * @returns {ZodLiteral<ZodResolve<T>>} The literal schema.
-     */
-    literal<T extends LiteralSchema>(value: T): ZodLiteral<ZodResolve<T>>;
-    /**
-     * Validate a value against a schema.
-     * @param {ZodCatchall} schema - The schema to validate against.
-     * @param {unknown} value - The value to validate.
-     * @returns {boolean} True if valid, otherwise false.
-     */
-    validate<T extends ZodCatchall>(schema: T, value: unknown): boolean;
-    /**
-     * Convert a schema to an OpenAPI schema object.
-     * @param {ZodIdiomaticSchema} schema - The schema to convert.
-     * @returns {SchemaObject} The OpenAPI schema object.
-     */
-    openapi<T extends ZodIdiomaticSchema>(schema: T): SchemaObject;
-}
-/**
- * Factory function for creating a ZodSchemaValidator instance.
- * @returns {ZodSchemaValidator} The ZodSchemaValidator instance.
- */
-export declare const ZodSchema: () => ZodSchemaValidator;
-declare const SchemaValidator: ZodSchemaValidator;
-/**
- * Zod schema definition for string type.
- */
-export declare const string: typeof SchemaValidator.string;
-/**
- * Zod schema definition for number type.
- */
-export declare const number: typeof SchemaValidator.number;
-/**
- * Zod schema definition for bigint type.
- */
-export declare const bigint: typeof SchemaValidator.bigint;
-/**
- * Zod schema definition for boolean type.
- */
-export declare const boolean: typeof SchemaValidator.boolean;
-/**
- * Zod schema definition for date type.
- */
-export declare const date: typeof SchemaValidator.date;
-/**
- * Zod schema definition for symbol type.
- */
-export declare const symbol: typeof SchemaValidator.symbol;
-/**
- * Zod schema definition for undefined, null, void types.
- */
-export declare const empty: typeof SchemaValidator.empty;
-/**
- * Zod schema definition for any type.
- */
-export declare const any: typeof SchemaValidator.any;
-/**
- * Zod schema definition for unknown type.
- */
-export declare const unknown: typeof SchemaValidator.unknown;
-/**
- * Zod schema definition for never type.
- */
-export declare const never: typeof SchemaValidator.never;
-/**
- * Transforms valid schema into Zod schema.
- */
-export declare const schemify: typeof SchemaValidator.schemify;
-/**
- * Makes a valid schema optional.
- */
-export declare const optional: typeof SchemaValidator.optional;
-/**
- * Defines an array for a valid schema.
- */
-export declare const array: typeof SchemaValidator.array;
-/**
- * Defines a union for a valid schema.
- */
-export declare const union: typeof SchemaValidator.union;
-/**
- * Defines a literal for a valid schema.
- */
-export declare const literal: typeof SchemaValidator.literal;
-/**
- * Validates a value against a valid schema.
- */
-export declare const validate: typeof SchemaValidator.validate;
-/**
- * Generates an OpenAPI schema object from a valid schema.
- */
-export declare const openapi: typeof SchemaValidator.openapi;
-export {};
+export * from './zod.schemaValidator';