@cleverbrush/schema 1.0.0-beta.5 → 1.0.0

package/dist/builders/NumberSchemaBuilder.js

@@ -1,206 +1,386 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.number = exports.NumberSchemaBuilder = void 0;
-const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
-const defaultSchemas_js_1 = require("../defaultSchemas.js");
-class NumberSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
-    clone() {
-        return NumberSchemaBuilder.create(this._schema);
-    }
-    get _schema() {
-        return Object.assign({
-            type: this.type,
-            ensureNotNaN: this._ensureNotNaN,
-            ensureIsFinite: this._ensureIsFinite
-        }, this.getCommonSchema(), typeof this._min !== 'undefined' ? { min: this._min } : {}, typeof this._max !== 'undefined' ? { max: this._max } : {}, typeof this._isInteger !== 'undefined'
-            ? { isInteger: this._isInteger }
-            : {}, typeof this._equals !== 'undefined' ? { equals: this._equals } : {});
-    }
-    static create(obj) {
-        return new NumberSchemaBuilder(obj);
-    }
-    constructor(obj) {
-        super(obj);
-        if (typeof obj === 'object' && obj) {
-            if (typeof obj.min !== 'undefined') {
-                this._min = obj.min;
-            }
-            if (typeof obj.max !== 'undefined') {
-                this._max = obj.max;
-            }
-            if (typeof obj.isInteger !== 'undefined') {
-                this._isInteger = obj.isInteger;
-            }
-            if (typeof obj.ensureNotNaN !== 'undefined') {
-                this._ensureNotNaN = obj.ensureNotNaN;
-            }
-            if (typeof obj.ensureIsFinite !== 'undefined') {
-                this._ensureIsFinite = obj.ensureIsFinite;
-            }
-            if (typeof obj.equals !== 'undefined') {
-                this._equals = obj.equals;
-            }
+import { SchemaBuilder } from './SchemaBuilder.js';
+/**
+ * Number schema builder class. Allows to create Number schemas.
+ * Can be required or optional, can be restricted to be equal to a certain value,
+ * can be restricted to be in a certain range, can be restricted to be integer.
+ *
+ * **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 number | number()} function instead.
+ *
+ * @example ```ts
+ * const schema = number().equals(42);
+ * const result = await schema.validate(42);
+ * // result.valid === true
+ * // result.object === 42
+ * ```
+ * @example ```ts
+ * const schema = number();
+ * const result = await schema.validate('42');
+ * // result.valid === false
+ * // result.errors[0].message === 'is expected to be a number'
+ * ```
+ * @example ```ts
+ * const schema = number().min(0).max(100);
+ * const result = await schema.validate(42);
+ * // result.valid === true
+ * // result.object === 42
+ * ```
+ *
+ * @example ```ts
+ * const schema = number().min(0).max(100);
+ * const result = await schema.validate(142.5);
+ * // result.valid === false
+ * // result.errors[0].message === 'is expected to be less than or equal to 100'
+ * ```
+ *
+ * @see {@link number}
+ */
+export class NumberSchemaBuilder extends SchemaBuilder {
+    #min;
+    #max;
+    #equalsTo;
+    #ensureNotNaN = true;
+    #ensureIsFinite = true;
+    #isInteger = true;
+    static create(props) {
+        return new NumberSchemaBuilder({
+            type: 'number',
+            ...props
+        });
+    }
+    constructor(props) {
+        super(props);
+        if (typeof props.min === 'number') {
+            this.#min = props.min;
         }
-        else {
-            const defaultSchema = defaultSchemas_js_1.defaultSchemas['number'];
-            this.isRequired = defaultSchema.isRequired;
-            this.isNullable = defaultSchema.isNullable;
-            this._ensureNotNaN = defaultSchema.ensureNotNaN;
-            this._ensureIsFinite = defaultSchema.ensureIsFinite;
+        if (typeof props.max === 'number') {
+            this.#max = props.max;
         }
-    }
-    type = 'number';
-    _min;
-    _max;
-    _isInteger;
-    _ensureNotNaN = true;
-    _ensureIsFinite = true;
-    _equals;
-    min(val) {
-        if (this._min === val) {
-            return this;
+        if (typeof props.ensureNotNaN === 'boolean') {
+            this.#ensureNotNaN = props.ensureNotNaN;
         }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            min: val
-        });
-    }
-    clearMin() {
-        if (typeof this._min === 'undefined') {
-            return this;
+        if (typeof props.ensureIsFinite === 'boolean') {
+            this.#ensureIsFinite = props.ensureIsFinite;
         }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            min: undefined
-        });
-    }
-    max(val) {
-        if (this._max === val) {
-            return this;
+        if (typeof props.isInteger === 'boolean') {
+            this.#isInteger = props.isInteger;
         }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            max: val
-        });
-    }
-    clearMax() {
-        if (typeof this._max === 'undefined') {
-            return this;
+        if (typeof props.equalsTo === 'number' ||
+            typeof props.equalsTo === 'undefined') {
+            this.#equalsTo = props.equalsTo;
         }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            max: undefined
-        });
     }
-    optional() {
-        if (this.isRequired === false) {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            isRequired: false
-        });
+    introspect() {
+        return {
+            ...super.introspect(),
+            /**
+             * Min valid value (if defined).
+             */
+            min: this.#min,
+            /**
+             * Max valid value (if defined).
+             */
+            max: this.#max,
+            /**
+             * Make sure that object is not `NaN`. `true` by default.
+             */
+            ensureNotNaN: this.#ensureNotNaN,
+            /**
+             * Make sure that object is not different kinds of `infinity`. `true` by default.
+             */
+            ensureIsFinite: this.#ensureIsFinite,
+            /**
+             * If set, restrict object to be equal to a certain value.
+             */
+            equalsTo: this.#equalsTo,
+            /**
+             * Allow only integer values (floating point values will be rejected
+             * as invalid)
+             */
+            isInteger: this.#isInteger,
+            /**
+             * Array of preprocessor functions
+             */
+            preprocessors: this.preprocessors,
+            /**
+             * Array of validator functions
+             */
+            validators: this.validators
+        };
     }
-    required() {
-        if (this.isRequired === true) {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            isRequired: true
+    /**
+     * @hidden
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    hasType(notUsed) {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    nullable() {
-        if (this.isNullable === true) {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            isNullable: true
+    /**
+     * @hidden
+     */
+    clearHasType() {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    notNullable() {
-        if (this.isNullable === false) {
-            return this;
+    /**
+     * Performs validion of number schema over `object`.
+     * @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 NumberSchemaBuilder.create({
-            ...this._schema,
-            isNullable: false
-        });
-    }
-    equals(val) {
-        if (this._equals === val) {
-            return this;
+        const { object: { validatedObject: objToValidate } } = preValidationTransaction;
+        if ((typeof objToValidate === 'undefined' || objToValidate === null) &&
+            this.isRequired === false) {
+            return {
+                valid: true,
+                object: objToValidate
+            };
         }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            equals: val
+        if (typeof objToValidate !== 'number')
+            return {
+                valid: false,
+                errors: [
+                    {
+                        message: `expected type number, but saw ${typeof objToValidate}`,
+                        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
+                    }
+                ]
+            };
+        }
+        if (this.#ensureNotNaN && Number.isNaN(objToValidate)) {
+            return {
+                valid: false,
+                errors: [
+                    {
+                        message: 'is not expected to be NaN',
+                        path: path
+                    }
+                ]
+            };
+        }
+        if (this.#ensureIsFinite &&
+            !Number.isFinite(objToValidate) &&
+            this.#ensureNotNaN &&
+            !Number.isNaN(objToValidate)) {
+            return {
+                valid: false,
+                errors: [
+                    {
+                        message: 'is expected to be a finite number',
+                        path: path
+                    }
+                ]
+            };
+        }
+        if (this.#isInteger &&
+            !Number.isNaN(objToValidate) &&
+            Number.isFinite(objToValidate) &&
+            !Number.isInteger(objToValidate)) {
+            return {
+                valid: false,
+                errors: [
+                    {
+                        message: `is expected to be integer`,
+                        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
+        };
+    }
+    createFromProps(props) {
+        return NumberSchemaBuilder.create(props);
+    }
+    /**
+     * Restricts number to be equal to `value`.
+     */
+    equals(value) {
+        if (typeof value !== 'number')
+            throw new Error('number expected');
+        return this.createFromProps({
+            ...this.introspect(),
+            equalsTo: value
         });
     }
+    /**
+     * Clear `equals()` call.
+     */
     clearEquals() {
-        if (typeof this._equals === 'undefined') {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            equals: undefined
+        return this.createFromProps({
+            ...this.introspect(),
+            equalsTo: undefined
+        });
+    }
+    /**
+     * Float values will be considered as valid after this call.
+     */
+    isFloat() {
+        return this.createFromProps({
+            ...this.introspect(),
+            isInteger: false
         });
     }
+    /**
+     * Only integer values will be considered as valid after this call.
+     */
     isInteger() {
-        if (this._isInteger === true) {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
+        return this.createFromProps({
+            ...this.introspect(),
             isInteger: true
         });
     }
-    canBeNotInteger() {
-        if (typeof this._isInteger === 'undefined') {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
-            isInteger: undefined
-        });
+    /**
+     * @hidden
+     */
+    required() {
+        return super.required();
     }
+    /**
+     * @hidden
+     */
+    optional() {
+        return super.optional();
+    }
+    /**
+     * Do not accept NaN value
+     */
     notNaN() {
-        if (this._ensureNotNaN === true) {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
+        return this.createFromProps({
+            ...this.introspect(),
             ensureNotNaN: true
         });
     }
+    /**
+     * Consider NaN value as valid
+     */
     canBeNaN() {
-        if (this._ensureNotNaN === false) {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
+        return this.createFromProps({
+            ...this.introspect(),
             ensureNotNaN: false
         });
     }
+    /**
+     * Do not accept `Infinity`.
+     */
     isFinite() {
-        if (this._ensureIsFinite === true) {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
+        return this.createFromProps({
+            ...this.introspect(),
             ensureIsFinite: true
         });
     }
+    /**
+     * Consider `Infinity` as valid.
+     */
     canBeInfinite() {
-        if (this._ensureIsFinite === false) {
-            return this;
-        }
-        return NumberSchemaBuilder.create({
-            ...this._schema,
+        return this.createFromProps({
+            ...this.introspect(),
             ensureIsFinite: false
         });
     }
+    /**
+     * Restrict number to be at least `minValue`.
+     */
+    min(minValue) {
+        if (typeof minValue !== 'number')
+            throw new Error('minValue must be a number');
+        return this.createFromProps({
+            ...this.introspect(),
+            min: minValue
+        });
+    }
+    /**
+     * Clear `min()` call.
+     */
+    clearMin() {
+        const schema = this.introspect();
+        delete schema.min;
+        return this.createFromProps({
+            ...schema
+        });
+    }
+    /**
+     * Restrict number to be no more than `maxValue`.
+     */
+    max(maxValue) {
+        if (typeof maxValue !== 'number')
+            throw new Error('maxValue must be a number');
+        return this.createFromProps({
+            ...this.introspect(),
+            max: maxValue
+        });
+    }
+    /**
+     * Clear `max()` call.
+     */
+    clearMax() {
+        const schema = this.introspect();
+        delete schema.max;
+        return this.createFromProps({
+            ...schema
+        });
+    }
+}
+/**
+ * Creates a number schema.
+ */
+export function number(equals) {
+    if (typeof equals === 'number') {
+        return NumberSchemaBuilder.create({
+            isRequired: true,
+            equalsTo: equals
+        });
+    }
+    return NumberSchemaBuilder.create({
+        isRequired: true
+    });
 }
-exports.NumberSchemaBuilder = NumberSchemaBuilder;
-const number = () => NumberSchemaBuilder.create();
-exports.number = number;