@tstdl/base 0.93.51 → 0.93.54

package/orm/sqls.js

@@ -7,7 +7,7 @@
 import { and, Column, eq, sql, isNotNull as sqlIsNotNull, Table } from 'drizzle-orm';
 import { match, P } from 'ts-pattern';
 import { mapObjectValues, objectEntries, objectValues } from '../utils/object/object.js';
-import { assertDefined, isDefined, isInstanceOf, isNotNull, isNull, isNumber, isString } from '../utils/type-guards.js';
+import { assertDefined, isArray, isDefined, isInstanceOf, isNotNull, isNull, isNumber, isString } from '../utils/type-guards.js';
 import { getEnumName } from './enums.js';
 /** Drizzle SQL helper for getting the current transaction's timestamp. Returns a Date object. */
 export const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
@@ -268,7 +268,7 @@ export function tsRankCd(tsvector, tsquery, options) {
 export function tsHeadline(language, document, tsquery, options) {
     const documentSql = isString(document) ? sql `${document}` : document;
     if (isDefined(options)) {
-        const optionsString = Object.entries(options).map(([key, value]) => `${key[0].toUpperCase()}${key.slice(1)}=${String(value)}`).join(', ');
+        const optionsString = objectEntries(options).map(([key, value]) => `${key[0].toUpperCase()}${key.slice(1)}=${String(value)}`).join(', ');
         return sql `ts_headline(${language}, ${documentSql}, ${tsquery}, '${sql.raw(optionsString)}')`;
     }
     return sql `ts_headline(${language}, ${documentSql}, ${tsquery})`;
@@ -322,7 +322,7 @@ export function strictWordDistance(left, right) {
     return sql `(${left} <<<-> ${right})`;
 }
 export function jsonbBuildObject(properties) {
-    const entries = Array.isArray(properties) ? properties : Object.entries(properties);
+    const entries = isArray(properties) ? properties : objectEntries(properties);
     const chunks = entries
         .filter(([_, propValue]) => isDefined(propValue))
         .map(([propKey, propValue]) => sql `'${sql.raw(propKey)}', ${propValue}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.51",
+  "version": "0.93.54",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,7 +152,7 @@
     "nodemailer": "^7.0",
     "pg": "^8.16",
     "playwright": "^1.57",
-    "preact": "^10.27",
+    "preact": "^10.28",
     "preact-render-to-string": "^6.6",
     "sharp": "^0.34",
     "undici": "^7.16",

package/schema/converters/zod-converter.d.ts

@@ -1,3 +1,9 @@
-import * as z from 'zod/mini';
+import { z } from 'zod';
 import type { SchemaTestable } from '../schema.js';
-export declare function convertToZodSchema<O, I = unknown>(testable: SchemaTestable<O>): z.ZodMiniType<O, I>;
+export type SchemaConversionOptions = {
+    /** Default coerce option if not specified in schema */
+    coerce?: boolean;
+    /** Default mask option if not specified in schema */
+    mask?: boolean;
+};
+export declare function convertToZodSchema<O, I = unknown>(testable: SchemaTestable<O>, options?: SchemaConversionOptions): z.ZodType<O, I>;

package/schema/converters/zod-converter.js

@@ -1,172 +1,218 @@
-import * as z from 'zod/mini';
+import { match, P } from 'ts-pattern';
+import { z } from 'zod';
 import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { JsonPath } from '../../json-path/json-path.js';
 import { objectEntries, objectKeys } from '../../utils/object/object.js';
-import { isArray, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
-import { any, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, DateSchema, DefaultSchema, DeferredSchema, EnumerationSchema, InstanceSchema, LiteralSchema, NeverSchema, NullableSchema, NumberSchema, ObjectSchema, OneOrManySchema, OptionalSchema, ReadableStreamSchema, RegExpSchema, StringSchema, SymbolSchema, TransformSchema, Uint8ArraySchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
+import { isArray, isInstanceOf, isNotNull, isNumber, isString } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { any, AnySchema, ArraySchema, BigIntSchema, BooleanSchema, ConstraintSchema, DateSchema, DefaultSchema, DeferredSchema, EnumerationSchema, FunctionSchema, InstanceSchema, LiteralSchema, NeverSchema, NullableSchema, NumberSchema, ObjectSchema, OneOrManySchema, OptionalSchema, ReadableStreamSchema, RegExpSchema, StringSchema, SymbolSchema, TransformSchema, Uint8ArraySchema, UnionSchema, UnknownSchema } from '../schemas/index.js';
 import { schemaTestableToSchema } from '../testable.js';
-export function convertToZodSchema(testable) {
+export function convertToZodSchema(testable, options) {
     const schema = schemaTestableToSchema(testable);
-    return convertToZodSchemaBase(schema);
+    return convertToZodSchemaBase(schema, options);
 }
-function convertToZodSchemaBase(schema) {
-    if (schema instanceof AnySchema) {
-        return z.any();
-    }
-    if (schema instanceof UnknownSchema) {
-        return z.unknown();
-    }
-    if (schema instanceof NeverSchema) {
-        return z.never();
-    }
-    if (schema instanceof NullableSchema) {
-        return z.nullable(convertToZodSchema(schema.schema));
-    }
-    if (schema instanceof OptionalSchema) {
-        return z.optional(convertToZodSchema(schema.schema));
-    }
-    if (schema instanceof OneOrManySchema) {
-        return convertToZodSchema(schema.schema);
-    }
-    if (schema instanceof StringSchema) {
-        const checks = [];
-        if (isNumber(schema.minimumLength)) {
-            checks.push(z.minLength(schema.minimumLength));
+function convertToZodSchemaBase(schema, options) {
+    let zodSchema = match(schema)
+        .with(P.instanceOf(AnySchema), () => z.any())
+        .with(P.instanceOf(UnknownSchema), () => z.unknown())
+        .with(P.instanceOf(NeverSchema), () => z.never())
+        .with(P.instanceOf(NullableSchema), (s) => convertToZodSchemaBase(s.schema, options).nullable())
+        .with(P.instanceOf(OptionalSchema), (s) => convertToZodSchemaBase(s.schema, options).optional())
+        .with(P.instanceOf(OneOrManySchema), (s) => {
+        const innerSchema = convertToZodSchemaBase(s.schema, options);
+        return innerSchema.or(innerSchema.array());
+    })
+        .with(P.instanceOf(StringSchema), (s) => {
+        let zodSchema = (s.coerce ?? options?.coerce ?? false) ? z.coerce.string() : z.string();
+        if (isNumber(s.minimumLength)) {
+            zodSchema = zodSchema.min(s.minimumLength);
         }
-        if (isNumber(schema.maximumLength)) {
-            checks.push(z.maxLength(schema.maximumLength));
+        if (isNumber(s.maximumLength)) {
+            zodSchema = zodSchema.max(s.maximumLength);
         }
-        if (isNotNull(schema.pattern)) {
-            checks.push(z.regex(isString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern));
+        if (isNotNull(s.pattern)) {
+            zodSchema = zodSchema.regex(s.pattern);
         }
-        if (schema.lowercase) {
-            checks.push(z.toLowerCase());
+        if (s.trim) {
+            zodSchema = zodSchema.trim();
         }
-        const zodSchema = z.string();
-        return (checks.length > 0) ? zodSchema.check(...checks) : zodSchema;
-    }
-    if (schema instanceof NumberSchema) {
-        const checks = [];
-        if (isNumber(schema.minimum)) {
-            checks.push(z.gte(schema.minimum));
+        if (s.lowercase) {
+            zodSchema = zodSchema.toLowerCase();
         }
-        if (isNumber(schema.maximum)) {
-            checks.push(z.lte(schema.maximum));
+        return zodSchema;
+    })
+        .with(P.instanceOf(NumberSchema), (s) => {
+        let zodSchema = (s.coerce ?? options?.coerce ?? false) ? z.coerce.number() : z.number();
+        if (s.integer) {
+            zodSchema = zodSchema.int();
         }
-        const zodSchema = (schema.integer) ? z.int() : z.number();
-        return (checks.length > 0) ? zodSchema.check(...checks) : zodSchema;
-    }
-    if (schema instanceof BooleanSchema) {
-        return z.boolean();
-    }
-    if (schema instanceof BigIntSchema) {
-        return z.bigint();
-    }
-    if (schema instanceof SymbolSchema) {
-        return z.symbol();
-    }
-    if (schema instanceof DateSchema) {
-        const checks = [];
-        if (isNotNull(schema.minimum)) {
-            checks.push(z.gte(schema.minimum));
+        if (isNumber(s.minimum)) {
+            zodSchema = zodSchema.gte(s.minimum);
         }
-        if (isNotNull(schema.maximum)) {
-            checks.push(z.lte(schema.maximum));
+        if (isNumber(s.maximum)) {
+            zodSchema = zodSchema.lte(s.maximum);
         }
-        const zodSchema = z.date();
-        return (checks.length > 0) ? zodSchema.check(...checks) : zodSchema;
-    }
-    if (schema instanceof LiteralSchema) {
-        return z.literal(schema.value);
-    }
-    if (schema instanceof ArraySchema) {
-        const itemSchema = convertToZodSchema(schema.itemSchema);
-        const checks = [];
-        if (isNumber(schema.minimum)) {
-            checks.push(z.minSize(schema.minimum));
+        return zodSchema;
+    })
+        .with(P.instanceOf(BooleanSchema), (s) => (s.coerce ?? options?.coerce ?? false) ? z.coerce.boolean() : z.boolean())
+        .with(P.instanceOf(BigIntSchema), (s) => (s.coerce ?? options?.coerce ?? false) ? z.coerce.bigint() : z.bigint())
+        .with(P.instanceOf(SymbolSchema), () => z.symbol())
+        .with(P.instanceOf(DateSchema), (s) => {
+        let zodSchema = (s.coerce ?? options?.coerce ?? false) ? z.coerce.date() : z.date();
+        if (isNotNull(s.minimum)) {
+            zodSchema = zodSchema.min(s.minimum);
         }
-        if (isNumber(schema.maximum)) {
-            checks.push(z.maxSize(schema.maximum));
+        if (isNotNull(s.maximum)) {
+            zodSchema = zodSchema.max(s.maximum);
         }
-        const zodSchema = z.array(itemSchema);
-        return (checks.length > 0) ? zodSchema.check(...checks) : zodSchema;
-    }
-    if (schema instanceof ObjectSchema) {
-        const propertyEntries = objectEntries(schema.properties);
-        if ((propertyEntries.length == 0) && (isNotNull(schema.unknownPropertiesKey) || isNotNull(schema.unknownProperties))) {
-            return z.record(convertToZodSchema(schema.unknownPropertiesKey ?? any()), convertToZodSchema(schema.unknownProperties ?? any()));
+        return zodSchema;
+    })
+        .with(P.instanceOf(LiteralSchema), (s) => z.literal(s.value))
+        .with(P.instanceOf(ArraySchema), (s) => {
+        const itemSchema = convertToZodSchemaBase(s.itemSchema, options);
+        let zodSchema = z.array(itemSchema);
+        if (isNumber(s.minimum)) {
+            zodSchema = zodSchema.min(s.minimum);
+        }
+        if (isNumber(s.maximum)) {
+            zodSchema = zodSchema.max(s.maximum);
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(ObjectSchema), (s) => {
+        const propertyEntries = objectEntries(s.properties);
+        // Handle generic records (no specific properties, but has unknownProperties/Key)
+        if ((propertyEntries.length == 0) && (isNotNull(s.unknownPropertiesKey) || isNotNull(s.unknownProperties))) {
+            return z.record(convertToZodSchema(s.unknownPropertiesKey ?? any()), convertToZodSchema(s.unknownProperties ?? any()));
         }
         const shape = {};
         for (const [key, propertySchema] of propertyEntries) {
-            shape[key] = convertToZodSchema(propertySchema);
-        }
-        const loose = isNotNull(schema.unknownPropertiesKey) || isNotNull(schema.unknownProperties);
-        const zodSchema = loose
-            ? z.looseObject(shape)
-            : schema.mask
-                ? z.object(shape)
-                : z.strictObject(shape);
-        if (loose) {
-            const propertiesSchema = convertToZodSchema(schema.unknownProperties ?? any());
-            const propertiesKeySchema = convertToZodSchema(schema.unknownPropertiesKey ?? any());
+            shape[key] = convertToZodSchemaBase(propertySchema, options);
+        }
+        const loose = isNotNull(s.unknownPropertiesKey) || isNotNull(s.unknownProperties);
+        let zodSchema = loose ? z.looseObject(shape) : z.object(shape);
+        if (!loose && !(s.mask ?? options?.mask ?? false)) {
+            zodSchema = zodSchema.strict();
+        }
+        if (isNotNull(s.unknownProperties)) {
+            zodSchema = zodSchema.catchall(convertToZodSchemaBase(s.unknownProperties, options));
+        }
+        // Apply custom validation for unknown properties if they are defined
+        if (isNotNull(s.unknownPropertiesKey)) {
+            const propertiesKeySchema = convertToZodSchemaBase(s.unknownPropertiesKey, options);
             const knownPropertyKeys = new Set(objectKeys(shape));
-            return zodSchema.check(z.superRefine((record, context) => {
-                for (const [key, value] of objectEntries(record)) {
+            return zodSchema.check((context) => {
+                for (const key of objectKeys(context.value)) {
                     if (knownPropertyKeys.has(key)) {
                         continue;
                     }
                     const keyParseResult = propertiesKeySchema.safeParse(key);
-                    const valueParseResult = propertiesSchema.safeParse(value);
                     if (!keyParseResult.success) {
-                        context.addIssue({
+                        context.issues.push({
                             code: 'invalid_key',
                             origin: 'record',
                             issues: keyParseResult.error.issues,
-                        });
-                    }
-                    if (!valueParseResult.success) {
-                        context.addIssue({
-                            code: 'custom',
-                            input: value,
-                            path: [key],
-                            message: valueParseResult.error.message,
+                            input: key,
                         });
                     }
                 }
-            }));
+            });
+        }
+        if (isNotNull(s.minimumPropertiesCount)) {
+            zodSchema = zodSchema.refine((obj) => objectKeys(obj).length >= s.minimumPropertiesCount, {
+                message: `Object must have at least ${s.minimumPropertiesCount} properties.`,
+            });
+        }
+        if (isNotNull(s.maximumPropertiesCount)) {
+            zodSchema = zodSchema.refine((obj) => objectKeys(obj).length <= s.maximumPropertiesCount, {
+                message: `Object must have at most ${s.maximumPropertiesCount} properties.`,
+            });
         }
         return zodSchema;
-    }
-    if (schema instanceof UnionSchema) {
-        const schemas = schema.schemas.map((s) => convertToZodSchema(s));
+    })
+        .with(P.instanceOf(UnionSchema), (s) => {
+        const schemas = s.schemas.map((subSchema) => convertToZodSchemaBase(subSchema, options));
         return z.union(schemas);
-    }
-    if (schema instanceof EnumerationSchema) {
-        if (isArray(schema.enumeration) && schema.enumeration.some((v) => isNumber(v))) {
-            const types = schema.allowedValues.map((value) => z.literal(value));
+    })
+        .with(P.instanceOf(EnumerationSchema), (s) => {
+        // Zod nativeEnum or enum doesn't support numbers directly without hacks or native TS enums.
+        // Use union of literals for mixed or number enums.
+        if (isArray(s.enumeration) && s.enumeration.some((v) => isNumber(v))) {
+            const types = s.allowedValues.map((value) => z.literal(value));
             return z.union(types);
         }
-        return z.enum(schema.enumeration);
-    }
-    if (schema instanceof DefaultSchema) {
-        return z._default(convertToZodSchema(schema.schema), schema.defaultValue);
-    }
-    if (schema instanceof TransformSchema) {
-        return z.transform((input) => schema.transformFn(input));
-    }
-    if (schema instanceof DeferredSchema) {
-        return z.lazy(() => convertToZodSchema(schema.schema));
-    }
-    if (schema instanceof Uint8ArraySchema) {
-        return z.instanceof(Uint8Array);
-    }
-    if (schema instanceof ReadableStreamSchema) {
-        return z.instanceof(ReadableStream);
-    }
-    if (schema instanceof RegExpSchema) {
-        return z.instanceof(RegExp);
-    }
-    if (schema instanceof InstanceSchema) {
-        return z.instanceof(schema.type);
-    }
-    throw new NotSupportedError(`Schema "${schema.name}" cannot be converted to Zod schema.`);
+        // enumeration is either EnumerationObject or string-only EnumerationArray, both is fine for z.enum
+        // using `as`, as z.enum is overloaded and only one type per overload
+        return z.enum(s.enumeration);
+    })
+        .with(P.instanceOf(FunctionSchema), (s) => {
+        let zodSchema = z.function();
+        if (isNotNull(s.parameterSchemas)) {
+            const args = s.parameterSchemas.map((parameterSchema) => convertToZodSchema(parameterSchema, options));
+            zodSchema = zodSchema.input(...args);
+        }
+        if (isNotNull(s.returnValueSchema)) {
+            zodSchema = zodSchema.output(convertToZodSchema(s.returnValueSchema, options));
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(DefaultSchema), (s) => convertToZodSchemaBase(s.schema, options).default(s.defaultValue))
+        .with(P.instanceOf(TransformSchema), (s) => convertToZodSchemaBase(s.schema, options).transform((input) => s.transformFn(input)))
+        .with(P.instanceOf(DeferredSchema), (s) => z.lazy(() => convertToZodSchemaBase(s.schema, options)))
+        .with(P.instanceOf(Uint8ArraySchema), (s) => {
+        let zodSchema = z.instanceof(Uint8Array);
+        if (isNumber(s.minimumLength)) {
+            zodSchema = zodSchema.refine((value) => (value.byteLength >= s.minimumLength), {
+                message: `Size must be at least ${s.minimumLength} bytes.`,
+            });
+        }
+        if (isNumber(s.maximumLength)) {
+            zodSchema = zodSchema.refine((value) => (value.byteLength <= s.maximumLength), {
+                message: `Size must be at most ${s.maximumLength} bytes.`,
+            });
+        }
+        if ((s.coerce ?? options?.coerce ?? false) && isNotNull(s.coerceType)) {
+            zodSchema = z.preprocess((value, context) => {
+                if (isString(value)) {
+                    try {
+                        return Uint8ArraySchema.coerce(value, s.coerceType);
+                    }
+                    catch {
+                        context.addIssue({ code: 'invalid_format', format: s.coerceType, input: value });
+                    }
+                }
+                return value;
+            }, zodSchema);
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(ReadableStreamSchema), () => z.instanceof(ReadableStream))
+        .with(P.instanceOf(RegExpSchema), (s) => {
+        let zodSchema = z.instanceof(RegExp);
+        if (s.coerce ?? options?.coerce ?? false) {
+            zodSchema = z.preprocess((value) => {
+                if (isString(value)) {
+                    return new RegExp(value, 'u');
+                }
+                return value;
+            }, zodSchema);
+        }
+        return zodSchema;
+    })
+        .with(P.instanceOf(InstanceSchema), (s) => z.instanceof(s.type))
+        .with(P.instanceOf(ConstraintSchema), (s) => convertToZodSchemaBase(s.schema, options).superRefine((value, context) => {
+        const result = s.constraintFn(value, { path: JsonPath.ROOT, options: { coerce: options?.coerce, mask: options?.mask } });
+        if (result == true) {
+            return;
+        }
+        const message = isString(result) ? result : isInstanceOf(result, SchemaError) ? result.message : 'Constraint validation failed.';
+        context.addIssue({ code: 'custom', message, input: value });
+    }))
+        .otherwise(() => {
+        throw new NotSupportedError(`Schema "${schema.name}" cannot be converted to Zod schema.`);
+    });
+    if (isNotNull(schema.description)) {
+        zodSchema = zodSchema.describe(schema.description);
+    }
+    return zodSchema;
 }

package/schema/schemas/bigint.js

@@ -24,8 +24,8 @@ export class BigIntSchema extends SimpleSchema {
                     catch (error) {
                         return { success: false, error: SchemaError.couldNotCoerce('bigint', 'string', path, { fast: coerceOptions.fastErrors, customMessage: error.message }) };
                     }
-                }
-            }
+                },
+            },
         });
     }
 }

package/schema/schemas/boolean.d.ts

@@ -4,6 +4,7 @@ export type BooleanSchemaOptions = SimpleSchemaOptions<boolean>;
 export declare class BooleanSchema extends SimpleSchema<boolean> {
     readonly name = "boolean";
     constructor(options?: BooleanSchemaOptions);
+    static coerce(value: unknown): boolean | null;
 }
 export declare function boolean(options?: BooleanSchemaOptions): BooleanSchema;
 export declare function BooleanProperty(options?: BooleanSchemaOptions & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/boolean.js

@@ -1,33 +1,33 @@
 import { isBoolean, isString } from '../../utils/type-guards.js';
 import { PropertySchema } from '../decorators/index.js';
 import { SimpleSchema } from './simple.js';
+const truthyValues = new Set([1, 1n, true, 'true', '1', 'yes', 'on', 'y', 'enabled']);
+const falsyValues = new Set([0, 0n, false, 'false', '0', 'no', 'off', 'n', 'disabled']);
 export class BooleanSchema extends SimpleSchema {
     name = 'boolean';
     constructor(options) {
         super('boolean', isBoolean, options, {
             coercers: {
                 all: (value) => {
-                    const normalizedValue = isString(value) ? value.toLowerCase().trim() : value;
-                    switch (normalizedValue) {
-                        case 1:
-                        case 1n:
-                        case 'true':
-                        case '1':
-                        case 'yes':
-                            return { success: true, value: true, valid: true };
-                        case 0:
-                        case 0n:
-                        case 'false':
-                        case '0':
-                        case 'no':
-                            return { success: true, value: false, valid: true };
-                        default:
-                            return { success: false };
+                    const coerceValue = BooleanSchema.coerce(value);
+                    if (coerceValue === null) {
+                        return { success: false };
                     }
+                    return { success: true, value: coerceValue, valid: true };
                 },
             },
         });
     }
+    static coerce(value) {
+        const normalizedValue = isString(value) ? value.toLowerCase().trim() : value;
+        if (truthyValues.has(normalizedValue)) {
+            return true;
+        }
+        if (falsyValues.has(normalizedValue)) {
+            return false;
+        }
+        return null;
+    }
 }
 export function boolean(options) {
     return new BooleanSchema(options);

package/schema/schemas/constraint.d.ts

@@ -0,0 +1,19 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import { SchemaError } from '../schema.error.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+type ConstraintFnContext = {
+    path: JsonPath;
+    options: SchemaTestOptions;
+};
+/**
+ * Adds a constraint function to an existing schema.
+ */
+export declare class ConstraintSchema<T> extends Schema<T> {
+    readonly name: string;
+    readonly schema: Schema<T>;
+    readonly constraintFn: (value: T, context: ConstraintFnContext) => boolean | string | SchemaError;
+    constructor(schema: SchemaTestable<T>, constraintFn: (value: T, context: ConstraintFnContext) => boolean | SchemaError);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export declare function constraint<T>(schema: Schema<T>, constraintFn: (value: T) => boolean | SchemaError): ConstraintSchema<T>;
+export {};

package/schema/schemas/constraint.js

@@ -0,0 +1,36 @@
+import { lazyProperty } from '../../utils/object/lazy-property.js';
+import { isInstanceOf, isString } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+/**
+ * Adds a constraint function to an existing schema.
+ */
+export class ConstraintSchema extends Schema {
+    name;
+    schema;
+    constraintFn;
+    constructor(schema, constraintFn) {
+        super();
+        this.schema = schemaTestableToSchema(schema);
+        this.constraintFn = constraintFn;
+        lazyProperty(this, 'name', () => `Constraint[${this.schema.name}]`);
+    }
+    _test(value, path, options) {
+        const result = this.schema._test(value, path, options);
+        if (!result.valid) {
+            return result;
+        }
+        const constraintResult = this.constraintFn(result.value, { path, options });
+        if (constraintResult == true) {
+            return { valid: true, value: result.value };
+        }
+        const error = isInstanceOf(constraintResult, SchemaError)
+            ? constraintResult
+            : new SchemaError(isString(constraintResult) ? constraintResult : `Value not passing constraint`, path, { fast: options.fastErrors });
+        return { valid: false, error };
+    }
+}
+export function constraint(schema, constraintFn) {
+    return new ConstraintSchema(schema, constraintFn);
+}

package/schema/schemas/index.d.ts

@@ -2,6 +2,7 @@ export * from './any.js';
 export * from './array.js';
 export * from './bigint.js';
 export * from './boolean.js';
+export * from './constraint.js';
 export * from './date.js';
 export * from './defaulted.js';
 export * from './deferred.js';

package/schema/schemas/index.js

@@ -2,6 +2,7 @@ export * from './any.js';
 export * from './array.js';
 export * from './bigint.js';
 export * from './boolean.js';
+export * from './constraint.js';
 export * from './date.js';
 export * from './defaulted.js';
 export * from './deferred.js';

package/schema/schemas/object.d.ts

@@ -35,8 +35,10 @@ export type ObjectSchemaPropertiesType<TP extends ObjectSchemaProperties> = Simp
 }>;
 export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflection;
 export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
-    private readonly propertyKeys;
+    private readonly propertyEntries;
+    private readonly knownPropertyKeys;
     private readonly allowUnknownProperties;
+    private readonly resultValueConstructor;
     readonly name: string;
     readonly properties: NormalizedObjectSchemaProperties<T>;
     readonly mask: boolean | null;