@tstdl/base 0.90.92 → 0.91.0-beta1

package/schema/schemas/object.js

@@ -1,12 +1,177 @@
-/* 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 { 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((schemaOrType) => {
+        if (schemaOrType instanceof ObjectSchema) {
+            return schemaOrType;
+        }
+        const typeSchema = getSchemaFromReflection(schemaOrType);
+        assert(typeSchema instanceof ObjectSchema, 'assign() only works with object schemas.');
+        return typeSchema;
+    });
+    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(schema, keyOrKeys) {
+    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(schema, keys) {
+    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(schema, keys) {
+    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 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 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,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 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 { SchemaPropertyDecorator } from '../decorators/types.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): SchemaPropertyDecorator;

package/schema/schemas/optional.js

@@ -1,7 +1,25 @@
+import { isUndefined } from '../../utils/type-guards.js';
 import { createSchemaPropertyDecorator } from '../decorators/utils.js';
-import { valueSchema } from '../types/index.js';
-export function optional(schema, options) {
-    return valueSchema(schema, { ...options, optional: true });
+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 new OptionalSchema(schema);
 }
 export function Optional(schema) {
     return createSchemaPropertyDecorator({ schema, 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 ReadableStream(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));
+export function 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 RegExp(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 RegExpProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(regexp(options));
+export function regExp(options) {
+    return new RegExpSchema(options);
+}
+export function 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,14 @@
-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 String(options?: SchemaPropertyDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;
+/**
+ * @deprecated use {@link String()} instead
+ */
+export declare function StringProperty(options?: SchemaPropertyDecoratorOptions & StringSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/string.js

@@ -1,38 +1,30 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { MaximumLengthConstraint, MinimumLengthConstraint, PatternConstraint } from '../constraints/index.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
-import { LowercaseTransformer, TrimTransformer, UppercaseTransformer } from '../transformers/index.js';
-import { valueSchema } from '../types/types.js';
-export function string(options = {}) {
-    const valueConstraints = toArrayCopy(options.valueConstraints ?? []);
-    const transformers = toArrayCopy(options.transformers ?? []);
-    if (isDefined(options.minimumLength)) {
-        valueConstraints.push(new MinimumLengthConstraint(options.minimumLength));
+import { isDefined, isRegExp, isString } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SimpleSchema } from './simple.js';
+export class StringSchema extends SimpleSchema {
+    constructor(options) {
+        const pattern = isDefined(options?.pattern) ? isString(options.pattern) ? RegExp(options.pattern, 'u') : isRegExp(options.pattern) ? options.pattern : undefined : undefined;
+        super('string', isString, options, {
+            coercers: {
+                number: (value) => ({ success: true, value: globalThis.String(value), valid: true }),
+                boolean: (value) => ({ success: true, value: globalThis.String(value), valid: true }),
+                bigint: (value) => ({ success: true, value: globalThis.String(value), valid: true })
+            },
+            constraints: [
+                isDefined(pattern) ? ((value) => pattern.test(value) ? ({ success: true }) : ({ success: false, error: 'Value did not match pattern.' })) : null
+            ]
+        });
     }
-    if (isDefined(options.maximumLength)) {
-        valueConstraints.push(new MaximumLengthConstraint(options.maximumLength));
-    }
-    if (isDefined(options.pattern)) {
-        const pattern = RegExp(options.pattern, options.patternFlags);
-        valueConstraints.push(new PatternConstraint(pattern, options.patternName));
-    }
-    if (isDefined(options.trim)) {
-        transformers.push(new TrimTransformer());
-    }
-    if (isDefined(options.lowercase)) {
-        transformers.push(new LowercaseTransformer());
-    }
-    if (isDefined(options.uppercase)) {
-        transformers.push(new UppercaseTransformer());
-    }
-    return valueSchema(String, {
-        ...options,
-        valueConstraints,
-        transformers
-    });
 }
+export function string(options) {
+    return new StringSchema(options);
+}
+export function String(options) {
+    return Property(string(options), options);
+}
+/**
+ * @deprecated use {@link String()} instead
+ */
 export function StringProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(string(options));
+    return String(options);
 }

package/schema/schemas/symbol.d.ts

@@ -0,0 +1,12 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class SymbolSchema extends Schema<symbol> {
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<symbol>;
+}
+export declare function symbol(): SymbolSchema;
+export declare function Symbol(): SchemaPropertyDecorator;
+/**
+ * @deprecated use {@link Symbol()} instead
+ */
+export declare function SymbolProperty(): SchemaPropertyDecorator;

package/schema/schemas/symbol.js

@@ -0,0 +1,25 @@
+import { SchemaError } from '../../schema/schema.error.js';
+import { isSymbol } 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 SymbolSchema extends Schema {
+    _test(value, path, options) {
+        if (isSymbol(value)) {
+            return { valid: true, value };
+        }
+        return { valid: false, error: SchemaError.expectedButGot('symbol', typeOf(value), path, { fast: options.fastErrors }) };
+    }
+}
+export function symbol() {
+    return new SymbolSchema();
+}
+export function Symbol() {
+    return Property(symbol());
+}
+/**
+ * @deprecated use {@link Symbol()} instead
+ */
+export function SymbolProperty() {
+    return Symbol();
+}

package/schema/schemas/transform.d.ts

@@ -1,5 +1,9 @@
-import type { OneOrMany } from '../../types.js';
-import type { SchemaTestable } from '../schema.js';
-import type { GenericTransformFunction } from '../transformers/generic.js';
-import type { ValueSchema, ValueType } from '../types/index.js';
-export declare function transform<T, O>(schema: OneOrMany<SchemaTestable<T>>, transformFunction: GenericTransformFunction<T, O>, sourceType?: OneOrMany<ValueType<T>>): ValueSchema<O>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class TransformSchema<I, O> extends Schema<O> {
+    readonly schema: Schema<I>;
+    readonly transformFn: (value: I) => O;
+    constructor(schema: Schema<I>, transformFn: (value: I) => O);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<O>;
+}
+export declare function transform<I, O>(schema: Schema<I>, transformFn: (value: I) => O): TransformSchema<I, O>;