@tstdl/base 0.90.92 → 0.91.0-beta10

package/schema/schema.error.d.ts

@@ -1,9 +1,7 @@
-import type { CustomErrorOptions } from '../errors/custom.error.js';
-import { CustomError } from '../errors/custom.error.js';
+import { CustomError, type CustomErrorOptions } from '../errors/custom.error.js';
 import type { JsonPath } from '../json-path/index.js';
-import type { OneOrMany, TypedOmit, UndefinableJson } from '../types.js';
+import type { AbstractConstructor, OneOrMany, TypedOmit, UndefinableJson } from '../types.js';
 import type { ErrorExtraInfo } from '../utils/format-error.js';
-import type { ValueType } from './types/index.js';
 export type SchemaErrorOptions = Pick<CustomErrorOptions, 'fast'> & {
     path: string | JsonPath;
     details?: UndefinableJson;
@@ -16,10 +14,10 @@ export declare class SchemaError extends CustomError implements ErrorExtraInfo {
     readonly details?: UndefinableJson;
     readonly inner?: OneOrMany<SchemaError>;
     constructor(message: string, options: SchemaErrorOptions, cause?: any);
-    static expectedButGot(expected: OneOrMany<string | ValueType>, got: string | ValueType, path: string | JsonPath, options: TypedOmit<SchemaErrorOptions, 'path'> & {
+    static expectedButGot(expected: OneOrMany<string | AbstractConstructor>, got: string, path: string | JsonPath, options?: TypedOmit<SchemaErrorOptions, 'path'> & {
         customMessage?: string;
     }): SchemaError;
-    static couldNotCoerce(expected: OneOrMany<string | ValueType>, got: string | ValueType, path: string | JsonPath, options: TypedOmit<SchemaErrorOptions, 'path'> & {
+    static couldNotCoerce(expected: OneOrMany<string | AbstractConstructor>, got: string, path: string | JsonPath, options: TypedOmit<SchemaErrorOptions, 'path'> & {
         customMessage?: string;
     }): SchemaError;
     getExtraInfo(includeMessage?: boolean): UndefinableJson | undefined;

package/schema/schema.error.js

@@ -1,8 +1,6 @@
 import { CustomError } from '../errors/custom.error.js';
 import { toArray } from '../utils/array/array.js';
-import { isArray, isDefined, isNotNullOrUndefined, isString } from '../utils/type-guards.js';
-import { getExpectString } from './schema.js';
-import { getValueTypeName } from './utils/index.js';
+import { isArray, isDefined, isFunction, isNotNullOrUndefined, isString } from '../utils/type-guards.js';
 export class SchemaError extends CustomError {
     static errorName = 'SchemaError';
     path;
@@ -24,24 +22,22 @@ export class SchemaError extends CustomError {
     }
     // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
     static expectedButGot(expected, got, path, options) {
-        const expectedNames = toArray(expected).map((exp) => (isString(exp) ? exp : getExpectString(exp)));
-        const gotName = isString(got) ? got : getValueTypeName(got);
+        const expectedNames = toArray(expected).map((e) => isFunction(e) ? e.name : e);
         const expectedString = expectedNames.length == 1
             ? expectedNames[0]
             : `(${expectedNames.join(' | ')})`;
-        const customMessage = isDefined(options.customMessage) ? `: ${options.customMessage}` : '.';
-        const message = `Expected ${expectedString} but got ${gotName}${customMessage}`;
+        const customMessage = isDefined(options?.customMessage) ? `: ${options.customMessage}` : '.';
+        const message = `Expected ${expectedString} but got ${got}${customMessage}`;
         return new SchemaError(message, { path, ...options });
     }
     // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
     static couldNotCoerce(expected, got, path, options) {
-        const expectedNames = toArray(expected).map((exp) => (isString(exp) ? exp : getValueTypeName(exp)));
-        const gotText = isString(got) ? got : getValueTypeName(got);
+        const expectedNames = toArray(expected).map((e) => isFunction(e) ? e.name : e);
         const expectedString = expectedNames.length == 1
             ? expectedNames[0]
             : `[${expectedNames.join(', ')}]`;
         const customMessageString = isDefined(options.customMessage) ? `: ${options.customMessage}` : '.';
-        const errorMessage = `Could not coerce ${gotText} to ${expectedString}${customMessageString}`;
+        const errorMessage = `Could not coerce ${got} to ${expectedString}${customMessageString}`;
         return new SchemaError(errorMessage, { path, ...options });
     }
     getExtraInfo(includeMessage = false) {

package/schema/schema.js

@@ -1,283 +1,81 @@
-import { JsonPath } from '../json-path/index.js';
-import { toArray } from '../utils/array/array.js';
-import { noop } from '../utils/noop.js';
-import { objectKeys } from '../utils/object/object.js';
-import { differenceSets } from '../utils/set.js';
-import { isArray, isDefined, isFunction, isNotNull, isNull, isUndefined } from '../utils/type-guards.js';
-import { booleanCoercer, dateCoercer, numberCoercer, regExpCoercer, stringCoercer, uint8ArrayCoercer } from './coercers/index.js';
-import { SchemaError } from './schema.error.js';
-import { isObjectSchema, isTransformErrorResult, isTypeSchema, isValueSchema, resolveValueType, resolveValueTypes, schemaTestableToSchema, transformErrorResultSymbol } from './types/index.js';
-import { getArrayItemSchema, getSchemaTypeNames, getSchemaValueTypes, getValueType, includesValueType, normalizeObjectSchema, normalizeValueSchema, tryGetObjectSchemaFromReflection } from './utils/index.js';
-const defaultCoercers = new Map();
-let initialize = () => {
-    Schema.registerDefaultCoercer(numberCoercer);
-    Schema.registerDefaultCoercer(booleanCoercer);
-    Schema.registerDefaultCoercer(stringCoercer);
-    Schema.registerDefaultCoercer(dateCoercer);
-    Schema.registerDefaultCoercer(regExpCoercer);
-    Schema.registerDefaultCoercer(uint8ArrayCoercer);
-    initialize = noop;
-};
-// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
-export const Schema = {
-    registerDefaultCoercer(coercer) {
-        for (const sourceType of toArray(coercer.sourceType)) {
-            if (!defaultCoercers.has(sourceType)) {
-                defaultCoercers.set(sourceType, []);
-            }
-            defaultCoercers.get(sourceType).push(coercer);
-        }
-    },
-    test(schemaOrValueType, value, options, path = JsonPath.ROOT) {
-        const normalizedOptions = { fastErrors: true, ...options };
-        const schema = schemaTestableToSchema(schemaOrValueType);
-        const result = testSchema(schema, value, normalizedOptions, path);
-        if (result.valid) {
-            return result;
-        }
-        if (isUndefined(result.error.stack)) {
-            result.error.stack = new Error().stack;
-        }
-        return result;
-    },
-    validate(schemaOrValueType, value, options) {
-        const schema = schemaTestableToSchema(schemaOrValueType);
-        const result = this.test(schema, value, options);
+import { JsonPath } from '../json-path/json-path.js';
+export class Schema {
+    /**
+     * Test an unknown value to see whether it corresponds to the schema.
+     * @param schema schema to test against
+     * @param value value to test
+     * @param options validation options
+     * @returns test result
+     */
+    static test;
+    /**
+     * Validate an unknown value to see whether it corresponds to the schema.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     * @returns validation result
+     */
+    static validate;
+    /**
+     * Asserts an unknown value to be valid according to the schema.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     */
+    static assert;
+    /**
+     * Parse an unknown value to comply with the scheme.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     * @returns validation result
+     */
+    static parse;
+    /**
+     * Test an unknown value to see whether it corresponds to the schema.
+     * @param schema schema to test against
+     * @param value value to test
+     * @param options validation options
+     * @returns test result with either the value or validation error
+     */
+    test(value, options = {}) {
+        return this._test(value, JsonPath.ROOT, options);
+    }
+    /**
+     * Validate an unknown value to see whether it corresponds to the schema.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     * @returns validation result. Throws if validation fails
+     */
+    validate(value, options = {}) {
+        const result = this._test(value, JsonPath.ROOT, options);
         return result.valid;
-    },
-    parse(schemaOrValueType, value, options) {
-        const schema = schemaTestableToSchema(schemaOrValueType);
-        const result = this.test(schema, value, options);
+    }
+    /**
+     * Asserts an unknown value to be valid according to the schema.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     */
+    assert(value, options = {}) {
+        const result = this._test(value, JsonPath.ROOT, options);
+        if (!result.valid) {
+            throw result.error;
+        }
+    }
+    /**
+     * Parse an unknown value to comply with the scheme.
+     * @param schema schema to parse against
+     * @param value value to parse
+     * @param options validation options
+     * @returns parsed value
+     */
+    parse(value, options = {}) {
+        const result = this._test(value, JsonPath.ROOT, options);
         if (result.valid) {
             return result.value;
         }
         throw result.error;
-    },
-    function(argumentSchemas, returnSchema, handler) {
-        const name = `validated${handler.name.slice(0, 1).toUpperCase()}${handler.name.slice(1)}`;
-        const schema = getFunctionParametersSchema(argumentSchemas);
-        return {
-            [name](...unsafeArgs) {
-                const safeArgs = Schema.parse(schema, unsafeArgs, { mask: true }); // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion
-                const unsafeResult = handler(...safeArgs);
-                return Schema.parse(returnSchema, unsafeResult); // eslint-disable-line @typescript-eslint/no-unsafe-return
-            }
-        }[name];
-    },
-    asyncFunction(argumentSchemas, returnSchema, handler) {
-        const name = `validated${handler.name.slice(0, 1).toUpperCase()}${handler.name.slice(1)}`;
-        const schema = getFunctionParametersSchema(argumentSchemas);
-        return {
-            async [name](...unsafeArgs) {
-                const safeArgs = Schema.parse(schema, unsafeArgs, { mask: true }); // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion
-                const unsafeResult = await handler(...safeArgs);
-                return Schema.parse(returnSchema, unsafeResult); // eslint-disable-line @typescript-eslint/no-unsafe-return
-            }
-        }[name];
-    }
-};
-function getFunctionParametersSchema(argumentSchemas) {
-    const schema = {
-        factory: { type: Array },
-        properties: {}
-    };
-    argumentSchemas.forEach((arg, index) => (schema.properties[index] = arg));
-    return schema;
-}
-export function testSchema(schema, value, options, path = JsonPath.ROOT) {
-    initialize();
-    if (isValueSchema(schema)) {
-        return testValue(schema, value, options, path);
-    }
-    if (isTypeSchema(schema)) {
-        return testType(schema, value, options, path);
-    }
-    if (isObjectSchema(schema)) {
-        return testObject(schema, value, options, path);
-    }
-    throw new Error('Unsupported schema');
-}
-function testType(schema, value, options = {}, path = JsonPath.ROOT) {
-    const resolvedValueType = resolveValueType(schema.type);
-    if (isFunction(resolvedValueType)) {
-        if ((value instanceof resolvedValueType) || (getValueType(value) == resolvedValueType)) {
-            return { valid: true, value: value };
-        }
-        const objectSchema = tryGetObjectSchemaFromReflection(resolvedValueType);
-        if (isNotNull(objectSchema)) {
-            return testObject(objectSchema, value, options, path);
-        }
-    }
-    else if ((resolvedValueType == 'any') || ((resolvedValueType == 'null') && isNull(value)) || ((resolvedValueType == 'undefined') && isUndefined(value))) {
-        return { valid: true, value: value };
-    }
-    return { valid: false, error: SchemaError.expectedButGot(resolvedValueType, getValueType(value), path, { fast: options.fastErrors }) };
-}
-// eslint-disable-next-line complexity
-function testObject(objectSchema, value, options = {}, path = JsonPath.ROOT) {
-    if (!(value instanceof Object)) {
-        return { valid: false, error: SchemaError.expectedButGot(objectSchema.sourceType ?? 'object', getValueType(value), path, { fast: options.fastErrors }) };
-    }
-    const schema = normalizeObjectSchema(objectSchema);
-    const mask = schema.mask ?? options.mask ?? false;
-    const resultValue = isDefined(schema.factory?.type) ? new schema.factory.type() : {};
-    const schemaPropertyKeys = objectKeys(schema.properties);
-    const valuePropertyKeys = objectKeys(value);
-    const unknownValuePropertyKeys = differenceSets(new Set(valuePropertyKeys), new Set(schemaPropertyKeys));
-    if ((unknownValuePropertyKeys.length > 0) && !mask && !schema.allowUnknownProperties) {
-        return { valid: false, error: new SchemaError('Unknown property', { path: path.add(unknownValuePropertyKeys[0]), fast: options.fastErrors }) };
-    }
-    for (const key of schemaPropertyKeys) {
-        const propertyResult = testSchema(schema.properties[key], value[key], options, path.add(key));
-        if (!propertyResult.valid) {
-            return propertyResult;
-        }
-        resultValue[key] = propertyResult.value;
-    }
-    if (schema.allowUnknownProperties) {
-        for (const key of unknownValuePropertyKeys) {
-            const propertyPath = path.add(key);
-            if (isDefined(schema.unknownPropertiesKey)) {
-                const keyResult = testSchema(schema.unknownPropertiesKey, key, options);
-                if (!keyResult.valid && !mask) {
-                    return { valid: false, error: new SchemaError('Invalid property key.', { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
-                }
-            }
-            const propertyResult = testSchema(schema.unknownProperties, value[key], options, path.add(key));
-            if (!propertyResult.valid && !mask) {
-                return propertyResult;
-            }
-            resultValue[key] = propertyResult.value;
-        }
-    }
-    const testResultValue = isUndefined(schema.factory) ? resultValue : isDefined(schema.factory.type) ? resultValue : schema.factory.builder(resultValue);
-    return { valid: true, value: testResultValue };
-}
-// eslint-disable-next-line max-lines-per-function, max-statements, complexity
-function testValue(schema, value, options = {}, path = JsonPath.ROOT) {
-    const normalizedValueSchema = normalizeValueSchema(schema);
-    if (normalizedValueSchema.optional && isUndefined(value)) {
-        return { valid: true, value: value };
     }
-    if (normalizedValueSchema.nullable && isNull(value)) {
-        return { valid: true, value: value };
-    }
-    const context = {
-        schema: normalizedValueSchema,
-        options
-    };
-    /** handle arrays */
-    if (normalizedValueSchema.array) {
-        if (!isArray(value)) {
-            if (normalizedValueSchema.coerce) {
-                return testValue(schema, [value], options, path);
-            }
-            return { valid: false, error: SchemaError.expectedButGot(Array, getValueType(value), path, { fast: options.fastErrors }) };
-        }
-        for (const arrayConstraint of normalizedValueSchema.arrayConstraints) {
-            const result = arrayConstraint.validate(value, path, context);
-            if (!result.valid) {
-                return { valid: false, error: result.error };
-            }
-        }
-        const itemSchema = getArrayItemSchema(schema);
-        const validatedItems = [];
-        for (let i = 0; i < value.length; i++) {
-            const result = testValue(itemSchema, value[i], options, path.add(i));
-            if (!result.valid) {
-                return result;
-            }
-            validatedItems.push(result.value);
-        }
-        return { valid: true, value: validatedItems };
-    }
-    let valueTestResult;
-    let resultValue;
-    let valueType;
-    function updateCurrentState(newValue) {
-        valueTestResult = isValidValue(normalizedValueSchema.schema, newValue, options, path);
-        resultValue = valueTestResult.valid ? valueTestResult.value : newValue;
-        valueType = getValueType(resultValue);
-    }
-    updateCurrentState(value);
-    /** try to coerce */
-    if (!valueTestResult.valid) {
-        const targetTypes = getSchemaValueTypes(schema);
-        const coercers = [
-            ...(normalizedValueSchema.coercers.get(valueType) ?? []),
-            ...((normalizedValueSchema.coerce || options.coerce == true) ? (defaultCoercers.get(valueType) ?? []) : [])
-        ]
-            .filter((coercer) => includesValueType(coercer.targetType, targetTypes));
-        const errors = [];
-        let success = false;
-        for (const coercer of coercers) {
-            const coerceResult = coercer.coerce(resultValue, path, context);
-            if (!coerceResult.success) {
-                errors.push(coerceResult.error);
-                continue;
-            }
-            success = true;
-            updateCurrentState(coerceResult.value);
-            break;
-        }
-        if (!success && (errors.length > 0)) {
-            return { valid: false, error: (errors.length == 1) ? errors[0] : new SchemaError('Value could not be coerced.', { inner: errors, path, fast: options.fastErrors }) };
-        }
-    }
-    if (!valueTestResult.valid) {
-        return valueTestResult;
-    }
-    if (normalizedValueSchema.valueConstraints.length > 0) {
-        const errors = [];
-        for (const constraint of normalizedValueSchema.valueConstraints) {
-            const result = constraint.validate(resultValue, path, context);
-            if (!result.valid) {
-                errors.push(result.error);
-            }
-        }
-        if (errors.length > 0) {
-            return { valid: false, error: (errors.length == 1) ? errors[0] : new SchemaError('Value did not match schema.', { path, inner: errors, fast: options.fastErrors }) };
-        }
-    }
-    if (normalizedValueSchema.transformers.length > 0) {
-        for (const transformer of normalizedValueSchema.transformers) {
-            if (isDefined(transformer.sourceType) && !includesValueType(valueType, resolveValueTypes(transformer.sourceType))) {
-                continue;
-            }
-            const transformResult = transformer.transform(resultValue, path, context);
-            if (isTransformErrorResult(transformResult)) {
-                return { valid: false, error: transformResult[transformErrorResultSymbol] };
-            }
-            return { valid: true, value: transformResult };
-        }
-    }
-    return { valid: true, value: resultValue };
-}
-function isValidValue(validSchemas, value, options, path) {
-    const errorResults = [];
-    for (const schema of validSchemas) {
-        const result = testSchema(schema, value, options, path);
-        if (result.valid) {
-            return result;
-        }
-        errorResults.push(result);
-    }
-    if (errorResults.length == 1) {
-        return errorResults[0];
-    }
-    const errors = errorResults.map((result) => result.error);
-    const expectStrings = [];
-    for (const schema of validSchemas) {
-        expectStrings.push(getExpectString(schema));
-    }
-    const expectString = expectStrings.length > 1 ? `(${expectStrings.join(' | ')})` : expectStrings[0];
-    return { valid: false, error: SchemaError.expectedButGot(expectString, getValueType(value), path, { inner: errors, fast: options.fastErrors }) };
-}
-export function getExpectString(schema) {
-    const expectedNames = getSchemaTypeNames(schema);
-    const arraySuffix = (isValueSchema(schema) && (schema.array == true)) ? '[]' : '';
-    const expectedTypeString = (expectedNames.length == 1) ? `${expectedNames[0]}${arraySuffix}` : `(${expectedNames.join(' | ')})${arraySuffix}`;
-    const expects = isValueSchema(schema) ? toArray(schema.valueConstraints ?? []).map((constraint) => constraint.expects) : [];
-    const expectsString = (expects.length > 0) ? `[${expects.join(', ')}]` : '';
-    return `${expectedTypeString}${expectsString}`;
 }

package/schema/schemas/any.d.ts

@@ -1,5 +1,7 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/index.js';
-export type AnyOptions = ValueSchemaOptions;
-export declare function any(options?: AnyOptions): ValueSchema<any>;
-export declare function Any(options?: AnyOptions): Decorator<'property' | 'accessor'>;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestResult } from '../schema.js';
+export declare class AnySchema extends Schema<any> {
+    _test(value: any): SchemaTestResult<any>;
+}
+export declare function any(): AnySchema;
+export declare function Any(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/any.js

@@ -1,9 +1,13 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/index.js';
-export function any(options) {
-    return valueSchema('any', options);
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+export class AnySchema extends Schema {
+    _test(value) {
+        return { valid: true, value };
+    }
+}
+export function any() {
+    return new AnySchema();
 }
 export function Any(options) {
-    return createSchemaPropertyDecoratorFromSchema(any(options));
+    return Property(any(), options);
 }

package/schema/schemas/array.d.ts

@@ -1,12 +1,11 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { OneOrMany } from '../../types.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type ArrayOptions = ValueSchemaOptions & {
-    /** minimum array length */
-    minimumLength?: number;
-    /** maximum array length */
-    maximumLength?: number;
-};
-export declare function array<T>(innerValues: OneOrMany<SchemaTestable<T>>, options?: ArrayOptions): ValueSchema<T[]>;
-export declare function Array(innerValues: OneOrMany<SchemaTestable>, options?: ArrayOptions): Decorator<'property' | 'accessor'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import type { TypedOmit } from '../../types.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class ArraySchema<T> extends Schema<T[]> {
+    readonly itemSchema: Schema<T>;
+    constructor(itemSchema: SchemaTestable<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T[]>;
+}
+export declare function array<T>(schema: SchemaTestable<T>): ArraySchema<T>;
+export declare function Array(schema: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'array'>): SchemaPropertyDecorator;

package/schema/schemas/array.js

@@ -1,23 +1,33 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { ArrayMaximumLengthConstraint } from '../array-constraints/maximum-length.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
-import { valueSchema } from '../types/types.js';
-export function array(innerValues, options = {}) {
-    const arrayConstraints = toArrayCopy(options.arrayConstraints ?? []);
-    if (isDefined(options.minimumLength)) {
-        arrayConstraints.push(new ArrayMaximumLengthConstraint(options.minimumLength));
+import { SchemaError } from '../../schema/schema.error.js';
+import { isArray } from '../../utils/type-guards.js';
+import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+export class ArraySchema extends Schema {
+    itemSchema;
+    constructor(itemSchema) {
+        super();
+        this.itemSchema = schemaTestableToSchema(itemSchema);
     }
-    if (isDefined(options.maximumLength)) {
-        arrayConstraints.push(new ArrayMaximumLengthConstraint(options.maximumLength));
+    _test(value, path, options) {
+        if (!isArray(value)) {
+            return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
+        }
+        const values = [];
+        for (let i = 0; i < value.length; i++) {
+            const result = this.itemSchema._test(value[i], path.add(i), options);
+            if (!result.valid) {
+                return result;
+            }
+            values.push(result.value);
+        }
+        return { valid: true, value: values };
     }
-    return valueSchema(innerValues, {
-        ...options,
-        array: true,
-        arrayConstraints
-    });
 }
-export function Array(innerValues, options) {
-    return createSchemaPropertyDecoratorFromSchema(array(innerValues, options));
+export function array(schema) {
+    return new ArraySchema(schema);
+}
+export function Array(schema, options) {
+    return Property(schema, { ...options, array: true });
 }

package/schema/schemas/bigint.d.ts

@@ -0,0 +1,9 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import type { SchemaPropertyDecorator } from '../decorators/types.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class BigIntSchema extends Schema<bigint> {
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<bigint>;
+}
+export declare function bigint(): BigIntSchema;
+export declare function BigIntProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/bigint.js

@@ -0,0 +1,19 @@
+import { SchemaError } from '../../schema/schema.error.js';
+import { isBigInt } from '../../utils/type-guards.js';
+import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+export class BigIntSchema extends Schema {
+    _test(value, path, options) {
+        if (isBigInt(value)) {
+            return { valid: true, value };
+        }
+        return { valid: false, error: SchemaError.expectedButGot('bigint', typeOf(value), path, { fast: options.fastErrors }) };
+    }
+}
+export function bigint() {
+    return new BigIntSchema();
+}
+export function BigIntProperty(options) {
+    return Property(bigint(), options);
+}

package/schema/schemas/boolean.d.ts

@@ -1,5 +1,11 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/index.js';
-export type BooleanOptions = ValueSchemaOptions;
-export declare function boolean(options?: BooleanOptions): ValueSchema<boolean>;
-export declare function BooleanProperty(options?: BooleanOptions): Decorator<'property' | 'accessor'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import type { SchemaTestOptions, SchemaTestResult } from '../schema.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type BooleanSchemaOptions = SimpleSchemaOptions;
+export declare class BooleanSchema extends SimpleSchema<boolean> {
+    constructor(options?: BooleanSchemaOptions);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<boolean>;
+}
+export declare function boolean(options?: BooleanSchemaOptions): BooleanSchema;
+export declare function BooleanProperty(options?: BooleanSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/boolean.js

@@ -1,9 +1,44 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/index.js';
-export function boolean(options = {}) {
-    return valueSchema(Boolean, options);
+import { SchemaError } from '../../schema/schema.error.js';
+import { isBoolean, isString } from '../../utils/type-guards.js';
+import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
+import { SimpleSchema } from './simple.js';
+export class BooleanSchema extends SimpleSchema {
+    constructor(options) {
+        super('boolean', isBoolean, options, {
+            coercers: {
+                all: (value) => {
+                    const normalizedValue = isString(value) ? value.toLowerCase().trim() : value;
+                    switch (normalizedValue) {
+                        case 1:
+                        case 1n:
+                        case 'true':
+                        case '1':
+                        case 'yes':
+                            return { success: true, value: true, valid: true };
+                        case 0:
+                        case 0n:
+                        case 'false':
+                        case '0':
+                        case 'no':
+                            return { success: true, value: false, valid: true };
+                        default:
+                            return { success: false };
+                    }
+                }
+            }
+        });
+    }
+    _test(value, path, options) {
+        if (isBoolean(value)) {
+            return { valid: true, value };
+        }
+        return { valid: false, error: SchemaError.expectedButGot('boolean', typeOf(value), path, { fast: options.fastErrors }) };
+    }
+}
+export function boolean(options) {
+    return new BooleanSchema(options);
 }
 export function BooleanProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(boolean(options));
+    return Property(boolean(options), options);
 }