@cleverbrush/schema 1.0.0-beta.4 → 1.0.0

package/dist/builders/DateSchemaBuilder.js

@@ -0,0 +1,433 @@
+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
+});

package/dist/builders/FunctionSchemaBuilder.d.ts

@@ -1,25 +1,61 @@
-import { Schema, Validator } from '../schema.js';
-import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
-export interface IFunctionSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false> extends ISchemaBuilder<TRequired, TNullable> {
-    optional(): IFunctionSchemaBuilder<false, TNullable>;
-    required(): IFunctionSchemaBuilder<true, TNullable>;
-    nullable(): IFunctionSchemaBuilder<TRequired, true>;
-    notNullable(): IFunctionSchemaBuilder<TRequired, false>;
-}
-export declare class FunctionSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false> extends SchemaBuilder<TRequired, TNullable> implements IFunctionSchemaBuilder<TRequired, TNullable> {
-    protected readonly type = "function";
-    get _schema(): Schema;
-    clone(): this;
-    static create<TRequired extends boolean = true, TNullable extends boolean = false>(obj?: {
-        isRequired: TRequired;
-        isNullable: TNullable;
-        validators?: Validator[];
-        preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
-    }): IFunctionSchemaBuilder<TRequired, TNullable>;
+import { SchemaBuilder, ValidationResult, ValidationContext } from './SchemaBuilder.js';
+type FunctionSchemaBuilderCreateProps<R extends boolean = true> = Partial<ReturnType<FunctionSchemaBuilder<R>['introspect']>>;
+/**
+ * Schema builder for functions. Allows to define a schema for a function.
+ * It can be: required or optional.
+ *
+ * **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 func | func()} function instead.
+ *
+ * @example
+ * ```ts
+ * const schema = func();
+ * const result = await schema.validate(() => {});
+ * // result.valid === true
+ * // result.object === () => {}
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = func().optional();
+ * const result = await schema.validate(undefined);
+ * // result.valid === true
+ * // result.object === undefined
+ * ```
+ *
+ * @see {@link func}
+ */
+export declare class FunctionSchemaBuilder<TRequired extends boolean = true, TExplicitType = undefined, TResult = TExplicitType extends undefined ? (...args: any[]) => any : TExplicitType> extends SchemaBuilder<TResult, TRequired> {
+    static create(props: FunctionSchemaBuilderCreateProps<any>): FunctionSchemaBuilder<true, undefined, (...args: any[]) => any>;
     private constructor();
-    optional(): IFunctionSchemaBuilder<false, TNullable>;
-    required(): IFunctionSchemaBuilder<true, TNullable>;
-    nullable(): IFunctionSchemaBuilder<TRequired, true>;
-    notNullable(): IFunctionSchemaBuilder<TRequired, false>;
+    /**
+     * @hidden
+     */
+    hasType<T>(notUsed?: T): FunctionSchemaBuilder<true, T>;
+    /**
+     * @hidden
+     */
+    clearHasType(): FunctionSchemaBuilder<TRequired, undefined>;
+    /**
+     * Performs validion of the schema over `object`. Basically runs
+     * validators, preprocessors and checks for required (if schema is not optional).
+     * @param context Optional `ValidationContext` settings.
+     */
+    validate(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    protected createFromProps<TReq extends boolean>(props: FunctionSchemaBuilderCreateProps<TReq>): this;
+    /**
+     * @hidden
+     */
+    required(): FunctionSchemaBuilder<true, TExplicitType>;
+    /**
+     * @hidden
+     */
+    optional(): FunctionSchemaBuilder<false, TExplicitType>;
 }
-export declare const func: () => IFunctionSchemaBuilder;
+/**
+ * Creates a `function` schema.
+ * @retuns {@link FunctionSchemaBuilder}
+ */
+export declare const func: () => FunctionSchemaBuilder<true, undefined, (...args: any[]) => any>;
+export {};

package/dist/builders/FunctionSchemaBuilder.js

@@ -1,66 +1,113 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.func = exports.FunctionSchemaBuilder = void 0;
-const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
-const defaultSchemas_js_1 = require("../defaultSchemas.js");
-class FunctionSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
-    type = 'function';
-    get _schema() {
-        return Object.assign({
-            type: this.type
-        }, this.getCommonSchema());
-    }
-    clone() {
-        return FunctionSchemaBuilder.create(this._schema);
+import { SchemaBuilder } from './SchemaBuilder.js';
+/**
+ * Schema builder for functions. Allows to define a schema for a function.
+ * It can be: required or optional.
+ *
+ * **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 func | func()} function instead.
+ *
+ * @example
+ * ```ts
+ * const schema = func();
+ * const result = await schema.validate(() => {});
+ * // result.valid === true
+ * // result.object === () => {}
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = func().optional();
+ * const result = await schema.validate(undefined);
+ * // result.valid === true
+ * // result.object === undefined
+ * ```
+ *
+ * @see {@link func}
+ */
+export class FunctionSchemaBuilder extends SchemaBuilder {
+    static create(props) {
+        return new FunctionSchemaBuilder({
+            type: 'function',
+            ...props
+        });
     }
-    static create(obj) {
-        return new FunctionSchemaBuilder(obj);
+    constructor(props) {
+        super(props);
     }
-    constructor(obj) {
-        super(obj);
-        if (typeof obj !== 'object' || !obj) {
-            const defaultSchema = defaultSchemas_js_1.defaultSchemas['function'];
-            this.isRequired = defaultSchema.isRequired;
-            this.isNullable = defaultSchema.isNullable;
-        }
-    }
-    optional() {
-        if (this.isRequired === false) {
-            return this;
-        }
-        return FunctionSchemaBuilder.create({
-            ...this._schema,
-            isRequired: false
+    /**
+     * @hidden
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hasType(notUsed) {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    required() {
-        if (this.isRequired === true) {
-            return this;
-        }
-        return FunctionSchemaBuilder.create({
-            ...this._schema,
-            isRequired: true
+    /**
+     * @hidden
+     */
+    clearHasType() {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    nullable() {
-        if (this.isNullable === true) {
-            return this;
+    /**
+     * Performs validion of the schema over `object`. Basically runs
+     * validators, preprocessors and checks for required (if schema is not optional).
+     * @param context Optional `ValidationContext` settings.
+     */
+    async validate(object, context) {
+        const superResult = await super.preValidate(object, context);
+        const { valid, context: prevalidationContext, transaction: preValidationTransaction, errors } = superResult;
+        const { path } = prevalidationContext;
+        if (!valid) {
+            return { valid, errors };
         }
-        return FunctionSchemaBuilder.create({
-            ...this._schema,
-            isNullable: true
-        });
-    }
-    notNullable() {
-        if (this.isNullable === false) {
-            return this;
+        const { object: { validatedObject: objToValidate } } = preValidationTransaction;
+        if ((typeof objToValidate === 'undefined' || objToValidate === null) &&
+            this.isRequired === false) {
+            return {
+                valid: true,
+                object: objToValidate
+            };
         }
-        return FunctionSchemaBuilder.create({
-            ...this._schema,
-            isNullable: false
-        });
+        if (typeof objToValidate !== 'function') {
+            return {
+                valid: false,
+                errors: [
+                    {
+                        message: `expected type function, but saw ${typeof objToValidate}`,
+                        path: path
+                    }
+                ]
+            };
+        }
+        return {
+            valid: true,
+            object: objToValidate
+        };
+    }
+    createFromProps(props) {
+        return FunctionSchemaBuilder.create(props);
+    }
+    /**
+     * @hidden
+     */
+    required() {
+        return super.required();
+    }
+    /**
+     * @hidden
+     */
+    optional() {
+        return super.optional();
     }
 }
-exports.FunctionSchemaBuilder = FunctionSchemaBuilder;
-const func = () => FunctionSchemaBuilder.create();
-exports.func = func;
+/**
+ * Creates a `function` schema.
+ * @retuns {@link FunctionSchemaBuilder}
+ */
+export const func = () => FunctionSchemaBuilder.create({
+    isRequired: true
+});