@cleverbrush/schema 1.1.10 → 2.0.0

package/dist/builders/DateSchemaBuilder.js

@@ -1,433 +1,2 @@
-import { transaction } from '../utils/transaction.js';
-import { SchemaBuilder } from './SchemaBuilder.js';
-const parseFromJsonPreprocessor = (value) => {
-    if (typeof value === 'undefined')
-        return value;
-    if (typeof value === 'string') {
-        const time = Date.parse(value);
-        if (Number.isNaN(time))
-            return value;
-        return new Date(time);
-    }
-    return value;
-};
-const parseFromEpochPreprocessor = (value) => {
-    if (typeof value === 'undefined')
-        return value;
-    if (typeof value === 'number') {
-        const time = new Date(value);
-        if (Number.isNaN(time.getTime()))
-            return value;
-        return time;
-    }
-    return value;
-};
-/**
- * Allows to create Date schema. It can be required or optional.
- * It can be restricted to be: equal to a certain value, in future, in past, in a certain range.
- * Supports parsing from JSON string and UNIX epoch (using preprocessors).
- *
- * **NOTE** this class is exported only to give opportunity to extend it
- * by inheriting. It is not recommended to create an instance of this class
- * directly. Use {@link date | date()} function instead.
- *
- * @example ```ts
- * const date = new Date(2020, 0, 2);
- * const schema = date().min(new Date(2020, 0, 1));
- * const result = await schema.validate(date);
- * // result.valid === true
- * // result.object === date
- * ```
- *
- * @example ```ts
- * const schema = date();
- * const result = await schema.validate('2020-01-01');
- * // result.valid === false
- * // result.errors[0].message === 'is expected to be a date'
- * ```
- *
- * @example ```ts
- * const schema = date().parseFromJson();
- * const result = await schema.validate('2020-01-01T00:00:00.000Z');
- * // result.valid === true
- * // result.object is equal to corresponding Date object
- * ```
- *
- * @example ```ts
- * const schema = date().parseFromEpoch();
- * const result = await schema.validate(1577836800000);
- * // result.valid === true
- * // result.object is equal to corresponding Date object
- * ```
- *
- * @see {@link date}
- */
-export class DateSchemaBuilder extends SchemaBuilder {
-    #min;
-    #max;
-    #equalsTo;
-    #ensureIsInFuture = false;
-    #ensureIsInPast = false;
-    #parseFromJson = false;
-    #parseFromEpoch = false;
-    static create(props) {
-        return new DateSchemaBuilder({
-            type: 'date',
-            ...props
-        });
-    }
-    constructor(props) {
-        super(props);
-        if (props.min instanceof Date) {
-            this.#min = props.min;
-        }
-        if (props.max instanceof Date) {
-            this.#max = props.max;
-        }
-        if (typeof props.ensureIsInFuture === 'boolean') {
-            this.#ensureIsInFuture = props.ensureIsInFuture;
-        }
-        if (typeof props.ensureIsInPast === 'boolean') {
-            this.#ensureIsInPast = props.ensureIsInPast;
-        }
-        if (typeof props.parseFromJson === 'boolean') {
-            this.#parseFromJson = props.parseFromJson;
-        }
-        if (typeof props.parseFromEpoch === 'boolean') {
-            this.#parseFromEpoch = props.parseFromEpoch;
-        }
-        if (props.equalsTo instanceof Date ||
-            typeof props.equalsTo === 'undefined') {
-            this.#equalsTo = props.equalsTo;
-        }
-    }
-    introspect() {
-        return {
-            ...super.introspect(),
-            /**
-             * Min valid value (if defined).
-             */
-            min: this.#min,
-            /**
-             * Max valid value (if defined).
-             */
-            max: this.#max,
-            /**
-             * Make sure that date is in future. `false` by default.
-             */
-            ensureIsInFuture: this.#ensureIsInFuture,
-            /**
-             * Make sure that date is in past. `false` by default.
-             */
-            ensureIsInPast: this.#ensureIsInPast,
-            /**
-             * If set, restrict date to be equal to a certain value.
-             */
-            equalsTo: this.#equalsTo,
-            /**
-             * If set, schema will try to parse date from the UNIX epoch (number).
-             * `false` by default.
-             */
-            parseFromEpoch: this.#parseFromEpoch,
-            /**
-             * If set, schema will try to parse date from JSON string.
-             * `false` by default.
-             */
-            parseFromJson: this.#parseFromJson,
-            /**
-             * Array of preprocessor functions
-             */
-            preprocessors: this.preprocessors,
-            /**
-             * Array of validator functions
-             */
-            validators: this.validators
-        };
-    }
-    /**
-     * @hidden
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    hasType(notUsed) {
-        return this.createFromProps({
-            ...this.introspect()
-        });
-    }
-    /**
-     * @hidden
-     */
-    clearHasType() {
-        return this.createFromProps({
-            ...this.introspect()
-        });
-    }
-    /**
-     * Performs validion of Date schema over `object`.
-     * @param context Optional `ValidationContext` settings.
-     */
-    async validate(object, context) {
-        const superResult = await super.preValidate(object, context);
-        const { valid, context: prevalidationContext, errors } = superResult;
-        const { path } = prevalidationContext;
-        if (!valid) {
-            return {
-                valid,
-                errors
-            };
-        }
-        let { transaction: preValidationTransaction } = superResult;
-        let { object: { validatedObject: objToValidate } } = preValidationTransaction;
-        if ((typeof objToValidate === 'undefined' || objToValidate === null) &&
-            this.isRequired === false) {
-            return {
-                valid: true,
-                object: objToValidate
-            };
-        }
-        if (this.#parseFromJson) {
-            preValidationTransaction = transaction({
-                validatedObject: parseFromJsonPreprocessor(objToValidate)
-            });
-            objToValidate = preValidationTransaction.object.validatedObject;
-        }
-        if (this.#parseFromEpoch) {
-            preValidationTransaction = transaction({
-                validatedObject: parseFromEpochPreprocessor(objToValidate)
-            });
-            objToValidate = preValidationTransaction.object.validatedObject;
-        }
-        if (!(objToValidate instanceof Date))
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: `expected instance of Date, but saw ${typeof objToValidate}`,
-                        path: path
-                    }
-                ]
-            };
-        if (typeof this.#equalsTo !== 'undefined' &&
-            objToValidate.getTime() !== this.#equalsTo.getTime()) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: `is expected to be equal to ${this.#equalsTo}`,
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (this.#ensureIsInFuture && objToValidate <= new Date()) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: 'is expected to be in future',
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (this.#ensureIsInPast && objToValidate >= new Date()) {
-            return {
-                valid: false,
-                errors: [
-                    {
-                        message: 'is expected to be in past',
-                        path: path
-                    }
-                ]
-            };
-        }
-        if (typeof this.#min !== 'undefined') {
-            if (objToValidate < this.#min)
-                return {
-                    valid: false,
-                    errors: [
-                        {
-                            message: `expected to be at least ${this.#min}`,
-                            path: path
-                        }
-                    ]
-                };
-        }
-        if (typeof this.#max !== 'undefined') {
-            if (objToValidate > this.#max)
-                return {
-                    valid: false,
-                    errors: [
-                        {
-                            message: `expected to be no more than or equal to ${this.#max}`,
-                            path: path
-                        }
-                    ]
-                };
-        }
-        return {
-            valid: true,
-            object: preValidationTransaction.commit()
-                .validatedObject
-        };
-    }
-    /**
-     * @hidden
-     */
-    createFromProps(props) {
-        return DateSchemaBuilder.create(props);
-    }
-    /**
-     * Restricts Date to be equal to `value`.
-     */
-    equals(value) {
-        if (!(value instanceof Date))
-            throw new Error('Date expected');
-        return this.createFromProps({
-            ...this.introspect(),
-            equalsTo: value
-        });
-    }
-    /**
-     * Clears `equals()` call.
-     */
-    clearEquals() {
-        return this.createFromProps({
-            ...this.introspect(),
-            equalsTo: undefined
-        });
-    }
-    /**
-     * @hidden
-     */
-    required() {
-        return super.required();
-    }
-    /**
-     * @hidden
-     */
-    optional() {
-        return super.optional();
-    }
-    /**
-     * Accept only dates in the future.
-     */
-    isInFuture() {
-        return this.createFromProps({
-            ...this.introspect(),
-            ensureIsInFuture: true
-        });
-    }
-    /**
-     * Cancel `isInFuture()` call.
-     */
-    clearIsInFuture() {
-        return this.createFromProps({
-            ...this.introspect(),
-            ensureIsInFuture: false
-        });
-    }
-    /**
-     * Accept only dates in the past.
-     */
-    isInPast() {
-        return this.createFromProps({
-            ...this.introspect(),
-            ensureIsInPast: true
-        });
-    }
-    /**
-     * Cancel `isInPast()` call.
-     */
-    clearIsInPast() {
-        return this.createFromProps({
-            ...this.introspect(),
-            ensureIsInPast: false
-        });
-    }
-    /**
-     * Set minimal valid Date value for schema.
-     */
-    min(minValue) {
-        if (!(minValue instanceof Date))
-            throw new Error('minValue must be a Date');
-        return this.createFromProps({
-            ...this.introspect(),
-            min: minValue
-        });
-    }
-    /**
-     * Clear `min()` call.
-     */
-    clearMin() {
-        const schema = this.introspect();
-        delete schema.min;
-        return this.createFromProps({
-            ...schema
-        });
-    }
-    /**
-     * Set maximal valid Date value for schema.
-     */
-    max(maxValue) {
-        if (!(maxValue instanceof Date))
-            throw new Error('maxValue must be a Date');
-        return this.createFromProps({
-            ...this.introspect(),
-            max: maxValue
-        });
-    }
-    /**
-     * Clear `max()` call.
-     */
-    clearMax() {
-        const schema = this.introspect();
-        delete schema.max;
-        return this.createFromProps({
-            ...schema
-        });
-    }
-    /**
-     * Accepts JSON string as a valid Date.
-     * String must be in ISO format and will be parsed using `JSON.parse()`.
-     */
-    acceptJsonString() {
-        return this.createFromProps({
-            ...this.introspect(),
-            parseFromJson: true
-        });
-    }
-    /**
-     * Cancel `acceptJsonString()` call.
-     */
-    doNotAcceptJsonString() {
-        return this.createFromProps({
-            ...this.introspect(),
-            parseFromJson: false
-        });
-    }
-    /**
-     * Accepts epoch number as a valid Date.
-     * Epoch number will be parsed using `new Date(epoch)`.
-     */
-    acceptEpoch() {
-        return this.createFromProps({
-            ...this.introspect(),
-            parseFromEpoch: true
-        });
-    }
-    /**
-     * Cancel `acceptEpoch()` call.
-     */
-    doNotAcceptEpoch() {
-        return this.createFromProps({
-            ...this.introspect(),
-            parseFromEpoch: false
-        });
-    }
-}
-/**
- * Creates a Date schema.
- */
-export const date = () => DateSchemaBuilder.create({
-    isRequired: true
-});
+import{a,b}from"../chunk-YWBNVHR6.js";import"../chunk-CTP4RHDG.js";export{a as DateSchemaBuilder,b as date};
+//# sourceMappingURL=DateSchemaBuilder.js.map

package/dist/builders/DateSchemaBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/builders/ExternSchemaBuilder.d.ts

@@ -0,0 +1,200 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { type BRAND, SchemaBuilder, SYMBOL_HAS_PROPERTIES, type ValidationContext, type ValidationErrorMessageProvider, type ValidationResult } from './SchemaBuilder.js';
+type ExternSchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<ExternSchemaBuilder<any, R>['introspect']>> & {
+    standardSchema: StandardSchemaV1;
+};
+/**
+ * Schema builder that wraps an external
+ * [Standard Schema v1](https://standardschema.dev/) compatible schema
+ * (e.g. Zod, Valibot, ArkType) into a `@cleverbrush/schema` builder.
+ *
+ * This enables cross-library schema composition — you can use a Zod schema
+ * as a property inside a `@cleverbrush/schema` object schema, and the
+ * inferred TypeScript type will be correct.
+ *
+ * Validation is delegated entirely to the external schema's
+ * `['~standard'].validate()` method. Standard Schema issues are mapped to
+ * `@cleverbrush/schema` `ValidationError` objects, with any issue paths
+ * formatted as dotted prefixes (e.g. `"address.city: must be a string"`).
+ *
+ * When used inside an `object()` schema, the property descriptor tree is
+ * built dynamically (via Proxy) from the external schema's output type,
+ * so `getErrorsFor(t => t.order.id)` works without any additional
+ * configuration.
+ *
+ * **NOTE** this class is exported only to give opportunity to extend it
+ * by inheriting. It is not recommended to create an instance of this class
+ * directly. Use the {@link extern | extern()} factory function instead.
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod';
+ * import { object, date, extern, InferType } from '@cleverbrush/schema';
+ *
+ * const zodUser = z.object({ first: z.string(), last: z.string() });
+ *
+ * const order = object({
+ *   user: extern(zodUser),
+ *   date: date(),
+ * });
+ *
+ * type Order = InferType<typeof order>;
+ * // { user: { first: string; last: string }; date: Date }
+ * ```
+ *
+ * @see {@link extern}
+ */
+export declare class ExternSchemaBuilder<TStandardSchema extends StandardSchemaV1 = StandardSchemaV1, TRequired extends boolean = true, TNullable extends boolean = false, TExplicitType = undefined, THasDefault extends boolean = false, TExtensions = {}, TResult = TExplicitType extends undefined ? StandardSchemaV1.InferOutput<TStandardSchema> : TExplicitType> extends SchemaBuilder<TResult, TRequired, TNullable, THasDefault, TExtensions> {
+    #private;
+    /**
+     * Always `true` for extern schemas — enables Proxy-based property
+     * descriptor trees and nested error propagation in
+     * `ObjectSchemaBuilder`.
+     */
+    readonly [SYMBOL_HAS_PROPERTIES] = true;
+    /**
+     * @hidden
+     */
+    static create(props: ExternSchemaBuilderCreateProps<any>): ExternSchemaBuilder<StandardSchemaV1<unknown, unknown>, true, false, undefined, false, {}, unknown>;
+    protected constructor(props: ExternSchemaBuilderCreateProps<TRequired>);
+    /**
+     * Returns the wrapped Standard Schema instance.
+     */
+    get standardSchema(): TStandardSchema;
+    /**
+     * @inheritdoc
+     */
+    hasType<T>(_notUsed?: T): ExternSchemaBuilder<TStandardSchema, true, TNullable, T, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @inheritdoc
+     */
+    clearHasType(): ExternSchemaBuilder<TStandardSchema, TRequired, TNullable, undefined, THasDefault, TExtensions> & TExtensions;
+    /** {@inheritDoc SchemaBuilder.validate} */
+    validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
+    /** {@inheritDoc SchemaBuilder.validateAsync} */
+    validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    /**
+     * Performs synchronous validation by delegating to the external
+     * Standard Schema's `validate()` method.
+     *
+     * If the external schema returns a `Promise` (async validation),
+     * this method throws — use {@link validateAsync} instead.
+     */
+    protected _validate(object: TResult, context?: ValidationContext): ValidationResult<TResult>;
+    /**
+     * Performs async validation by delegating to the external
+     * Standard Schema's `validate()` method. Supports external schemas
+     * that return a `Promise` from their `validate()`.
+     */
+    protected _validateAsync(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    protected createFromProps<TReq extends boolean>(props: ExternSchemaBuilderCreateProps<TReq>): this;
+    /**
+     * Returns a snapshot of the builder's internal state.
+     * Includes the wrapped `standardSchema` reference.
+     */
+    introspect(): {
+        standardSchema: TStandardSchema;
+        type: string;
+        isRequired: boolean;
+        isNullable: boolean;
+        isReadonly: boolean;
+        preprocessors: readonly import("./SchemaBuilder.js").PreprocessorEntry<TResult>[];
+        validators: readonly import("./SchemaBuilder.js").ValidatorEntry<TResult>[];
+        requiredValidationErrorMessageProvider: ValidationErrorMessageProvider<SchemaBuilder<any, any, any, any, any>>;
+        extensions: {
+            [x: string]: unknown;
+        };
+        hasDefault: boolean;
+        defaultValue: TResult | (() => TResult) | undefined;
+        description: string | undefined;
+        hasCatch: boolean;
+        catchValue: TResult | (() => TResult) | undefined;
+    };
+    /**
+     * @hidden
+     */
+    required(errorMessage?: ValidationErrorMessageProvider): ExternSchemaBuilder<TStandardSchema, true, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    optional(): ExternSchemaBuilder<TStandardSchema, false, TNullable, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    default(value: TResult | (() => TResult)): ExternSchemaBuilder<TStandardSchema, true, TNullable, TExplicitType, true, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    clearDefault(): ExternSchemaBuilder<TStandardSchema, TRequired, TNullable, TExplicitType, false, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    brand<TBrand extends string | symbol>(_name?: TBrand): ExternSchemaBuilder<TStandardSchema, TRequired, TNullable, TResult & {
+        readonly [K in BRAND]: TBrand;
+    }, THasDefault, TExtensions> & TExtensions;
+    /**
+     * Marks the inferred type as `Readonly<T>`. Sets the `isReadonly`
+     * introspection flag for tooling consistency.
+     *
+     * @see {@link SchemaBuilder.readonly}
+     */
+    readonly(): ExternSchemaBuilder<TStandardSchema, TRequired, TNullable, Readonly<TResult>, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    nullable(): ExternSchemaBuilder<TStandardSchema, TRequired, true, TExplicitType, THasDefault, TExtensions> & TExtensions;
+    /**
+     * @hidden
+     */
+    notNullable(): ExternSchemaBuilder<TStandardSchema, TRequired, false, TExplicitType, THasDefault, TExtensions> & TExtensions;
+}
+/**
+ * Wraps an external [Standard Schema v1](https://standardschema.dev/)
+ * compatible schema into a `@cleverbrush/schema` builder.
+ *
+ * This enables cross-library schema composition — use schemas from Zod,
+ * Valibot, ArkType, or any Standard Schema v1 compliant library as
+ * properties inside `@cleverbrush/schema` object schemas with full type
+ * inference.
+ *
+ * @param standardSchema - A Standard Schema v1 compliant schema instance
+ *   (any object that exposes a `['~standard']` property with `version: 1`
+ *   and a `validate` function).
+ *
+ * @example
+ * ```ts
+ * import { z } from 'zod';
+ * import { object, date, extern, InferType } from '@cleverbrush/schema';
+ *
+ * const zodUser = z.object({ first: z.string(), last: z.string() });
+ *
+ * const order = object({
+ *   user: extern(zodUser),
+ *   date: date(),
+ * });
+ *
+ * type Order = InferType<typeof order>;
+ * // { user: { first: string; last: string }; date: Date }
+ *
+ * order.validate({
+ *   user: { first: 'Alice', last: 'Smith' },
+ *   date: new Date(),
+ * }); // { valid: true, object: { user: …, date: … } }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Optional external schema
+ * const schema = extern(zodUser).optional();
+ * schema.validate(undefined); // valid
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Inside an array
+ * import { array, extern } from '@cleverbrush/schema';
+ * const users = array(extern(zodUser));
+ * ```
+ */
+export declare const extern: <T extends StandardSchemaV1>(standardSchema: T) => ExternSchemaBuilder<T, true>;
+export {};

package/dist/builders/ExternSchemaBuilder.js

@@ -0,0 +1,2 @@
+import{a,b}from"../chunk-MKAYFPAR.js";import"../chunk-CTP4RHDG.js";export{a as ExternSchemaBuilder,b as extern};
+//# sourceMappingURL=ExternSchemaBuilder.js.map

package/dist/builders/ExternSchemaBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}