@tstdl/base 0.90.91 → 0.91.0-beta1

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,10 @@
-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 SchemaPropertyDecorator } 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): SchemaPropertyDecorator;

package/schema/schemas/array.js

@@ -1,23 +1,31 @@
-/* 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)) {
+            for (let i = 0; i < value.length; i++) {
+                const result = this.itemSchema._test(value[i], path.add(i), options);
+                if (!result.valid) {
+                    return result;
+                }
+            }
+            return { valid: true, value: value };
+        }
+        return { valid: false, error: SchemaError.expectedButGot('array', typeOf(value), path) };
     }
-    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) {
+    return Property(schema, { array: true });
 }

package/schema/schemas/bigint.d.ts

@@ -0,0 +1,8 @@
+import type { JsonPath } from '../../json-path/json-path.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 BigInt(): 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 BigInt() {
+    return Property(bigint());
+}

package/schema/schemas/boolean.d.ts

@@ -1,5 +1,15 @@
-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(): BooleanSchema;
+export declare function Boolean(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+/**
+ * @deprecated use {@link Boolean()} instead
+ */
+export declare function BooleanProperty(options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/boolean.js

@@ -1,9 +1,50 @@
-/* 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() {
+    return new BooleanSchema();
+}
+export function Boolean(options) {
+    return Property(boolean(), options);
+}
+/**
+ * @deprecated use {@link Boolean()} instead
+ */
 export function BooleanProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(boolean(options));
+    return Boolean(options);
 }

package/schema/schemas/date.d.ts

@@ -1,8 +1,10 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type DateOptions = ValueSchemaOptions & {
-    minimum?: Date | number;
-    maximum?: Date | number;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type DateSchemaOptions = SimpleSchemaOptions & {
+    integer?: boolean;
 };
-export declare function date(options?: DateOptions): ValueSchema<Date>;
-export declare function DateProperty(options?: DateOptions): Decorator<'property' | 'accessor'>;
+export declare class DateSchema extends SimpleSchema<globalThis.Date> {
+    constructor(options?: DateSchemaOptions);
+}
+export declare function date(options?: DateSchemaOptions): DateSchema;
+export declare function Date(options?: SchemaPropertyDecoratorOptions & DateSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/date.js

@@ -1,22 +1,28 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { MaximumDateConstraint, MinimumDateConstraint } from '../constraints/index.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/types.js';
-export function date(options = {}) {
-    const constraints = toArrayCopy(options.valueConstraints ?? []);
-    if (isDefined(options.minimum)) {
-        constraints.push(new MinimumDateConstraint(options.minimum));
+import { isValidDate } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SimpleSchema } from './simple.js';
+export class DateSchema extends SimpleSchema {
+    constructor(options) {
+        super('date', isValidDate, options, {
+            coercers: {
+                string: (value, path, options) => {
+                    const result = new globalThis.Date(value);
+                    return globalThis.Number.isNaN(result.getTime())
+                        ? { success: false, error: SchemaError.couldNotCoerce('date', 'string', path, { fast: options.fastErrors }) }
+                        : { success: true, value: result, valid: true };
+                },
+                number: (value) => ({ success: true, value: new globalThis.Date(value), valid: false })
+            },
+            constraints: [
+                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'value is not an integer.' }) : null
+            ]
+        });
     }
-    if (isDefined(options.maximum)) {
-        constraints.push(new MaximumDateConstraint(options.maximum));
-    }
-    return valueSchema(Date, {
-        ...options,
-        valueConstraints: constraints
-    });
 }
-export function DateProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(date(options));
+export function date(options) {
+    return new DateSchema(options);
+}
+export function Date(options) {
+    return Property(date(options), options);
 }