@cleverbrush/schema 1.0.0-beta.4 → 1.0.0

package/dist/builders/BooleanSchemaBuilder.js

@@ -1,90 +1,150 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.boolean = exports.BooleanSchemaBuilder = void 0;
-const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
-const defaultSchemas_js_1 = require("../defaultSchemas.js");
-class BooleanSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
-    type = 'boolean';
-    get _schema() {
-        return Object.assign({
-            type: this.type
-        }, this.getCommonSchema(), typeof this._equals !== 'undefined' ? { equals: this._equals } : {});
-    }
-    clone() {
-        return BooleanSchemaBuilder.create(this._schema);
-    }
-    static create(obj) {
-        return new BooleanSchemaBuilder(obj);
+import { SchemaBuilder } from './SchemaBuilder.js';
+/**
+ * Similar to `boolean` type in TypeScript.
+ * Allows to define a schema for a boolean value. It can be required or optional.
+ * It can be restricted to be equal to a certain value.
+ *
+ * **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 boolean | boolean()} function instead.
+ *
+ * @example ```ts
+ * const schema = boolean().equals(true);
+ * const result = await schema.validate(true);
+ * // result.valid === true
+ * // result.object === true
+ * ```
+ * @example ```ts
+ * const schema = boolean().equals(false);
+ * const result = await schema.validate(true);
+ * // result.valid === false
+ * // result.errors[0].message === 'is expected to be equal to 'false''
+ * ```
+ * @example ```ts
+ * const schema = boolean().equals(true).optional();
+ * const result = await schema.validate(undefined);
+ * // result.valid === true
+ * // result.object === undefined
+ * ```
+ *
+ * @see {@link boolean}
+ */
+export class BooleanSchemaBuilder extends SchemaBuilder {
+    #equalsTo;
+    static create(props) {
+        return new BooleanSchemaBuilder({
+            type: 'boolean',
+            ...props
+        });
     }
-    constructor(obj) {
-        super(obj);
-        if (typeof obj === 'object' && obj) {
-            if (typeof obj.equals !== 'undefined') {
-                this._equals = obj.equals;
-            }
-        }
-        else {
-            const defaultSchema = defaultSchemas_js_1.defaultSchemas['boolean'];
-            this.isRequired = defaultSchema.isRequired;
-            this.isNullable = defaultSchema.isNullable;
+    constructor(props) {
+        super(props);
+        if (typeof props.equalsTo === 'boolean' ||
+            typeof props.equalsTo === 'undefined') {
+            this.#equalsTo = props.equalsTo;
         }
     }
-    _equals;
-    equals(val) {
-        if (this._equals === val) {
-            return this;
-        }
-        return BooleanSchemaBuilder.create({
-            ...this._schema,
-            equals: val
+    introspect() {
+        return {
+            ...super.introspect(),
+            /**
+             * If set, restrict object to be equal to a certain value.
+             */
+            equalsTo: this.#equalsTo
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hasType(notUsed) {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    clearEqualsTo() {
-        if (typeof this._equals === 'undefined') {
-            return this;
-        }
-        return BooleanSchemaBuilder.create({
-            ...this._schema,
-            equals: undefined
+    clearHasType() {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    optional() {
-        if (this.isRequired === false) {
-            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 BooleanSchemaBuilder.create({
-            ...this._schema,
-            isRequired: false
-        });
+        const { object: { validatedObject: objToValidate } } = preValidationTransaction;
+        if ((typeof objToValidate === 'undefined' || objToValidate === null) &&
+            this.isRequired === false) {
+            return {
+                valid: true,
+                object: objToValidate
+            };
+        }
+        if (typeof objToValidate !== 'boolean') {
+            return {
+                valid: false,
+                errors: [
+                    {
+                        message: 'expected to be boolean',
+                        path: path
+                    }
+                ]
+            };
+        }
+        if (typeof this.#equalsTo !== 'undefined' &&
+            objToValidate !== this.#equalsTo) {
+            return {
+                valid: false,
+                errors: [
+                    {
+                        message: `is expected to be equal to '${this.#equalsTo}'`,
+                        path: path
+                    }
+                ]
+            };
+        }
+        return {
+            valid: true,
+            object: objToValidate
+        };
+    }
+    createFromProps(props) {
+        return BooleanSchemaBuilder.create(props);
     }
     required() {
-        if (this.isRequired === true) {
-            return this;
-        }
-        return BooleanSchemaBuilder.create({
-            ...this._schema,
-            isRequired: true
-        });
+        return super.required();
     }
-    nullable() {
-        if (this.isNullable === true) {
-            return this;
-        }
-        return BooleanSchemaBuilder.create({
-            ...this._schema,
-            isNullable: true
+    optional() {
+        return super.optional();
+    }
+    /**
+     * Restricts object to be equal to `value`.
+     */
+    equals(value) {
+        if (typeof value !== 'boolean')
+            throw new Error('boolean expected');
+        return this.createFromProps({
+            ...this.introspect(),
+            equalsTo: value
         });
     }
-    notNullable() {
-        if (this.isNullable === false) {
-            return this;
-        }
-        return BooleanSchemaBuilder.create({
-            ...this._schema,
-            isNullable: false
+    /**
+     * Removes a `value` defeined by `equals()` call.
+     */
+    clearEquals() {
+        return this.createFromProps({
+            ...this.introspect(),
+            equalsTo: undefined
         });
     }
 }
-exports.BooleanSchemaBuilder = BooleanSchemaBuilder;
-const boolean = () => BooleanSchemaBuilder.create();
-exports.boolean = boolean;
+/**
+ * Creates a `boolean` schema.
+ */
+export const boolean = () => BooleanSchemaBuilder.create({
+    isRequired: true
+});

package/dist/builders/DateSchemaBuilder.d.ts

@@ -0,0 +1,177 @@
+import { Preprocessor, SchemaBuilder, ValidationResult, ValidationContext, Validator } from './SchemaBuilder.js';
+type DateSchemaBuilderCreateProps<T = Date, R extends boolean = true> = Partial<ReturnType<DateSchemaBuilder<T, R>['introspect']>>;
+/**
+ * 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 declare class DateSchemaBuilder<TResult = Date, TRequired extends boolean = true> extends SchemaBuilder<TResult, TRequired> {
+    #private;
+    static create(props: DateSchemaBuilderCreateProps): DateSchemaBuilder<Date, true>;
+    private constructor();
+    introspect(): {
+        /**
+         * Min valid value (if defined).
+         */
+        min: Date | undefined;
+        /**
+         * Max valid value (if defined).
+         */
+        max: Date | undefined;
+        /**
+         * Make sure that date is in future. `false` by default.
+         */
+        ensureIsInFuture: boolean;
+        /**
+         * Make sure that date is in past. `false` by default.
+         */
+        ensureIsInPast: boolean;
+        /**
+         * If set, restrict date to be equal to a certain value.
+         */
+        equalsTo: Date | undefined;
+        /**
+         * If set, schema will try to parse date from the UNIX epoch (number).
+         * `false` by default.
+         */
+        parseFromEpoch: boolean;
+        /**
+         * If set, schema will try to parse date from JSON string.
+         * `false` by default.
+         */
+        parseFromJson: boolean;
+        /**
+         * Array of preprocessor functions
+         */
+        preprocessors: Preprocessor<TResult>[];
+        /**
+         * Array of validator functions
+         */
+        validators: Validator<TResult>[];
+        type: string;
+        isRequired: boolean;
+    };
+    /**
+     * @hidden
+     */
+    hasType<T>(notUsed?: T): DateSchemaBuilder<T, true>;
+    /**
+     * @hidden
+     */
+    clearHasType(): DateSchemaBuilder<Date, TRequired>;
+    /**
+     * Performs validion of Date schema over `object`.
+     * @param context Optional `ValidationContext` settings.
+     */
+    validate(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    /**
+     * @hidden
+     */
+    protected createFromProps<T, TReq extends boolean>(props: DateSchemaBuilderCreateProps<T, TReq>): this;
+    /**
+     * Restricts Date to be equal to `value`.
+     */
+    equals<T extends Date>(value: T): DateSchemaBuilder<T, TRequired>;
+    /**
+     * Clears `equals()` call.
+     */
+    clearEquals(): DateSchemaBuilder<Date, TRequired>;
+    /**
+     * @hidden
+     */
+    required(): DateSchemaBuilder<TResult, true>;
+    /**
+     * @hidden
+     */
+    optional(): DateSchemaBuilder<TResult, false>;
+    /**
+     * Accept only dates in the future.
+     */
+    isInFuture(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Cancel `isInFuture()` call.
+     */
+    clearIsInFuture(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Accept only dates in the past.
+     */
+    isInPast(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Cancel `isInPast()` call.
+     */
+    clearIsInPast(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Set minimal valid Date value for schema.
+     */
+    min(minValue: Date): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Clear `min()` call.
+     */
+    clearMin(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Set maximal valid Date value for schema.
+     */
+    max(maxValue: Date): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Clear `max()` call.
+     */
+    clearMax(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Accepts JSON string as a valid Date.
+     * String must be in ISO format and will be parsed using `JSON.parse()`.
+     */
+    acceptJsonString(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Cancel `acceptJsonString()` call.
+     */
+    doNotAcceptJsonString(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Accepts epoch number as a valid Date.
+     * Epoch number will be parsed using `new Date(epoch)`.
+     */
+    acceptEpoch(): DateSchemaBuilder<TResult, TRequired>;
+    /**
+     * Cancel `acceptEpoch()` call.
+     */
+    doNotAcceptEpoch(): DateSchemaBuilder<TResult, TRequired>;
+}
+/**
+ * Creates a Date schema.
+ */
+export declare const date: () => DateSchemaBuilder<Date, true>;
+export {};