@cleverbrush/schema 1.0.0-beta.5 → 1.1.0

package/dist/builders/ObjectSchemaBuilder.js

@@ -1,344 +1,589 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.object = exports.ObjectSchemaBuilder = void 0;
-const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
-const defaultSchemas_js_1 = require("../defaultSchemas.js");
-class ObjectSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
-    type = 'object';
-    noUnknownProperties;
-    properties;
-    preprocessors;
-    clone() {
-        return ObjectSchemaBuilder.create({
-            isNullable: this._isNullable,
-            isRequired: this._isRequired,
-            noUnknownProperties: this.noUnknownProperties,
-            properties: this.properties,
-            preprocessor: this.preprocessor,
-            preprocessors: this.preprocessors,
-            validators: this.validators
+import { SchemaBuilder } from './SchemaBuilder.js';
+/**
+ * Object schema builder class. Similar to the `object` type
+ * in JS. Allows to define a schema for `object` value.
+ * Should be used to validate objects with specific properties.
+ * Properties should be defined as their own schema builders.
+ * You can use any `SchemaBuilder` e.g. `string()`, `number()`,
+ * `boolean()`, `array()`, `object()`, etc. to define properties.
+ * Which means that you can define nested objects and arrays of
+ * any complexity.
+ *
+ * **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 object | object()} function instead.
+ *
+ * @example
+ * ```ts
+ * const schema = object({
+ *    name: string(),
+ *    age: number()
+ * });
+ *
+ * const result = await schema.validate({
+ *   name: 'John',
+ *   age: 30
+ * });
+ *
+ * // result.valid === true
+ * // result.object === { name: 'John', age: 30 }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = object({
+ *   name: string(),
+ *   age: number().optional()
+ * });
+ *
+ * const result = await schema.validate({
+ *  name: 'John'
+ * });
+ * // result.valid === true
+ * // result.object === { name: 'John' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = object({
+ *  name: string(),
+ *  age: number();
+ * });
+ * const result = await schema.validate({
+ *  name: 'John'
+ * });
+ *
+ * // result.valid === false
+ * // result.errors[0].message === "is expected to have property 'age'"
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = object({
+ * name: string(),
+ * address: object({
+ *     city: string(),
+ *     country: string()
+ *   })
+ * });
+ * const result = await schema.validate({
+ * name: 'John',
+ * address: {
+ *    city: 'New York',
+ *    country: 'USA'
+ *  }
+ * });
+ * // result.valid === true
+ * // result.object === {
+ * //   name: 'John',
+ * //   address: {
+ * //     city: 'New York',
+ * //     country: 'USA'
+ * //   }
+ * // }
+ * ```
+ * @see {@link object}
+ */
+export class ObjectSchemaBuilder extends SchemaBuilder {
+    #properties = {};
+    #acceptUnknownProps = false;
+    static create(props) {
+        return new ObjectSchemaBuilder({
+            type: 'object',
+            ...props
         });
     }
-    get _schema() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const that = this;
-        return Object.assign({
-            type: this.type
-        }, this.getCommonSchema(), typeof that.properties !== 'undefined' && that.properties
-            ? {
-                properties: Object.keys(that.properties).reduce((acc, curr) => {
-                    if (!that.properties)
-                        return;
-                    if (that.properties[curr] instanceof SchemaBuilder_js_1.SchemaBuilder) {
-                        acc[curr] = that.properties[curr].clone();
-                    }
-                    else {
-                        acc[curr] = that.properties[curr];
-                    }
-                    return acc;
-                }, {})
+    createFromProps(props) {
+        return ObjectSchemaBuilder.create(props);
+    }
+    constructor(props) {
+        super(props);
+        if (typeof props.properties === 'object' && props.properties) {
+            this.#properties = props.properties;
+        }
+        if (typeof props.acceptUnknownProps === 'boolean') {
+            this.#acceptUnknownProps = props.acceptUnknownProps;
+        }
+    }
+    introspect() {
+        return {
+            ...super.introspect(),
+            /**
+             * Properties defined in schema
+             */
+            properties: { ...this.#properties },
+            /**
+             * If set to `true`, schema validation will not
+             * return errors if object contains fields which
+             * are not defined in the schema `properties`.
+             * Set to `false` by default
+             */
+            acceptUnknownProps: this.#acceptUnknownProps
+        };
+    }
+    /**
+     * @hidden
+     */
+    required() {
+        return super.required();
+    }
+    /**
+     * @hidden
+     */
+    optional() {
+        return super.optional();
+    }
+    /**
+     * Performs validion of object schema over the `object`.
+     * @param context Optional `ValidationContext` settings.
+     */
+    async validate(object, context) {
+        const prevalidatedResult = await super.preValidate(object, context);
+        const { valid, context: prevalidationContext, transaction: validationTransaction, errors: preValidationErrors } = prevalidatedResult;
+        const { path, doNotStopOnFirstError } = prevalidationContext;
+        let errors = prevalidatedResult.errors || [];
+        if (!valid && !doNotStopOnFirstError) {
+            return {
+                valid,
+                errors: preValidationErrors
+            };
+        }
+        const { object: { validatedObject: objToValidate } } = validationTransaction;
+        if (!this.isRequired &&
+            (typeof objToValidate === 'undefined' || objToValidate === null)) {
+            return {
+                valid: true,
+                object: validationTransaction.commit().validatedObject
+            };
+        }
+        if (typeof objToValidate !== 'object') {
+            errors.push({
+                message: 'must be an object',
+                path: path
+            });
+            if (!doNotStopOnFirstError) {
+                if (validationTransaction) {
+                    validationTransaction.rollback();
+                }
+                return {
+                    valid: false,
+                    errors: [errors[0]]
+                };
             }
-            : {}, typeof that.noUnknownProperties !== 'undefined'
-            ? { noUnknownProperties: that.noUnknownProperties }
-            : {}, typeof that.preprocessors !== 'undefined' && that.preprocessors
-            ? {
-                preprocessors: {
-                    ...that.preprocessors
+        }
+        const propKeys = Object.keys(this.#properties);
+        const objKeys = Object.keys(objToValidate);
+        if (propKeys.length === 0) {
+            if (objKeys.length === 0) {
+                if (doNotStopOnFirstError && errors.length > 0) {
+                    return {
+                        valid: false,
+                        errors
+                    };
                 }
+                if (validationTransaction) {
+                    validationTransaction.commit().validatedObject;
+                }
+                return {
+                    valid: true,
+                    object: {}
+                };
             }
-            : {});
-    }
-    constructor(obj) {
-        super(obj);
-        if (typeof obj === 'object' && obj) {
-            if (typeof obj.properties !== 'undefined') {
-                this.properties = Object.keys(obj.properties).reduce((acc, curr) => {
-                    if (obj.properties[curr] instanceof SchemaBuilder_js_1.SchemaBuilder) {
-                        acc[curr] = obj.properties[curr].clone();
-                    }
-                    else {
-                        acc[curr] = {
-                            ...obj.properties[curr]
-                        };
+        }
+        const validationResults = await Promise.all(propKeys.map(async (key) => ({
+            key,
+            result: await this.#properties[key].validate(objToValidate[key], {
+                ...context,
+                path: `${path}.${key}`
+            })
+        })));
+        const notValidResults = validationResults.filter((res) => !res.result.valid);
+        validationResults
+            .filter((res) => res.result.valid)
+            .forEach(({ key, result }) => {
+            objToValidate[key] = result.object;
+        });
+        errors = [
+            ...errors,
+            ...notValidResults.reduce((acc, val) => [...acc, ...(val?.result?.errors || [])], [])
+        ];
+        for (let i = 0; i < objKeys.length; i++) {
+            const key = objKeys[i];
+            if (!(key in this.#properties) && !this.#acceptUnknownProps) {
+                errors.push({
+                    message: `unknown property '${key}'`,
+                    path: path
+                });
+                if (!doNotStopOnFirstError) {
+                    if (validationTransaction) {
+                        validationTransaction.rollback();
                     }
-                    return acc;
-                }, {});
-            }
-            if (typeof obj.preprocessors !== 'undefined') {
-                this.preprocessors = { ...obj.preprocessors };
-            }
-            if (typeof obj.noUnknownProperties !== 'undefined') {
-                this.noUnknownProperties = obj.noUnknownProperties;
+                    return {
+                        valid: false,
+                        errors: [errors[0]]
+                    };
+                }
             }
         }
-        else {
-            const defaultSchema = defaultSchemas_js_1.defaultSchemas['object'];
-            this.isRequired = defaultSchema.isRequired;
-            this.isNullable = defaultSchema.isNullable;
+        if (notValidResults.length === 0 && errors.length === 0) {
+            const commited = validationTransaction.commit();
+            return {
+                valid: true,
+                object: commited.validatedObject
+            };
         }
+        validationTransaction.rollback();
+        return {
+            valid: false,
+            errors: doNotStopOnFirstError
+                ? errors
+                : errors[0]
+                    ? [errors[0]]
+                    : []
+        };
     }
-    static create(obj) {
-        return new ObjectSchemaBuilder(obj);
-    }
-    canHaveUnknownProps() {
-        if (this.noUnknownProperties === false) {
-            return this;
-        }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            noUnknownProperties: false
+    /**
+     * Fields not defined in `properties` will not be validated
+     * and will be passed through the validation.
+     */
+    acceptUnknownProps() {
+        return this.createFromProps({
+            ...this.introspect(),
+            acceptUnknownProps: true
         });
     }
-    noUnknownProps() {
-        if (this.noUnknownProperties === true) {
-            return this;
-        }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            noUnknownProperties: true
+    /**
+     * Fields not defined in `properties` will be considered
+     * as schema violation. This is the default behavior.
+     */
+    notAcceptUnknownProps() {
+        return this.createFromProps({
+            ...this.introspect(),
+            acceptUnknownProps: false
         });
     }
-    optional() {
-        if (this.isRequired === false) {
-            return this;
-        }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            isRequired: false
+    /**
+     * @hidden
+     */
+    hasType(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    notUsed) {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    required() {
-        if (this.isRequired === true) {
-            return this;
-        }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            isRequired: true
+    /**
+     * @hidden
+     */
+    clearHasType() {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    nullable() {
-        if (this.isNullable === true) {
-            return this;
+    /**
+     * Adds a new property to the object schema. The new property
+     * will be validated according to the provided schema.
+     * @param propName name of the new property
+     * @param schema schema builder of the new property
+     */
+    addProp(propName, schema) {
+        if (typeof propName !== 'string' || !propName) {
+            throw new Error('propName must be a non empty string');
         }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            isNullable: true
-        });
-    }
-    notNullable() {
-        if (this.isNullable === false) {
-            return this;
+        if (propName in this.#properties) {
+            throw new Error(`Property ${propName} already exists`);
         }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            isNullable: false
-        });
-    }
-    addProps(val) {
-        if (typeof val === 'undefined')
-            return this;
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
+        if (!(schema instanceof SchemaBuilder)) {
+            throw new Error('schema must be an instance of the SchemaBuilder class');
+        }
+        return this.createFromProps({
+            ...this.introspect(),
             properties: {
-                ...this.properties,
-                ...val
+                ...this.introspect().properties,
+                [propName]: schema
             }
         });
     }
-    removeProp(property) {
-        if (typeof this.properties === 'undefined') {
-            return this;
+    /**
+     * @hidden
+     * @deprecated this is for internal use, do not use if you are
+     * not sure you need it.
+     *
+     * TODO: This is used to avoid `&` in resulting types. For example,
+     * when you have a schema like `object({prop1: string()})` and then use `addProp({prop2: string()})` method,
+     * the resulting type without `optimize` will be something like `{prop1: string} & {prop2: string}`. Which
+     * is not we would like to have. Instead we want to have `{prop1: string, prop2: string}`. This is what
+     * `optimize` method does. However it is not always possible to do this optimization without losing
+     * JSDoc comments, which is sucks. For example, I had to disable optimization for UnionSchemas, because
+     * comments were lost. Hopefully it will be fixed in the future by Typescript team or somebody will
+     * find a workaround/fix and create a pull request.
+     */
+    optimize() {
+        return this.createFromProps({
+            ...this.introspect()
+        });
+    }
+    addProps(props) {
+        if (props instanceof ObjectSchemaBuilder) {
+            return this.addProps(props.introspect().properties);
         }
-        if (!(property in this.properties)) {
-            return this;
+        if (typeof props !== 'object') {
+            throw new Error('props should be an object');
         }
-        const newProperties = {
-            ...this.properties
-        };
-        delete newProperties[property];
-        let newPreprocessors = this.preprocessors;
-        if (typeof newPreprocessors !== 'undefined' &&
-            property in newPreprocessors) {
-            if (Object.keys(newPreprocessors).length === 1) {
-                newPreprocessors = undefined;
+        if (props === null) {
+            throw new Error('props should not be null');
+        }
+        const newProps = { ...this.#properties };
+        for (const key in props) {
+            if (key in this.#properties) {
+                throw new Error(`property '${key}' already exists`);
             }
-            else {
-                newPreprocessors = {
-                    ...this.preprocessors
-                };
-                delete newPreprocessors[property];
+            if (!(props[key] instanceof SchemaBuilder)) {
+                throw new Error(`${key} is not a SchemaBuilder`);
             }
+            newProps[key] = props[key];
         }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            preprocessors: newPreprocessors,
-            properties: newProperties
+        return this.createFromProps({
+            ...this.introspect(),
+            properties: newProps
         });
     }
-    setPropPreprocessor(property, validator) {
-        if (typeof this.preprocessors === 'undefined') {
-            this.preprocessors = {
-                [property]: validator
-            };
+    omit(propNameOrArrayOrPropsOrBuilder) {
+        if (typeof propNameOrArrayOrPropsOrBuilder === 'string') {
+            // remove one field
+            const propName = propNameOrArrayOrPropsOrBuilder;
+            if (!propName || !(propName in this.#properties)) {
+                throw new Error(`property ${propName.toString()} does not exists in the schema`);
+            }
+            return this.createFromProps({
+                ...this.introspect(),
+                properties: (() => {
+                    const result = { ...this.#properties };
+                    delete result[propName];
+                    return result;
+                })()
+            });
         }
-        else {
-            this.preprocessors = {
-                ...this.preprocessors,
-                [property]: validator
+        else if (Array.isArray(propNameOrArrayOrPropsOrBuilder)) {
+            const propsArray = propNameOrArrayOrPropsOrBuilder;
+            const distinctKeys = new Map();
+            propsArray.forEach((key) => {
+                if (typeof key !== 'string' || !key) {
+                    throw new Error('property name must be a string');
+                }
+                if (!(key in this.#properties)) {
+                    throw new Error(`property ${key.toString()} does not exists in the schema`);
+                }
+                distinctKeys.set(key.toString(), true);
+            });
+            if (distinctKeys.size === 0) {
+                throw new Error('please provide at least one property to omit');
+            }
+            const props = {
+                ...this.introspect()
             };
-        }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            preprocessors: {
-                ...this.preprocessors
+            for (const key of distinctKeys.keys()) {
+                delete props.properties[key];
             }
-        });
-    }
-    unsetPropPreprocessor(property) {
-        if (typeof this.preprocessors === 'undefined' ||
-            !(property in this.preprocessors)) {
-            return this;
+            return this.createFromProps(props);
         }
-        let newPreprocessors;
-        if (Object.keys(this.preprocessors).length === 1) {
-            newPreprocessors = undefined;
-        }
-        else {
-            newPreprocessors = {
-                ...this.preprocessors
+        else if (propNameOrArrayOrPropsOrBuilder instanceof ObjectSchemaBuilder) {
+            const propsToOmit = {
+                ...propNameOrArrayOrPropsOrBuilder.introspect().properties
+            };
+            const props = {
+                ...this.introspect()
             };
-            delete newPreprocessors[property];
+            for (const key in propsToOmit) {
+                if (key in props.properties) {
+                    delete props.properties[key];
+                }
+            }
+            return this.createFromProps(props);
         }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            preprocessors: newPreprocessors
-        });
+        throw new Error('this parameter type is not supported');
     }
-    clearPropsPreprocessors() {
-        if (typeof this.preprocessors === 'undefined') {
-            return this;
+    /**
+     * Adds all properties from `schema` to the current schema.
+     * `TSchema & TAnotherSchema` is a good example of the similar concept
+     * in the TS type system.
+     * @param schema an object schema to take properties from
+     */
+    intersect(schema) {
+        if (!(schema instanceof ObjectSchemaBuilder)) {
+            throw new Error('schema must be an instance of the ObjectSchemaBuilder class');
         }
-        return ObjectSchemaBuilder.create({
-            ...this._schema,
-            preprocessors: undefined
+        const remoteProps = schema.introspect().properties;
+        const localProps = this.introspect();
+        const newProps = Object.keys(localProps.properties).reduce((acc, curr) => {
+            acc[curr] =
+                curr in remoteProps ? remoteProps[curr] : localProps[curr];
+            return acc;
+        }, {});
+        return this.createFromProps({
+            ...this.introspect(),
+            properties: newProps
         });
     }
-    mapToType() {
-        return this;
-    }
-    clearMapToType() {
-        return this;
-    }
-    makeAllPropsOptional() {
-        let res = this;
-        for (const prop in this.properties) {
-            res = res.makePropOptional(prop);
-        }
-        return res;
-    }
-    makePropOptional(property) {
-        if (typeof this.properties[property] === 'undefined')
-            throw new Error(`Property ${property} does not exists`);
-        if (this.properties[property] instanceof SchemaBuilder_js_1.SchemaBuilder) {
-            return ObjectSchemaBuilder.create({
-                ...this._schema,
-                properties: {
-                    ...this.properties,
-                    [property]: this.properties[property].optional()
-                }
+    partial(propNameOrArray) {
+        if (typeof propNameOrArray === 'undefined' ||
+            propNameOrArray === null) {
+            return this.createFromProps({
+                ...this.introspect(),
+                properties: Object.keys(this.#properties).reduce((acc, key) => {
+                    acc[key] = this.#properties[key].optional();
+                    return acc;
+                }, {})
             });
         }
-        else {
-            return ObjectSchemaBuilder.create({
-                ...this._schema,
-                properties: {
-                    ...this.properties,
-                    [property]: {
-                        ...this.properties[property],
-                        isRequired: false
-                    }
+        if (Array.isArray(propNameOrArray)) {
+            const propsArray = propNameOrArray;
+            if (propsArray.length === 0) {
+                throw new Error('properties cannot be empty');
+            }
+            const newProps = {
+                ...this.introspect()
+            };
+            propsArray.forEach((key) => {
+                if (typeof key !== 'string') {
+                    throw new Error('each propery in property list must be as string value');
                 }
-            });
-        }
-    }
-    makePropRequired(property) {
-        if (typeof this.properties[property] === 'undefined')
-            throw new Error(`Property ${property} does not exists`);
-        if (this.properties[property] instanceof SchemaBuilder_js_1.SchemaBuilder) {
-            return ObjectSchemaBuilder.create({
-                ...this._schema,
-                properties: {
-                    ...this.properties,
-                    [property]: this.properties[property].required()
+                if (!(key in newProps.properties)) {
+                    throw new Error(`property ${key} does not exists`);
                 }
+                newProps.properties[key] =
+                    newProps.properties[key].optional();
             });
+            return this.createFromProps(newProps);
         }
-        else {
-            return ObjectSchemaBuilder.create({
-                ...this._schema,
-                properties: {
-                    ...this.properties,
-                    [property]: {
-                        ...this.properties[property],
-                        isRequired: true
-                    }
-                }
-            });
+        if (typeof propNameOrArray === 'string') {
+            return this.modifyPropSchema(propNameOrArray, (schema) => schema.optional());
         }
+        throw new Error('expecting string or string[] parameter');
     }
-    makePropNullable(property) {
-        if (typeof this.properties[property] === 'undefined')
-            throw new Error(`Property ${property} does not exists`);
-        if (this.properties[property] instanceof SchemaBuilder_js_1.SchemaBuilder) {
-            return ObjectSchemaBuilder.create({
-                ...this._schema,
+    pick(properties) {
+        if (typeof properties === 'string') {
+            const property = properties;
+            if (!property) {
+                throw new Error('property cannot be empty');
+            }
+            if (!(property in this.#properties)) {
+                throw new Error(`property ${property} does not exists`);
+            }
+            return this.createFromProps({
+                ...this.introspect(),
                 properties: {
-                    ...this.properties,
-                    [property]: this.properties[property].nullable()
+                    [property]: this.#properties[property]
                 }
             });
         }
-        else {
-            return ObjectSchemaBuilder.create({
-                ...this._schema,
-                properties: {
-                    ...this.properties,
-                    [property]: {
-                        ...this.properties[property],
-                        isNullable: true
-                    }
+        if (Array.isArray(properties)) {
+            if (properties.length === 0) {
+                throw new Error('properties must be a non empty erray');
+            }
+            const newProperties = properties.reduce((acc, curr) => {
+                if (typeof curr !== 'string' || !curr) {
+                    throw new Error('each property name must be a non empty string');
+                }
+                if (!(curr in this.#properties)) {
+                    throw new Error(`property ${curr} does not exists`);
                 }
+                acc[curr] = this.#properties[curr];
+                return acc;
+            }, {});
+            return this.createFromProps({
+                ...this.introspect(),
+                properties: newProperties
             });
         }
+        if (properties instanceof ObjectSchemaBuilder) {
+            const externalSchema = properties;
+            const props = Object.keys(externalSchema.introspect().properties).filter((p) => typeof this.#properties[p] !== 'undefined');
+            if (props.length === 0) {
+                throw new Error('there are no common properties in provided schemas');
+            }
+            return this.pick(props);
+        }
+        throw new Error('string, array or ObjectSchemaBuilder is expected');
     }
-    makePropNotNullable(property) {
-        if (typeof this.properties[property] === 'undefined')
-            throw new Error(`Property ${property} does not exists`);
-        if (this.properties[property] instanceof SchemaBuilder_js_1.SchemaBuilder) {
-            return ObjectSchemaBuilder.create({
-                ...this._schema,
-                properties: {
-                    ...this.properties,
-                    [property]: this.properties[property].notNullable()
-                }
-            });
+    /**
+     * Modify schema for `propName` and return a new schema.
+     * Could be useful if you want to leave all schema intact, but
+     * change a type of one property.
+     * @param propName name of the property (string)
+     * @param callback callback function returning a new schema fo the `propName`. As a first parameter
+     * you will receive an old schema for `propName`.
+     * @returns
+     */
+    modifyPropSchema(propName, callback) {
+        if (typeof propName !== 'string' || !propName) {
+            throw new Error('propName must be a non empty string');
         }
-        else {
-            return ObjectSchemaBuilder.create({
-                ...this._schema,
-                properties: {
-                    ...this.properties,
-                    [property]: {
-                        ...this.properties[property],
-                        isNullable: false
-                    }
-                }
-            });
+        if (!(propName in this.#properties)) {
+            throw new Error(`property ${propName} does not exists in the schema`);
+        }
+        if (typeof callback !== 'function') {
+            throw new Error('callback must be a function');
+        }
+        const callbackResult = callback(this.#properties[propName]);
+        if (!(callbackResult instanceof SchemaBuilder)) {
+            throw new Error('callback must return a SchemaBuilder object');
         }
+        const props = {
+            ...this.introspect()
+        };
+        props.properties = {
+            ...props.properties,
+            [propName]: callbackResult
+        };
+        return this.createFromProps(props);
+    }
+    /**
+     * An alias for `.partial(prop: string)`
+     * @param prop name of the property
+     */
+    makePropOptional(prop) {
+        return this.modifyPropSchema(prop, (builder) => builder.optional());
     }
+    /**
+     * Marks `prop` as required property.
+     * If `prop` does not exists in the current schema,
+     * an error will be thrown.
+     * @param prop name of the property
+     */
+    makePropRequired(prop) {
+        return this.modifyPropSchema(prop, (builder) => builder.required());
+    }
+    /**
+     * `Partial<T>` would be a good example of the
+     * same operation in the TS world.
+     */
+    makeAllPropsOptional() {
+        return this.createFromProps({
+            ...this.introspect(),
+            properties: Object.keys(this.#properties).reduce((acc, curr) => {
+                acc[curr] = this.#properties[curr].optional();
+                return acc;
+            }, {})
+        });
+    }
+    /**
+     * `Required<T>` would be a good example of the
+     * same operation in the TS world.
+     */
+    makeAllPropsRequired() {
+        return this.createFromProps({
+            ...this.introspect(),
+            properties: Object.keys(this.#properties).reduce((acc, curr) => {
+                acc[curr] = this.#properties[curr].required();
+                return acc;
+            }, {})
+        });
+    }
+}
+export function object(props) {
+    return ObjectSchemaBuilder.create({
+        isRequired: true,
+        properties: props
+    });
 }
-exports.ObjectSchemaBuilder = ObjectSchemaBuilder;
-const object = (properties) => typeof properties === 'undefined'
-    ? ObjectSchemaBuilder.create()
-    : ObjectSchemaBuilder.create().addProps(properties);
-exports.object = object;