@tstdl/base 0.90.92 → 0.91.0-beta1

package/orm/schema-converter.js

@@ -0,0 +1,74 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { boolean, doublePrecision, integer, pgSchema, text, unique, uuid } from 'drizzle-orm/pg-core';
+import { NotSupportedError } from '../errors/not-supported.error.js';
+import { reflectionRegistry } from '../reflection/registry.js';
+import { Property } from '../schema/index.js';
+import { fromEntries } from '../utils/object/object.js';
+import { assertStringPass, isUndefined } from '../utils/type-guards.js';
+import { Integer } from './types.js';
+export const mySchema = pgSchema('my_schema');
+export const colors = mySchema.enum('colors', ['red', 'green', 'blue']);
+export const mySchemaUsers = mySchema.table('users', {
+    id: uuid('id'),
+    name: text('name'),
+    age: integer(''),
+    color: colors('color').default('red'),
+}, (self) => ({
+    unq: unique().on(self.age).nullsNotDistinct().nullsNotDistinct()
+}));
+export function getDrizzleSchemaFromType(type) {
+    const metadata = reflectionRegistry.getMetadata(type);
+    if (isUndefined(metadata)) {
+        throw new Error('Type does not have reflection metadata.');
+    }
+    const entries = [...metadata.properties].map(([property, propertyMetadata]) => [property, getPostgresColumn(assertStringPass(property), propertyMetadata.type)]);
+    const schema = mySchema.table(type.entityName, fromEntries(entries));
+    return schema;
+}
+function getPostgresColumn(name, type) {
+    if (type == String) {
+        return text(name);
+    }
+    if (type == Number) {
+        return doublePrecision(name);
+    }
+    if (type == Boolean) {
+        return boolean(name);
+    }
+    throw new NotSupportedError(`Type ${type.name} not supported`);
+}
+export class Entity2 {
+    id;
+}
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], Entity2.prototype, "id", void 0);
+export class User extends Entity2 {
+    name;
+    age;
+    hasAge;
+}
+__decorate([
+    Property(),
+    __metadata("design:type", String)
+], User.prototype, "name", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Object)
+], User.prototype, "age", void 0);
+__decorate([
+    Property(),
+    __metadata("design:type", Boolean)
+], User.prototype, "hasAge", void 0);
+const user = getDrizzleSchemaFromType(User);
+const db = null;
+const results = await db.select().from(user);

package/orm/schema.d.ts

@@ -0,0 +1,3 @@
+export interface DbSchemaStatic {
+    readonly entityName: string;
+}

package/orm/schema.js

@@ -0,0 +1 @@
+export {};

package/orm/types.d.ts

@@ -0,0 +1,8 @@
+import { Integer } from '../schema/index.js';
+import type { doublePrecision, integer, uuid } from 'drizzle-orm/pg-core';
+import type { Tagged } from 'type-fest';
+export declare function Uuid(): PropertyDecorator & MethodDecorator;
+export type Uuid<ColumnName extends string> = Tagged<string, 'column', ReturnType<typeof uuid<ColumnName>>>;
+export type Integer<ColumnName extends string> = Tagged<number, 'column', ReturnType<typeof integer<ColumnName>>>;
+export type DoublePrecision<ColumnName extends string> = Tagged<number, 'column', ReturnType<typeof doublePrecision<ColumnName>>>;
+export { Integer };

package/orm/types.js

@@ -0,0 +1,6 @@
+/* eslint-disable @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention */
+import { createSchemaPropertyDecorator, Integer, string } from '../schema/index.js';
+export function Uuid() {
+    return createSchemaPropertyDecorator({ schema: string() });
+}
+export { Integer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.92",
+  "version": "0.91.0-beta1",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -111,11 +111,11 @@
     "luxon": "^3.4",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.20"
+    "type-fest": "4.21"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
-    "@stylistic/eslint-plugin": "2.2",
+    "@stylistic/eslint-plugin": "2.3",
     "@types/chroma-js": "2.4",
     "@types/koa__router": "12.0",
     "@types/luxon": "3.4",
@@ -123,7 +123,7 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "7.14",
+    "@typescript-eslint/eslint-plugin": "7.16",
     "concurrently": "8.2",
     "eslint": "8.57",
     "eslint-import-resolver-typescript": "3.6",
@@ -142,12 +142,14 @@
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.4",
+    "drizzle-orm": "^0.31",
     "handlebars": "^4.7",
     "koa": "^2.15",
     "minio": "^8.0",
     "mjml": "^4.15",
     "mongodb": "^6.7",
     "nodemailer": "^6.9",
+    "pg": "^8.12",
     "playwright": "^1.45",
     "preact": "^10.22",
     "preact-render-to-string": "^6.5",

package/reflection/registry.d.ts

@@ -9,7 +9,7 @@ export type MetadataBase<T extends MetadataType> = {
 export type TypeMetadata = MetadataBase<'type'> & {
     readonly constructor: AbstractConstructor;
     readonly parent: AbstractConstructor | null;
-    /** undefined if class has no constructor */
+    /** Undefined if class has no constructor */
     readonly parameters: ConstructorParameterMetadata[] | undefined;
     readonly properties: ReadonlyMap<string | symbol, PropertyMetadata>;
     readonly staticProperties: ReadonlyMap<string | symbol, PropertyMetadata>;

package/reflection/utils.d.ts

@@ -5,9 +5,9 @@ export type CreateDecoratorTypeOptions = {
 };
 export type CreateDecoratorOptions = {
     data?: Record<string | symbol>;
-    /** merge data values instead of replacing them (requires them to be objects, arrays, maps or sets) */
+    /** Merge data values instead of replacing them (requires them to be objects, arrays, maps or sets) */
     mergeData?: boolean;
-    /** return values of these decorators are not used */
+    /** Return values of these decorators are not used */
     include?: OneOrMany<DecoratorUnion>;
 };
 export type SpecificCreateDecoratorOptions<T extends DecoratorType> = TypedOmit<CreateDecoratorOptions, 'include'> & {

package/schema/decorators/class.d.ts

@@ -1,3 +1,3 @@
-import type { Decorator } from '../../reflection/index.js';
+import { type Decorator } from '../../reflection/index.js';
 import type { SchemaTypeReflectionData } from './types.js';
 export declare function Class(options?: SchemaTypeReflectionData): Decorator<'class'>;

package/schema/decorators/index.d.ts

@@ -1,6 +1,4 @@
 export * from './class.js';
-export * from './coerce.js';
-export * from './constraint.js';
 export * from './property.js';
 export * from './types.js';
 export * from './utils.js';

package/schema/decorators/index.js

@@ -1,6 +1,4 @@
 export * from './class.js';
-export * from './coerce.js';
-export * from './constraint.js';
 export * from './property.js';
 export * from './types.js';
 export * from './utils.js';

package/schema/decorators/property.d.ts

@@ -1,6 +1,7 @@
 import type { Decorator } from '../../reflection/index.js';
-import type { OneOrMany, TypedOmit } from '../../types.js';
-import type { ValueType } from '../types/index.js';
-import type { PropertyOptions } from './types.js';
-export declare function Property(options?: PropertyOptions): Decorator<'property' | 'accessor'>;
-export declare function Property(schema?: OneOrMany<ValueType>, options?: TypedOmit<PropertyOptions, 'schema'>): Decorator<'property' | 'accessor'>;
+import type { TypedOmit } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { SchemaPropertyReflectionData } from './types.js';
+export type SchemaPropertyDecoratorOptions = TypedOmit<SchemaPropertyReflectionData, 'schema'>;
+export declare function Property(schema?: SchemaTestable, options?: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;
+export declare function Property(options?: SchemaPropertyDecoratorOptions): Decorator<'property' | 'accessor'>;

package/schema/decorators/property.js

@@ -1,17 +1,13 @@
 /* eslint-disable @typescript-eslint/naming-convention */
-import { toArray } from '../../utils/array/array.js';
-import { isDefined, isFunction, isString, isUndefined } from '../../utils/type-guards.js';
-import { typeSchema } from '../types/index.js';
+import { isDefined } from '../../utils/type-guards.js';
+import { isSchemaTestable } from '../testable.js';
 import { createSchemaPropertyDecorator } from './utils.js';
-export function Property(optionsOrTypes = {}, optionsOrNothing) {
-    const schema = (isFunction(optionsOrTypes) || isString(optionsOrTypes)) ? typeSchema(optionsOrTypes) : undefined;
-    const options = isUndefined(schema) ? optionsOrTypes : optionsOrNothing ?? {};
-    return createSchemaPropertyDecorator({
-        schema,
-        ...options,
-        coercers: isDefined(options.coercers) ? toArray(options.coercers) : undefined,
-        transformers: isDefined(options.transformers) ? toArray(options.transformers) : undefined,
-        arrayConstraints: isDefined(options.arrayConstraints) ? toArray(options.arrayConstraints) : undefined,
-        valueConstraints: isDefined(options.valueConstraints) ? toArray(options.valueConstraints) : undefined
-    });
+export function Property(schemaOrOptions, optionsOrNothing) {
+    if (isDefined(optionsOrNothing)) {
+        return createSchemaPropertyDecorator({ schema: schemaOrOptions, ...optionsOrNothing });
+    }
+    if (isSchemaTestable(schemaOrOptions)) {
+        return createSchemaPropertyDecorator({ schema: schemaOrOptions });
+    }
+    return createSchemaPropertyDecorator(schemaOrOptions);
 }

package/schema/decorators/types.d.ts

@@ -1,19 +1,14 @@
-import type { OneOrMany } from '../../types.js';
+import type { Decorator } from '../../reflection/types.js';
 import type { SchemaTestable } from '../schema.js';
-import type { ObjectSchema, SchemaArrayConstraint, SchemaFactoryFunction, SchemaValueCoercer, SchemaValueConstraint, SchemaValueTransformer, TypeSchema, ValueSchema, ValueType } from '../types/index.js';
-export type SchemaTypeReflectionData = Partial<Pick<ObjectSchema, 'mask' | 'unknownProperties' | 'unknownPropertiesKey'>> & {
-    schema?: ObjectSchema | TypeSchema | ValueType;
-    factory?: SchemaFactoryFunction<any>;
+import type { ObjectSchemaFactoryFunction, ObjectSchemaOptions } from '../schemas/object.js';
+export type SchemaPropertyDecorator = Decorator<'property' | 'accessor'>;
+export type SchemaTypeReflectionData = Partial<Pick<ObjectSchemaOptions, 'mask' | 'unknownProperties' | 'unknownPropertiesKey'>> & {
+    schema?: SchemaTestable;
+    factory?: ObjectSchemaFactoryFunction<any>;
 };
 export type SchemaPropertyReflectionData = {
-    schema?: OneOrMany<SchemaTestable>;
+    schema?: SchemaTestable;
     array?: boolean;
     optional?: boolean;
     nullable?: boolean;
-    coerce?: boolean;
-    coercers?: readonly SchemaValueCoercer[];
-    transformers?: readonly SchemaValueTransformer[];
-    arrayConstraints?: readonly SchemaArrayConstraint[];
-    valueConstraints?: readonly SchemaValueConstraint[];
 };
-export type PropertyOptions = Partial<ValueSchema<any>>;

package/schema/decorators/utils.d.ts

@@ -1,15 +1,2 @@
-import type { Decorator, PropertyMetadata } from '../../reflection/index.js';
-import type { OneOrMany } from '../../types.js';
-import type { Schema } from '../schema.js';
-import type { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-import type { SchemaValueCoercer } from '../types/schema-value-coercer.js';
-import type { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { SchemaValueTransformer } from '../types/schema-value-transformer.js';
-import type { PropertyOptions, SchemaPropertyReflectionData } from './types.js';
-export declare function createSchemaPropertyDecorator(options: PropertyOptions): Decorator<'property' | 'accessor'>;
-export declare function createSchemaPropertyDecoratorFromSchema(schema: Schema): Decorator<'property' | 'accessor'>;
-export declare function createSchemaValueCoercerDecorator(coercer: SchemaValueCoercer, options?: PropertyOptions): Decorator<'property' | 'accessor'>;
-export declare function createSchemaValueTransformerDecorator(transformer: SchemaValueTransformer, options?: PropertyOptions): Decorator<'property' | 'accessor'>;
-export declare function createSchemaArrayConstraintDecorator(constraint: SchemaArrayConstraint, options?: PropertyOptions): Decorator<'property' | 'accessor'>;
-export declare function createSchemaValueConstraintDecorator(constraints: OneOrMany<SchemaValueConstraint>, options?: PropertyOptions): Decorator<'property' | 'accessor'>;
-export declare function tryGetSchemaPropertyReflectionData(metadata: PropertyMetadata): SchemaPropertyReflectionData | undefined;
+import type { SchemaPropertyDecorator, SchemaPropertyReflectionData } from './types.js';
+export declare function createSchemaPropertyDecorator(data?: SchemaPropertyReflectionData): SchemaPropertyDecorator;

package/schema/decorators/utils.js

@@ -1,48 +1,8 @@
 /* eslint-disable @typescript-eslint/naming-convention */
 import { createPropertyOrAccessorDecorator } from '../../reflection/index.js';
-import { toArray } from '../../utils/array/array.js';
-import { merge } from '../../utils/merge.js';
-import { filterObject } from '../../utils/object/object.js';
-import { isArray, isDefined, isUndefined } from '../../utils/type-guards.js';
-import { isValueSchema, valueSchema } from '../types/types.js';
-export function createSchemaPropertyDecorator(options) {
+export function createSchemaPropertyDecorator(data) {
     return createPropertyOrAccessorDecorator({
-        handler(_, metadata) {
-            const schemaData = getOrCreateSchemaPropertyReflectionData(metadata);
-            const newSchemaData = {
-                ...options,
-                coercers: (isDefined(options.coercers) && (!isArray(options.coercers) || options.coercers.length > 0)) ? merge(toArray(options.coercers), schemaData.coercers) : undefined,
-                transformers: (isDefined(options.transformers) && (!isArray(options.transformers) || options.transformers.length > 0)) ? merge(toArray(options.transformers), schemaData.transformers) : undefined,
-                arrayConstraints: (isDefined(options.arrayConstraints) && (!isArray(options.arrayConstraints) || options.arrayConstraints.length > 0)) ? merge(toArray(options.arrayConstraints), schemaData.arrayConstraints) : undefined,
-                valueConstraints: (isDefined(options.valueConstraints) && (!isArray(options.valueConstraints) || options.valueConstraints.length > 0)) ? merge(toArray(options.valueConstraints), schemaData.valueConstraints) : undefined
-            };
-            metadata.data.set('schema', filterObject(newSchemaData, isDefined), true);
-        }
+        data: { schema: data },
+        mergeData: true
     });
 }
-export function createSchemaPropertyDecoratorFromSchema(schema) {
-    return createSchemaPropertyDecorator(isValueSchema(schema) ? schema : valueSchema(schema));
-}
-export function createSchemaValueCoercerDecorator(coercer, options) {
-    return createSchemaPropertyDecorator({ ...options, coercers: coercer });
-}
-export function createSchemaValueTransformerDecorator(transformer, options) {
-    return createSchemaPropertyDecorator({ ...options, transformers: transformer });
-}
-export function createSchemaArrayConstraintDecorator(constraint, options) {
-    return createSchemaPropertyDecorator({ ...options, arrayConstraints: constraint });
-}
-export function createSchemaValueConstraintDecorator(constraints, options) {
-    return createSchemaPropertyDecorator({ ...options, valueConstraints: constraints });
-}
-export function tryGetSchemaPropertyReflectionData(metadata) {
-    return metadata.data.tryGet('schema');
-}
-function getOrCreateSchemaPropertyReflectionData(metadata) {
-    let schemaData = tryGetSchemaPropertyReflectionData(metadata);
-    if (isUndefined(schemaData)) {
-        schemaData = {};
-        metadata.data.set('schema', schemaData);
-    }
-    return schemaData;
-}

package/schema/index.d.ts

@@ -1,10 +1,5 @@
-export * from './array-constraints/index.js';
-export * from './coercers/index.js';
-export * from './constraints/index.js';
 export * from './decorators/index.js';
 export * from './schema.error.js';
 export * from './schema.js';
 export * from './schemas/index.js';
-export * from './transformers/index.js';
-export * from './types/index.js';
-export * from './utils/index.js';
+export * from './testable.js';

package/schema/index.js

@@ -1,10 +1,19 @@
-export * from './array-constraints/index.js';
-export * from './coercers/index.js';
-export * from './constraints/index.js';
+import { Schema } from './schema.js';
+import { schemaTestableToSchema } from './testable.js';
 export * from './decorators/index.js';
 export * from './schema.error.js';
 export * from './schema.js';
 export * from './schemas/index.js';
-export * from './transformers/index.js';
-export * from './types/index.js';
-export * from './utils/index.js';
+export * from './testable.js';
+Schema.test = function test(schema, value, options) {
+    return schemaTestableToSchema(schema).test(value, options);
+};
+Schema.validate = function validate(schema, value, options) {
+    return schemaTestableToSchema(schema).validate(value, options);
+};
+Schema.assert = function assert(schema, value, options) {
+    schemaTestableToSchema(schema).assert(value, options);
+};
+Schema.parse = function parse(schema, value, options) {
+    return schemaTestableToSchema(schema).parse(value, options);
+};

package/schema/schema.d.ts

@@ -1,15 +1,90 @@
-import { JsonPath } from '../json-path/index.js';
-import type { NormalizedObjectSchema, NormalizedTypeSchema, NormalizedValueSchema, ObjectSchema, SchemaOutput, SchemaTestOptions, SchemaTestResult, SchemaValueCoercer, TupleSchemaOutput, TypeSchema, ValueSchema, ValueType } from './types/index.js';
-export type Schema<T = any> = ObjectSchema<T> | ValueSchema<T> | TypeSchema<T>;
-export type SchemaTestable<T = any> = Schema<T> | ValueType<T>;
-export type NormalizedSchema<T = any> = NormalizedObjectSchema<T> | NormalizedValueSchema<T> | NormalizedTypeSchema<T>;
-export declare const Schema: {
-    registerDefaultCoercer(coercer: SchemaValueCoercer): void;
-    test<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
-    validate<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions): boolean;
-    parse<T>(schemaOrValueType: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions): T;
-    function<T extends readonly SchemaTestable[], R extends SchemaTestable, F extends (...args: TupleSchemaOutput<T>) => SchemaOutput<R>>(argumentSchemas: T, returnSchema: R, handler: F): F;
-    asyncFunction<T extends readonly SchemaTestable[], R extends SchemaTestable, F extends (...args: TupleSchemaOutput<T>) => Promise<SchemaOutput<R>>>(argumentSchemas: T, returnSchema: R, handler: F): F;
+import type { IsEqual, Or } from 'type-fest';
+import { JsonPath } from '../json-path/json-path.js';
+import type { AbstractConstructor } from '../types.js';
+import type { SchemaError } from './schema.error.js';
+import type { Coercible, Maskable } from './types.js';
+export type SchemaTestOptions = Coercible & Maskable & {
+    /**
+     * Use fast errors which can improve performance a lot but misses detailed stack traces.
+     */
+    fastErrors?: boolean;
 };
-export declare function testSchema<T>(schema: Schema<T>, value: unknown, options?: SchemaTestOptions, path?: JsonPath): SchemaTestResult<T>;
-export declare function getExpectString(schema: SchemaTestable): string;
+export type SchemaTestResult<T> = {
+    valid: true;
+    value: T;
+    error?: undefined;
+} | {
+    valid: false;
+    value?: undefined;
+    error: SchemaError;
+};
+type NormalizePrimitiveToConstructor<T> = Or<IsEqual<T, string>, IsEqual<T, String>> extends true ? typeof String : Or<IsEqual<T, number>, IsEqual<T, Number>> extends true ? typeof Number : Or<IsEqual<T, boolean>, IsEqual<T, Boolean>> extends true ? typeof Boolean : Or<IsEqual<T, bigint>, IsEqual<T, BigInt>> extends true ? typeof BigInt : Or<IsEqual<T, symbol>, IsEqual<T, Symbol>> extends true ? typeof Symbol : never;
+type NormalizeConstructorToPrimitve<T> = T extends String ? string : T extends Number ? number : T extends Boolean ? boolean : T extends BigInt ? bigint : T extends Symbol ? symbol : T;
+export type SchemaTestable<T = unknown> = Schema<T> | AbstractConstructor<T> | NormalizePrimitiveToConstructor<T>;
+export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? NormalizeConstructorToPrimitve<U> : never;
+export declare abstract class Schema<T = unknown> {
+    /**
+     * 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 readonly test: <T>(schema: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions) => SchemaTestResult<T>;
+    /**
+     * 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 readonly validate: <T>(schema: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions) => boolean;
+    /**
+     * 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 readonly assert: <T>(schema: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions) => asserts value is T;
+    /**
+     * 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 readonly parse: <T>(schema: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions) => T;
+    /**
+     * 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: any, options?: SchemaTestOptions): SchemaTestResult<T>;
+    /**
+     * 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: any, options?: SchemaTestOptions): boolean;
+    /**
+     * 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: any, options?: SchemaTestOptions): asserts value is T;
+    /**
+     * 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: any, options?: SchemaTestOptions): T;
+    abstract _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export {};

package/schema/schema.error.d.ts

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

package/schema/schema.error.js

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