@tstdl/base 0.90.92 → 0.91.0-beta10

package/schema/schemas/object.d.ts

@@ -1,7 +1,84 @@
-import type { ObjectLiteral, Optionalize, Record, SimplifyObject, TypedOmit } from '../../types.js';
-import type { IfNever } from 'type-fest';
-import { type ObjectSchema, type ObjectSchemaProperties, type TypedObjectSchemaUnknownProperties } from '../types/index.js';
-export type ObjectOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'unknownProperties' | 'unknownPropertiesKey'>;
-export declare function explicitObject<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T>): ObjectSchema<T>;
-export declare function object<T extends Record = Record<never>, K extends PropertyKey = any, V = never>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T> & TypedObjectSchemaUnknownProperties<K, V>): ObjectSchema<SimplifyObject<Optionalize<T> & IfNever<V, ObjectLiteral, Record<K, V>>>>;
-export declare const emptyObjectSchema: ObjectSchema<ObjectLiteral>;
+import type { EmptyObject, Merge } from 'type-fest';
+import type { JsonPath } from '../../json-path/json-path.js';
+import type { AbstractConstructor, OneOrMany, PartialProperty, PropertiesOfType, Record as RecordType, SimplifyObject, Type, TypedOmit } from '../../types.js';
+import { type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import type { SchemaPropertyDecorator } from '../decorators/types.js';
+import { Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { type OptionalSchema } from './optional.js';
+export type Record<K extends PropertyKey = PropertyKey, V = any> = RecordType<K, V>;
+export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
+export type ObjectSchemaFactory<T> = {
+    type: Type<T>;
+} | ObjectSchemaFactoryFunction<T>;
+export type ObjectSchemaProperties<T extends Record = Record> = {
+    [P in keyof T]-?: SchemaTestable<T[P]>;
+};
+export type NormalizedObjectSchemaProperties<T extends Record> = {
+    [P in keyof T]-?: Schema<T[P]>;
+};
+export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey = PropertyKey, V = unknown> = {
+    mask?: boolean | null;
+    unknownProperties?: SchemaTestable<V> | null;
+    unknownPropertiesKey?: SchemaTestable<K> | null;
+    factory?: ObjectSchemaFactory<T> | null;
+};
+export type ObjectSchemaOrType<T extends Record = any> = ObjectSchema<T> | AbstractConstructor<T>;
+export type ObjectSchemaPropertiesType<TP extends ObjectSchemaProperties> = SimplifyObject<{
+    [P in keyof PartialProperty<TP, PropertiesOfType<TP, OptionalSchema<any>>>]: SchemaOutput<TP[P]>;
+}>;
+export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflection;
+export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
+    private readonly propertyKeys;
+    private readonly allowUnknownProperties;
+    readonly properties: NormalizedObjectSchemaProperties<T>;
+    readonly mask: boolean | null;
+    readonly unknownProperties: Schema | null;
+    readonly unknownPropertiesKey: Schema<PropertyKey> | null;
+    readonly factory: ObjectSchemaFactory<T> | null;
+    constructor(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export declare function object<const K extends PropertyKey, const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<Record<K, V>>;
+export declare function object<const K extends PropertyKey>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, unknown>> & {
+    unknownProperties?: undefined;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<Record<K, unknown>>;
+export declare function object<const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<PropertyKey, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey?: undefined;
+}): ObjectSchema<Record<PropertyKey, V>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, V>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, unknown>> & {
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, unknown>>;
+export declare function object<const TP extends ObjectSchemaProperties, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>> & {
+    unknownProperties: SchemaTestable<V>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>>;
+export declare function object<const TP extends ObjectSchemaProperties>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>> & {
+    unknownProperties?: undefined;
+    unknownPropertiesKey?: undefined;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>, K, V>): ObjectSchema<ObjectSchemaPropertiesType<TP> & Record<K, V>>;
+export declare function explicitObject<const T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>): ObjectSchema<T>;
+export declare function record<const K extends PropertyKey, const V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
+export declare function assign<const T1 extends Record, const T2 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>): ObjectSchema<Merge<Merge<T1, T2>, T3>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record, const T5 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record, const T5 extends Record, const T6 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>, f: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>, T6>>;
+export declare function partial<const T extends Record>(schema: ObjectSchemaOrType<T>): ObjectSchema<Partial<T>>;
+export declare function partial<const T extends Record, const K extends keyof T>(schema: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
+export declare function pick<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Pick<T, K>>>;
+export declare function omit<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
+declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | ObjectSchema<T> | null;
+export declare function getObjectSchema<T extends Record>(schemaOrType: SchemaTestable<T>): ObjectSchema<T>;
+export declare function Record<K extends PropertyKey, V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;
+export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;
+export {};

package/schema/schemas/object.js

@@ -1,12 +1,186 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { objectSchema } from '../types/index.js';
+/* eslint-disable max-depth */
+import { reflectionRegistry } from '../../reflection/index.js';
+import { SchemaError } from '../../schema/schema.error.js';
+import { toArray } from '../../utils/array/array.js';
+import { memoizeSingle } from '../../utils/function/memoize.js';
+import { filterObject, mapObjectValues, objectKeys } from '../../utils/object/object.js';
+import { assert, isDefined, isFunction, isLiteralObject, isNotNull, isNotNullOrUndefined, isNull, isObject, isUndefined } 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';
+import { array } from './array.js';
+import { nullable } from './nullable.js';
+import { optional } from './optional.js';
+export const tryGetSchemaFromReflection = memoizeSingle(_tryGetSchemaFromReflection, { weak: true });
+export class ObjectSchema extends Schema {
+    propertyKeys;
+    allowUnknownProperties;
+    properties;
+    mask;
+    unknownProperties;
+    unknownPropertiesKey;
+    factory;
+    constructor(properties, options = {}) {
+        super();
+        this.properties = mapObjectValues(properties, (value) => schemaTestableToSchema(value));
+        this.mask = options.mask ?? null;
+        this.unknownProperties = isNotNullOrUndefined(options.unknownProperties) ? schemaTestableToSchema(options.unknownProperties) : null;
+        this.unknownPropertiesKey = isNotNullOrUndefined(options.unknownPropertiesKey) ? schemaTestableToSchema(options.unknownPropertiesKey) : null;
+        this.factory = options.factory ?? null;
+        this.allowUnknownProperties = isNotNull(this.unknownProperties) || isNotNull(this.unknownPropertiesKey);
+        this.propertyKeys = new Set(objectKeys(properties));
+    }
+    _test(value, path, options) {
+        if (!isObject(value)) {
+            return { valid: false, error: SchemaError.expectedButGot('object', typeOf(value), path) };
+        }
+        const mask = this.mask ?? options.mask ?? false;
+        const resultValue = isLiteralObject(this.factory) ? new this.factory.type() : {};
+        const valueKeys = new Set(objectKeys(value));
+        const unknownValuePropertyKeys = valueKeys.difference(this.propertyKeys);
+        if ((unknownValuePropertyKeys.size > 0) && !mask && !this.allowUnknownProperties) {
+            return { valid: false, error: new SchemaError('Unexpected property', { path: path.add(unknownValuePropertyKeys.values().next().value), fast: options.fastErrors }) };
+        }
+        for (const key of this.propertyKeys) {
+            const propertyResult = this.properties[key]._test(value[key], path.add(key), options);
+            if (!propertyResult.valid) {
+                return propertyResult;
+            }
+            resultValue[key] = propertyResult.value;
+        }
+        if (this.allowUnknownProperties) {
+            for (const key of unknownValuePropertyKeys) {
+                const propertyPath = path.add(key);
+                const keyResult = this.unknownPropertiesKey?._test(key, propertyPath, options) ?? { valid: true };
+                if (!keyResult.valid) {
+                    if (mask) {
+                        continue;
+                    }
+                    return { valid: false, error: new SchemaError('Invalid property key.', { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
+                }
+                const innerValueResult = this.unknownProperties?._test(value[key], propertyPath, options) ?? { valid: true, value: value[key] };
+                if (!innerValueResult.valid) {
+                    return innerValueResult;
+                }
+                resultValue[key] = innerValueResult.value;
+            }
+        }
+        const testResultValue = isFunction(this.factory) ? this.factory(resultValue) : resultValue;
+        return { valid: true, value: testResultValue };
+    }
+}
+export function object(properties, options) {
+    return new ObjectSchema(properties, options);
+}
 export function explicitObject(properties, options) {
     return object(properties, options);
 }
-export function object(properties, options) {
-    return objectSchema({
-        properties,
-        ...options
+export function record(key, value, options) {
+    return object({}, { ...options, unknownPropertiesKey: key, unknownProperties: value });
+}
+export function assign(...schemasOrTypes) {
+    const schemas = schemasOrTypes.map(getObjectSchema);
+    return object(schemas.reduce((result, schema) => ({ ...result, ...schema.properties }), {}), {
+        mask: schemas.findLast((schema) => isNotNull(schema.mask))?.mask,
+        unknownProperties: schemas.findLast((schema) => isNotNull(schema.unknownProperties))?.unknownProperties,
+        unknownPropertiesKey: schemas.findLast((schema) => isNotNull(schema.unknownPropertiesKey))?.unknownPropertiesKey
+    });
+}
+export function partial(schemaOrType, keyOrKeys) {
+    const schema = getObjectSchema(schemaOrType);
+    const keys = isUndefined(keyOrKeys) ? undefined : toArray(keyOrKeys);
+    const mapper = isUndefined(keys)
+        ? (propertySchema) => optional(propertySchema)
+        : (propertySchema, key) => keys.includes(key) ? optional(propertySchema) : propertySchema;
+    return object(mapObjectValues(schema.properties, mapper), {
+        mask: schema.mask,
+        unknownProperties: schema.unknownProperties,
+        unknownPropertiesKey: schema.unknownPropertiesKey
+    });
+}
+export function pick(schemaOrType, keys) {
+    const schema = getObjectSchema(schemaOrType);
+    const keyArray = toArray(keys);
+    return object(filterObject(schema.properties, (_, key) => keyArray.includes(key)), {
+        mask: schema.mask,
+        unknownProperties: schema.unknownProperties,
+        unknownPropertiesKey: schema.unknownPropertiesKey
     });
 }
+export function omit(schemaOrType, keys) {
+    const schema = getObjectSchema(schemaOrType);
+    const keysArray = toArray(keys);
+    return object(filterObject(schema.properties, (_, key) => !keysArray.includes(key)), {
+        mask: schema.mask,
+        unknownProperties: schema.unknownProperties,
+        unknownPropertiesKey: schema.unknownPropertiesKey
+    });
+}
+export function getSchemaFromReflection(type) {
+    const schema = tryGetSchemaFromReflection(type);
+    if (isNull(schema)) {
+        throw new Error(`Could not get schema for ${type.name} from reflection data.`);
+    }
+    return schema;
+}
+function _tryGetSchemaFromReflection(type) {
+    const metadata = reflectionRegistry.getMetadata(type);
+    if (isUndefined(metadata)) {
+        return null;
+    }
+    const typeData = metadata.data.tryGet('schema') ?? {};
+    if (typeData.schema instanceof Schema) {
+        return typeData.schema;
+    }
+    if (isFunction(typeData.schema)) {
+        return schemaTestableToSchema(typeData.schema);
+    }
+    const schema = object(getObjectSchemaPropertiesFromReflection(metadata, type), {
+        factory: isDefined(typeData.factory) ? typeData.factory : { type: type },
+        mask: typeData.mask,
+        unknownProperties: typeData.unknownProperties,
+        unknownPropertiesKey: typeData.unknownPropertiesKey
+    });
+    const prototype = Reflect.getPrototypeOf(type);
+    if (isNotNull(prototype) && reflectionRegistry.hasType(prototype)) {
+        const parentSchema = getSchemaFromReflection(prototype);
+        assert(parentSchema instanceof ObjectSchema, 'Can not infer an ObjectSchema from reflection when parent class has an explicit non-object schema defined.');
+        return assign(parentSchema, schema);
+    }
+    return schema;
+}
+function getObjectSchemaPropertiesFromReflection(metadata, type) {
+    const properties = {};
+    for (const [key, propertyMetadata] of metadata.properties) {
+        const reflectionData = propertyMetadata.data.tryGet('schema');
+        if (isUndefined(reflectionData?.schema) && (propertyMetadata.type == Object)) {
+            throw new Error(`Schema of property "${String(key)}" on type ${type.name} is inferred as Object. This is most likely unwanted and happens when the property is defined as partial or the type is an union. Use an explicit @Property(Object) if this is wanted.`);
+        }
+        let propertySchema = reflectionData?.schema ?? propertyMetadata.type;
+        if (reflectionData?.array == true) {
+            propertySchema = array(propertySchema);
+        }
+        if (reflectionData?.nullable == true) {
+            propertySchema = nullable(propertySchema);
+        }
+        if (reflectionData?.optional == true) {
+            propertySchema = optional(propertySchema);
+        }
+        properties[key] = propertySchema;
+    }
+    return properties;
+}
+export function getObjectSchema(schemaOrType) {
+    if (schemaOrType instanceof ObjectSchema) {
+        return schemaOrType;
+    }
+    if (isFunction(schemaOrType)) {
+        return getObjectSchema(getSchemaFromReflection(schemaOrType));
+    }
+    throw new Error('Could not infer ObjectSchema.');
+}
+export function Record(key, value, options) {
+    return Property(record(key, value, options), options);
+}
 export const emptyObjectSchema = explicitObject({});

package/schema/schemas/one-or-many.d.ts

@@ -1,9 +1,12 @@
-import type { Decorator } from '../../reflection/index.js';
+import type { JsonPath } from '../../json-path/json-path.js';
 import type { OneOrMany as OneOrManyType } from '../../types.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-import type { ArrayOptions } from './array.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
 export type OneOrMany<T> = OneOrManyType<T>;
-export type OneOrManyOptions = ValueSchemaOptions & Pick<ArrayOptions, 'minimumLength' | 'maximumLength'>;
-export declare function oneOrMany<T>(innerValues: OneOrMany<SchemaTestable<T>>, options?: OneOrManyOptions): ValueSchema<T | T[]>;
-export declare function OneOrMany(innerValues: OneOrMany<SchemaTestable>, options?: OneOrManyOptions): Decorator<'property' | 'accessor'>;
+export declare class OneOrManySchema<T> extends Schema<T | T[]> {
+    readonly schema: Schema<T | T[]>;
+    constructor(schema: SchemaTestable<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | T[]>;
+}
+export declare function oneOrMany<T>(schema: SchemaTestable<T>): OneOrManySchema<T>;
+export declare function OneOrMany(schema: SchemaTestable, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/one-or-many.js

@@ -1,15 +1,22 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArray } from '../../utils/array/array.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
 import { array } from './array.js';
 import { union } from './union.js';
-export function oneOrMany(innerValues, options) {
-    return union([
-        array(innerValues, { minimumLength: options?.minimumLength, maximumLength: options?.maximumLength }),
-        ...toArray(innerValues)
-    ], options);
+export class OneOrManySchema extends Schema {
+    schema;
+    constructor(schema) {
+        super();
+        const oneSchema = schemaTestableToSchema(schema);
+        this.schema = union(oneSchema, array(oneSchema));
+    }
+    _test(value, path, options) {
+        return this.schema._test(value, path, options);
+    }
 }
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export function OneOrMany(innerValues, options) {
-    return createSchemaPropertyDecoratorFromSchema(oneOrMany(innerValues, options));
+export function oneOrMany(schema) {
+    return new OneOrManySchema(schema);
+}
+export function OneOrMany(schema, options) {
+    return Property(oneOrMany(schema), options);
 }

package/schema/schemas/optional.d.ts

@@ -1,7 +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 OptionalOptions = ValueSchemaOptions;
-export declare function optional<T>(schema: OneOrMany<SchemaTestable<T>>, options?: OptionalOptions): ValueSchema<T | undefined>;
-export declare function Optional(schema?: OneOrMany<SchemaTestable>): 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 OptionalSchema<T> extends Schema<T | undefined> {
+    readonly schema: Schema<T>;
+    constructor(schema: SchemaTestable<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | undefined>;
+}
+export declare function optional<T>(schema: SchemaTestable<T>): OptionalSchema<T>;
+export declare function Optional(schema?: SchemaTestable, options?: TypedOmit<SchemaPropertyDecoratorOptions, 'optional'>): SchemaPropertyDecorator;

package/schema/schemas/optional.js

@@ -1,8 +1,26 @@
-import { createSchemaPropertyDecorator } from '../decorators/utils.js';
-import { valueSchema } from '../types/index.js';
-export function optional(schema, options) {
-    return valueSchema(schema, { ...options, optional: true });
+import { isUndefined } from '../../utils/type-guards.js';
+import { createSchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+export class OptionalSchema extends Schema {
+    schema;
+    constructor(schema) {
+        if ((schema instanceof OptionalSchema) && (schema == schema.schema)) {
+            return schema; // eslint-disable-line no-constructor-return
+        }
+        super();
+        this.schema = schemaTestableToSchema(schema);
+    }
+    _test(value, path, options) {
+        if (isUndefined(value)) {
+            return { valid: true, value: undefined };
+        }
+        return this.schema._test(value, path, options);
+    }
 }
-export function Optional(schema) {
-    return createSchemaPropertyDecorator({ schema, optional: true });
+export function optional(schema) {
+    return new OptionalSchema(schema);
+}
+export function Optional(schema, options) {
+    return createSchemaPropertyDecorator({ schema, ...options, optional: true });
 }

package/schema/schemas/readable-stream.d.ts

@@ -1,6 +1,8 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { Schema } from '../schema.js';
-import type { ValueSchemaOptions } from '../types/types.js';
-export type ReadableStreamOptions = ValueSchemaOptions;
-export declare function readableStream(options?: ReadableStreamOptions): Schema<ReadableStream>;
-export declare function ReadableStreamProperty(options?: ReadableStreamOptions): Decorator<'property' | 'accessor'>;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type ReadableStreamSchemaOptions = SimpleSchemaOptions;
+export declare class ReadableStreamSchema extends SimpleSchema<ReadableStream> {
+    constructor(options?: ReadableStreamSchemaOptions);
+}
+export declare function readableStream(options?: ReadableStreamSchemaOptions): ReadableStreamSchema;
+export declare function ReadableStreamProperty(options?: SchemaPropertyDecoratorOptions & ReadableStreamSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/readable-stream.js

@@ -1,9 +1,14 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/index.js';
+import { isReadableStream } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SimpleSchema } from './simple.js';
+export class ReadableStreamSchema extends SimpleSchema {
+    constructor(options) {
+        super('ReadableStream', isReadableStream, options);
+    }
+}
 export function readableStream(options) {
-    return valueSchema(ReadableStream, options);
+    return new ReadableStreamSchema(options);
 }
 export function ReadableStreamProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(readableStream(options));
+    return Property(readableStream(options), options);
 }

package/schema/schemas/regexp.d.ts

@@ -1,6 +1,8 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { Schema } from '../schema.js';
-import type { ValueSchemaOptions } from '../types/types.js';
-export type RegExpSchemaOptions = ValueSchemaOptions;
-export declare function regexp(options?: RegExpSchemaOptions): Schema<RegExp>;
-export declare function RegExpProperty(options?: RegExpSchemaOptions): Decorator<'property' | 'accessor'>;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type RegExpSchemaOptions = SimpleSchemaOptions;
+export declare class RegExpSchema extends SimpleSchema<RegExp> {
+    constructor(options?: RegExpSchemaOptions);
+}
+export declare function regExp(options?: RegExpSchemaOptions): RegExpSchema;
+export declare function RegExpProperty(options?: SchemaPropertyDecoratorOptions & RegExpSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/regexp.js

@@ -1,9 +1,27 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/index.js';
-export function regexp(options) {
-    return valueSchema(RegExp, options);
+import { isRegExp } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SimpleSchema } from './simple.js';
+export class RegExpSchema extends SimpleSchema {
+    constructor(options) {
+        super('RegExp', isRegExp, options, {
+            coercers: {
+                string: (value, path, options) => {
+                    try {
+                        const regex = globalThis.RegExp(value, 'u');
+                        return ({ success: true, value: regex, valid: true });
+                    }
+                    catch (error) {
+                        return { success: false, error: SchemaError.couldNotCoerce(globalThis.RegExp, 'string', path, { fast: options.fastErrors, customMessage: error.message }) };
+                    }
+                }
+            }
+        });
+    }
+}
+export function regExp(options) {
+    return new RegExpSchema(options);
 }
 export function RegExpProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(regexp(options));
+    return Property(regExp(options), options);
 }

package/schema/schemas/simple.d.ts

@@ -0,0 +1,27 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import type { AbstractConstructor, OneOrMany } from '../../types.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import type { CoerceResult, Coercible, ConstraintResult } from '../types.js';
+export type SimpleSchemaOptions = Coercible;
+type SimpleSchemaRefinements<T> = {
+    coercers?: SimpleSchemaCoercers<T>;
+    constraints?: (SimpleSchemaConstraint<T> | null)[];
+    gotValueFormatter?: SimpleSchemaGotValueFormatter;
+};
+export type SimpleSchemaCoercers<T> = {
+    string?: (value: string, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    number?: (value: number, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    boolean?: (value: boolean, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    bigint?: (value: bigint, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    undefined?: (value: undefined, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    null?: (value: null, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    all?: (value: unknown, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+};
+export type SimpleSchemaConstraint<T> = (value: T) => ConstraintResult;
+export type SimpleSchemaGotValueFormatter = (value: unknown) => string;
+export declare abstract class SimpleSchema<T> extends Schema<T> {
+    #private;
+    constructor(expected: OneOrMany<string | AbstractConstructor>, guardFn: (value: any) => value is T, options?: SimpleSchemaOptions, refinements?: SimpleSchemaRefinements<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export {};

package/schema/schemas/simple.js

@@ -0,0 +1,57 @@
+import { isDefined, isError, isNotNull, isNull, isUndefined } from '../../utils/type-guards.js';
+import { typeOf } from '../../utils/type-of.js';
+import { SchemaError } from '../schema.error.js';
+import { Schema } from '../schema.js';
+export class SimpleSchema extends Schema {
+    #guardFn;
+    #expected;
+    #options;
+    #coercers;
+    #constraints;
+    #gotValueFormatter;
+    constructor(expected, guardFn, options = {}, refinements = {}) {
+        super();
+        this.#expected = expected;
+        this.#guardFn = guardFn;
+        this.#options = options;
+        this.#coercers = refinements.coercers ?? {};
+        this.#constraints = refinements.constraints?.filter(isNotNull) ?? [];
+        this.#gotValueFormatter = refinements.gotValueFormatter ?? typeOf;
+    }
+    _test(value, path, options) {
+        let result;
+        if (this.#guardFn(value)) {
+            result = { valid: true, value };
+        }
+        else if ((this.#options.coerce ?? options.coerce) == true) {
+            const type = typeof value;
+            const coerceType = isNull(value) ? 'null' : type;
+            const coerceFn = (this.#coercers[coerceType] ?? this.#coercers.all);
+            if (isDefined(coerceFn)) {
+                const coerceResult = coerceFn(value, path, options);
+                if (coerceResult.success) {
+                    if (!coerceResult.valid) {
+                        return this._test(coerceResult.value, path, options);
+                    }
+                    result = { valid: true, value: coerceResult.value };
+                }
+                else if (isDefined(coerceResult.error)) {
+                    result = { valid: false, error: coerceResult.error };
+                }
+            }
+        }
+        if (isUndefined(result)) {
+            return { valid: false, error: SchemaError.expectedButGot(this.#expected, this.#gotValueFormatter(value), path, { fast: options.fastErrors }) };
+        }
+        for (const constraint of this.#constraints) {
+            const constraintResult = constraint(result.value);
+            if (!constraintResult.success) {
+                if (isError(constraintResult.error)) {
+                    return { valid: false, error: constraintResult.error };
+                }
+                return { valid: false, error: new SchemaError(`Constraint validation failed: ${constraintResult.error}`, { path, fast: options.fastErrors }) };
+            }
+        }
+        return result;
+    }
+}

package/schema/schemas/string.d.ts

@@ -1,22 +1,10 @@
-import type { Decorator } from '../../reflection/types.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type StringOptions = ValueSchemaOptions & {
-    /** trim */
-    trim?: boolean;
-    /** lowercase */
-    lowercase?: boolean;
-    /** uppercase */
-    uppercase?: boolean;
-    /** minimum length */
-    minimumLength?: number;
-    /** maximum length */
-    maximumLength?: number;
-    /** regular expression */
-    pattern?: string | RegExp;
-    /** regular expression flags */
-    patternFlags?: string;
-    /** name for errors */
-    patternName?: string;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type StringSchemaOptions = SimpleSchemaOptions & {
+    pattern?: RegExp | string;
 };
-export declare function string(options?: StringOptions): ValueSchema<string>;
-export declare function StringProperty(options?: StringOptions): Decorator<'property' | 'accessor'>;
+export declare class StringSchema extends SimpleSchema<string> {
+    constructor(options?: StringSchemaOptions);
+}
+export declare function string(options?: StringSchemaOptions): StringSchema;
+export declare function StringProperty(options?: SchemaPropertyDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;