@cleverbrush/schema 1.1.11 → 2.0.0

package/dist/utils/transaction.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Options for customizing transaction behavior.
+ */
 export type TransactionOptions = {
     /**
      * An optional callback returning boolean. Called for every
@@ -12,6 +15,11 @@ export type TransactionOptions = {
      */
     shouldNotWrapWithTransaction?: (child: any) => boolean;
 };
+/**
+ * A transaction wrapper around an object. Provides copy-on-write semantics:
+ * modifications to `object` are isolated from the original until `commit()` is called.
+ * Use `rollback()` to discard changes, and `isDirty()` to check for pending modifications.
+ */
 export type Transaction<T> = {
     /**
      * Transaction object you can modify (equals to `initial` right after the call).
@@ -30,17 +38,32 @@ export type Transaction<T> = {
      */
     rollback: () => T;
     /**
-     * Returns `true` if there are any changes to `object` which makes is different from `initial`
+     * Returns `true` if there are any changes to `object` which make it different from `initial`.
      */
     isDirty: () => boolean;
 };
 /**
- * Starts transaction over the `initial` object.
+ * Starts a transaction over the `initial` object. The returned `object` is a
+ * proxy (for plain objects) or a shallow copy (for arrays) that tracks mutations
+ * without modifying `initial`. Call `commit()` to apply or `rollback()` to discard changes.
+ *
+ * @param initial - the object or array to wrap in a transaction
+ * @param options - optional configuration to control which nested values are wrapped
+ * @returns a {@link Transaction} with `object`, `commit`, `rollback`, and `isDirty` members
  */
 export declare const transaction: <T extends {}>(initial: T, options?: TransactionOptions) => Transaction<T>;
 /**
- * Checks if `obj` is instance of transaction
+ * Creates a lightweight no-op transaction that wraps the `initial` value
+ * without any Proxy or copy-on-write overhead.  `commit()` and `rollback()`
+ * simply return the original object, and `isDirty()` is always `false`.
+ *
+ * Use this when no preprocessors or validators are defined — there is no
+ * risk of mutation, so the full transaction machinery can be skipped.
+ */
+export declare const noopTransaction: <T extends {}>(initial: T) => Transaction<T>;
+/**
+ * Checks if `obj` is an instance of a transaction.
  * @param obj object to check if it's a transaction
- * @returns
+ * @returns `true` if `obj` is a transaction, `false` otherwise
  */
 export declare const isTransaction: (obj: any) => any;

package/package.json

@@ -10,13 +10,77 @@
     ],
     "homepage": "https://docs.cleverbrush.com/modules/_cleverbrush_schema.html",
     "keywords": [
-        "object schema validator",
         "schema",
-        "validate object",
+        "validation",
+        "typescript",
+        "type-safe",
+        "runtime-validation",
+        "zod-alternative",
+        "schema-validation",
+        "standard-schema",
         "cleverbrush"
     ],
     "license": "BSD 3-Clause",
     "main": "./dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./core": {
+            "types": "./dist/core.d.ts",
+            "import": "./dist/core.js"
+        },
+        "./string": {
+            "types": "./dist/builders/StringSchemaBuilder.d.ts",
+            "import": "./dist/builders/StringSchemaBuilder.js"
+        },
+        "./number": {
+            "types": "./dist/builders/NumberSchemaBuilder.d.ts",
+            "import": "./dist/builders/NumberSchemaBuilder.js"
+        },
+        "./boolean": {
+            "types": "./dist/builders/BooleanSchemaBuilder.d.ts",
+            "import": "./dist/builders/BooleanSchemaBuilder.js"
+        },
+        "./object": {
+            "types": "./dist/builders/ObjectSchemaBuilder.d.ts",
+            "import": "./dist/builders/ObjectSchemaBuilder.js"
+        },
+        "./array": {
+            "types": "./dist/builders/ArraySchemaBuilder.d.ts",
+            "import": "./dist/builders/ArraySchemaBuilder.js"
+        },
+        "./date": {
+            "types": "./dist/builders/DateSchemaBuilder.d.ts",
+            "import": "./dist/builders/DateSchemaBuilder.js"
+        },
+        "./any": {
+            "types": "./dist/builders/AnySchemaBuilder.d.ts",
+            "import": "./dist/builders/AnySchemaBuilder.js"
+        },
+        "./union": {
+            "types": "./dist/builders/UnionSchemaBuilder.d.ts",
+            "import": "./dist/builders/UnionSchemaBuilder.js"
+        },
+        "./tuple": {
+            "types": "./dist/builders/TupleSchemaBuilder.d.ts",
+            "import": "./dist/builders/TupleSchemaBuilder.js"
+        },
+        "./record": {
+            "types": "./dist/builders/RecordSchemaBuilder.d.ts",
+            "import": "./dist/builders/RecordSchemaBuilder.js"
+        },
+        "./function": {
+            "types": "./dist/builders/FunctionSchemaBuilder.d.ts",
+            "import": "./dist/builders/FunctionSchemaBuilder.js"
+        },
+        "./extern": {
+            "types": "./dist/builders/ExternSchemaBuilder.d.ts",
+            "import": "./dist/builders/ExternSchemaBuilder.js"
+        }
+    },
+    "sideEffects": false,
     "name": "@cleverbrush/schema",
     "readme": "https://github.com/cleverbrush/framework/tree/master/libs/schema#readme",
     "repository": {
@@ -24,13 +88,17 @@
         "url": "github:cleverbrush/framework"
     },
     "scripts": {
-        "watch": "tsc --watch",
-        "build": "tsc"
+        "watch": "tsc --build --watch",
+        "build": "tsup && tsc --project tsconfig.build.json --emitDeclarationOnly",
+        "clean": "rm -rf dist tsconfig.tsbuildinfo"
     },
     "type": "module",
     "types": "./dist/index.d.ts",
-    "version": "1.1.11",
+    "version": "2.0.0",
     "devDependencies": {
-        "@cleverbrush/deep": "1.1.11"
+        "@cleverbrush/deep": "^2.0.0"
+    },
+    "peerDependencies": {
+        "@standard-schema/spec": "^1.1.0"
     }
 }

package/dist/builders/SchemaBuilder.js

@@ -1,275 +0,0 @@
-import { transaction } from '../utils/transaction.js';
-/**
- * Base class for all schema builders. Provides basic functionality for schema building.
- *
- * **Note:** this class is not intended to be used directly, use one of the subclasses instead.
- * @typeparam TResult Type of the object that will be returned by `validate()` method.
- * @typeparam TRequired If `true`, object will be required. If `false`, object will be optional.
- */
-export class SchemaBuilder {
-    #isRequired = true;
-    #preprocessors = [];
-    #validators = [];
-    #type = 'base';
-    get type() {
-        return this.#type;
-    }
-    set type(value) {
-        if (typeof value !== 'string' || !value)
-            throw new Error('value should be non empty string');
-        this.#type = value;
-    }
-    /**
-     * A list of preprocessors associated with
-     * the Builder
-     */
-    get preprocessors() {
-        return this.#preprocessors;
-    }
-    /**
-     * A list of validators associated with
-     * the Builder
-     */
-    get validators() {
-        return this.#validators;
-    }
-    get isRequired() {
-        return this.#isRequired;
-    }
-    set isRequired(value) {
-        if (typeof value !== 'boolean')
-            throw new Error('should be a boolean value');
-        this.#isRequired = value;
-    }
-    async preValidate(
-    /**
-     * Object to validate
-     */
-    object, context) {
-        const { doNotStopOnFirstError } = context || {
-            doNotStopOnFirstError: false
-        };
-        let path = '$';
-        if (typeof context?.path === 'string' && context.path)
-            path = context.path;
-        const resultingContext = {
-            path,
-            doNotStopOnFirstError
-        };
-        let preprocessingTransaction = transaction({
-            validatedObject: object
-        });
-        let preprocessedObject = preprocessingTransaction.object.validatedObject;
-        let errors = [];
-        if (Array.isArray(this.preprocessors)) {
-            let currentPrepropIndex = 0;
-            for (const preprocessor of this.preprocessors) {
-                try {
-                    preprocessingTransaction = transaction({
-                        validatedObject: await Promise.resolve(preprocessor(preprocessedObject))
-                    });
-                    preprocessedObject =
-                        preprocessingTransaction.object.validatedObject;
-                }
-                catch (err) {
-                    errors.push({
-                        message: `Preprocessor #${currentPrepropIndex}${preprocessor.name ? ` (${preprocessor.name})` : ''} thrown an error: ${err.message}`,
-                        path: `${path}($preprocessors[${currentPrepropIndex}])`
-                    });
-                    if (!doNotStopOnFirstError) {
-                        preprocessingTransaction.rollback();
-                        return {
-                            valid: false,
-                            errors: [errors[0]].filter((e) => e),
-                            context: resultingContext
-                        };
-                    }
-                }
-                finally {
-                    currentPrepropIndex++;
-                }
-            }
-        }
-        if (Array.isArray(this.validators)) {
-            let currentValidatorIndex = 0;
-            for (const validator of this.validators) {
-                try {
-                    const { valid, errors: validatorErrors } = await Promise.resolve(validator(preprocessedObject));
-                    if (!valid) {
-                        errors = [
-                            ...errors,
-                            ...(Array.isArray(validatorErrors) &&
-                                validatorErrors.length
-                                ? validatorErrors.map((err) => ({
-                                    message: err.message,
-                                    path: `${path}($validators[${currentValidatorIndex}])`
-                                }))
-                                : [
-                                    {
-                                        message: `Validator #${currentValidatorIndex}${validator.name
-                                            ? ` (${validator.name})`
-                                            : ''} didn't pass.`,
-                                        path: `${path}($validators[${currentValidatorIndex}])`
-                                    }
-                                ])
-                        ];
-                        if (!doNotStopOnFirstError) {
-                            preprocessingTransaction.rollback();
-                            return {
-                                valid: false,
-                                errors: [errors[0]].filter((e) => e),
-                                context: resultingContext
-                            };
-                        }
-                    }
-                }
-                catch (err) {
-                    errors.push({
-                        message: `Validator #${currentValidatorIndex}${validator.name ? ` (${validator.name})` : ''} thrown an error: ${err.message}`,
-                        path: `${path}($validators[${currentValidatorIndex}])`
-                    });
-                    if (!doNotStopOnFirstError) {
-                        preprocessingTransaction.rollback();
-                        return {
-                            valid: false,
-                            errors: [errors[0]].filter((e) => e),
-                            context: resultingContext
-                        };
-                    }
-                }
-                finally {
-                    currentValidatorIndex++;
-                }
-            }
-        }
-        if (this.isRequired &&
-            (typeof preprocessedObject === 'undefined' ||
-                preprocessedObject === null)) {
-            errors.push({
-                message: 'is required',
-                path
-            });
-            if (!doNotStopOnFirstError) {
-                preprocessingTransaction.rollback();
-                return {
-                    valid: false,
-                    errors: [errors[0]],
-                    context: resultingContext
-                };
-            }
-        }
-        if (errors.length > 0) {
-            return {
-                valid: false,
-                errors: errors
-                    .filter((e) => e)
-                    .filter((e, i) => (doNotStopOnFirstError ? true : i === 0)),
-                context: resultingContext,
-                transaction: preprocessingTransaction
-            };
-        }
-        return {
-            valid: true,
-            context: resultingContext,
-            transaction: preprocessingTransaction
-        };
-    }
-    /**
-     * Generates a serializable object describing the defined schema
-     */
-    introspect() {
-        return {
-            /**
-             * String `id` of schema type, e.g. `string', `number` or `object`.
-             */
-            type: this.type,
-            /**
-             * If set to `false`, schema will be optional (`null` or `undefined` values
-             * will be considered as valid).
-             */
-            isRequired: this.#isRequired,
-            /**
-             * Array of preprocessor functions
-             */
-            preprocessors: [
-                ...this.preprocessors
-            ],
-            /**
-             * Array of validator functions
-             */
-            validators: [...this.validators]
-        };
-    }
-    /**
-     * Makes schema optional (consider `null` and `undefined` as valid objects for this schema)
-     */
-    optional() {
-        return this.createFromProps({
-            ...this.introspect(),
-            isRequired: false
-        });
-    }
-    /**
-     * Makes schema required (consider `null` and `undefined` as invalid objects for this schema)
-     */
-    required() {
-        return this.createFromProps({
-            ...this.introspect(),
-            isRequired: true
-        });
-    }
-    /**
-     * Adds a `preprocessor` to a preprocessors list
-     */
-    addPreprocessor(preprocessor) {
-        if (typeof preprocessor !== 'function') {
-            throw new Error('preprocessor must be a function');
-        }
-        return this.createFromProps({
-            ...this.introspect(),
-            preprocessors: [...this.preprocessors, preprocessor]
-        });
-    }
-    /**
-     * Remove all preprocessors for this schema.
-     */
-    clearPreprocessors() {
-        return this.createFromProps({
-            ...this.introspect(),
-            preprocessors: []
-        });
-    }
-    /**
-     * Adds a `validator` to validators list.
-     */
-    addValidator(validator) {
-        if (typeof validator !== 'function') {
-            throw new Error('validator must be a function');
-        }
-        return this.createFromProps({
-            ...this.introspect(),
-            validators: [...this.validators, validator]
-        });
-    }
-    /**
-     * Remove all validators for this schema.
-     */
-    clearValidators() {
-        return this.createFromProps({
-            ...this.introspect(),
-            validators: []
-        });
-    }
-    constructor(props) {
-        const { type, preprocessors, validators, isRequired } = props;
-        this.type = type;
-        if (typeof isRequired === 'boolean')
-            this.isRequired = isRequired;
-        if (Array.isArray(preprocessors)) {
-            this.#preprocessors = [...preprocessors];
-        }
-        if (Array.isArray(validators)) {
-            this.#validators = [...validators];
-        }
-    }
-}

package/dist/utils/transaction.js

@@ -1,178 +0,0 @@
-const TRANSACTION_SYMBOL = Symbol('transaction');
-const defaultNonTransactionalTypes = [Error, RegExp, Date];
-const defaultTransactionOptions = {
-    shouldNotWrapWithTransaction: (child) => !!defaultNonTransactionalTypes.find((t) => child instanceof t)
-};
-/**
- * Starts transaction over the `initial` object.
- */
-export const transaction = (initial, options) => {
-    let newProperties = {};
-    let deletedProperties = new Map();
-    options = Object.assign({}, defaultTransactionOptions, options || {});
-    const { shouldNotWrapWithTransaction } = options;
-    const isDirty = () => !!Object.keys(newProperties).find((key) => {
-        if (newProperties[key] && newProperties[key][TRANSACTION_SYMBOL]) {
-            return newProperties[key][TRANSACTION_SYMBOL].isDirty();
-        }
-        return true;
-    }) || (deletedProperties.size > 0);
-    const commit = () => {
-        const result = {};
-        Object.keys(initial).forEach((key) => {
-            result[key] = initial[key];
-        });
-        Object.keys(newProperties).forEach((key) => {
-            const value = newProperties[key];
-            if (value[TRANSACTION_SYMBOL]) {
-                const { commit: childCommit } = value[TRANSACTION_SYMBOL];
-                result[key] = childCommit();
-            }
-            else {
-                result[key] = newProperties[key];
-            }
-        });
-        for (const key of deletedProperties.keys()) {
-            delete result[key];
-        }
-        newProperties = {};
-        deletedProperties = new Map();
-        return result;
-    };
-    const rollback = () => {
-        for (const key in newProperties) {
-            const value = newProperties[key];
-            if (value &&
-                typeof value === 'object' &&
-                value[TRANSACTION_SYMBOL]) {
-                // this is nested transaction, let's rollback it as well
-                value[TRANSACTION_SYMBOL].rollback();
-            }
-        }
-        newProperties = {};
-        deletedProperties = new Map();
-        return initial;
-    };
-    if (Array.isArray(initial)) {
-        const result = initial.map((el) => typeof el === 'object' && el && !shouldNotWrapWithTransaction(el)
-            ? transaction(el).object
-            : el);
-        const commitArray = () => result.map((el) => el && typeof el[TRANSACTION_SYMBOL] === 'object'
-            ? el[TRANSACTION_SYMBOL].commit()
-            : el);
-        const isDirtyArray = () => {
-            return !!result.find((val, index) => {
-                if (val && typeof val[TRANSACTION_SYMBOL] === 'object') {
-                    return val[TRANSACTION_SYMBOL].isDirty();
-                }
-                return result[index] !== initial[index];
-            });
-        };
-        Object.defineProperty(result, TRANSACTION_SYMBOL, {
-            writable: false,
-            configurable: false,
-            value: {
-                initial,
-                object: result,
-                commit: commitArray,
-                rollback: () => initial,
-                isDirty: isDirtyArray
-            }
-        });
-        return {
-            object: result,
-            commit: commitArray,
-            rollback: () => initial,
-            isDirty: isDirtyArray
-        };
-    }
-    const proxy = new Proxy(initial, {
-        set: (target, property, value) => {
-            if (target && target[property] === value) {
-                delete newProperties[property];
-                return true;
-            }
-            newProperties[property] = value;
-            deletedProperties.delete(property);
-            return true;
-        },
-        ownKeys: (target) => {
-            return [
-                ...Object.keys(target).filter((k) => !deletedProperties.has(k)),
-                ...Object.keys(newProperties).filter((k) => !(k in target))
-            ];
-        },
-        getOwnPropertyDescriptor: (target, prop) => {
-            if (deletedProperties.has(prop)) {
-                return undefined;
-            }
-            if (prop in newProperties) {
-                return Object.getOwnPropertyDescriptor(newProperties, prop);
-            }
-            return Object.getOwnPropertyDescriptor(target, prop);
-        },
-        has: (target, prop) => {
-            if (deletedProperties.has(prop)) {
-                return false;
-            }
-            if (prop in newProperties) {
-                return true;
-            }
-            return prop in target;
-        },
-        get: (target, prop) => {
-            if (typeof prop === 'symbol') {
-                if (prop === TRANSACTION_SYMBOL) {
-                    return {
-                        initial,
-                        object: proxy,
-                        commit,
-                        rollback,
-                        isDirty
-                    };
-                }
-                return target[prop];
-            }
-            if (prop in newProperties) {
-                return newProperties[prop];
-            }
-            if (deletedProperties.has(prop)) {
-                return undefined;
-            }
-            if (!isTransaction(target[prop]) &&
-                typeof target[prop] === 'object' &&
-                target[prop] &&
-                !shouldNotWrapWithTransaction(target[prop])) {
-                const { object } = transaction(target[prop], options);
-                newProperties[prop] = object;
-                return object;
-            }
-            return target[prop];
-        },
-        deleteProperty: (target, p) => {
-            if (p in newProperties) {
-                if (newProperties[p] &&
-                    typeof newProperties[p][TRANSACTION_SYMBOL] === 'object') {
-                    newProperties[p][TRANSACTION_SYMBOL].rollback();
-                }
-                delete newProperties[p];
-            }
-            if (p in target) {
-                deletedProperties.set(p, true);
-            }
-            return true;
-        }
-    });
-    return {
-        object: proxy,
-        commit,
-        rollback,
-        isDirty
-    };
-};
-/**
- * Checks if `obj` is instance of transaction
- * @param obj object to check if it's a transaction
- * @returns
- */
-export const isTransaction = (obj) => obj && typeof obj === 'object' && Object.hasOwn(obj, TRANSACTION_SYMBOL);