@cleverbrush/schema 1.0.0-beta.4 → 1.0.0

package/dist/builders/StringSchemaBuilder.d.ts

@@ -1,14 +1,139 @@
-import { ISchemaBuilder } from './SchemaBuilder.js';
-export interface IStringSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TMinLength extends number | undefined = undefined, TMaxLength extends number | undefined = undefined, TEqualsTo extends string | undefined = undefined> extends ISchemaBuilder<TRequired, TNullable> {
-    optional(): IStringSchemaBuilder<false, TNullable, TMinLength, TMaxLength, TEqualsTo>;
-    required(): IStringSchemaBuilder<true, TNullable, TMinLength, TMaxLength, TEqualsTo>;
-    nullable(): IStringSchemaBuilder<TRequired, true, TMinLength, TMaxLength, TEqualsTo>;
-    notNullable(): IStringSchemaBuilder<TRequired, false, TMinLength, TMaxLength, TEqualsTo>;
-    minLength<K extends number>(val: K): IStringSchemaBuilder<TRequired, TNullable, K, TMaxLength, TEqualsTo>;
-    clearMinLength(): IStringSchemaBuilder<TRequired, TNullable, undefined, TMaxLength, TEqualsTo>;
-    maxLength<K extends number>(val: K): IStringSchemaBuilder<TRequired, TNullable, TMinLength, K, TEqualsTo>;
-    clearMaxLength(): IStringSchemaBuilder<TRequired, TNullable, TMinLength, undefined, TEqualsTo>;
-    equals<T extends string>(val: T): IStringSchemaBuilder<TRequired, TNullable, TMinLength, TMaxLength, T>;
-    clearEquals(): IStringSchemaBuilder<TRequired, TNullable, TMinLength, TMaxLength, undefined>;
+import { Preprocessor, SchemaBuilder, ValidationResult, ValidationContext, Validator } from './SchemaBuilder.js';
+type StringSchemaBuilderCreateProps<T = string, R extends boolean = true> = Partial<ReturnType<StringSchemaBuilder<T, R>['introspect']>>;
+/**
+ * Allows to define a schema for a string. It can be: required or optional,
+ * restricted to be equal to a certain value, restricted to have a certain
+ * length.
+ *
+ * **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 string | string()} function instead.
+ *
+ * @example ```ts
+ * const schema = string().equals('hello');
+ * const result = await schema.validate('hello');
+ * // result.valid === true
+ * // result.object === 'hello'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().equals('hello');
+ * const result = await schema.validate('world');
+ * // result.valid === false
+ * // result.errors[0].message === "is expected to be equal to 'hello'"
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(5);
+ * const result = await schema.validate('hello');
+ * // result.valid === true
+ * // result.object === 'hello'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(5);
+ * const result = await schema.validate('hi');
+ * // result.valid === false
+ * // result.errors[0].message === 'is expected to have a length of at least 5'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(2).maxLength(5);
+ * const result = await schema.validate('yes');
+ * // result.valid === true
+ * // result.object === 'yes'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string('no');
+ * const result = await schema.validate('yes');
+ * // result.valid === false
+ * // result.errors[0].message === "is expected to be equal to 'no'"
+ * ```
+ *
+ * @see {@link string}
+ */
+export declare class StringSchemaBuilder<TResult = string, TRequired extends boolean = true> extends SchemaBuilder<TResult, TRequired> {
+    #private;
+    static create(props: StringSchemaBuilderCreateProps): StringSchemaBuilder<string, true>;
+    private constructor();
+    introspect(): {
+        /**
+         * Min length of the string (if defined).
+         */
+        minLength: number | undefined;
+        /**
+         * Max length of the string (if defined).
+         */
+        maxLength: number | undefined;
+        /**
+         * If set, restrict object to be equal to a certain value.
+         */
+        equalsTo: string | undefined;
+        /**
+         * Array of preprocessor functions
+         */
+        preprocessors: Preprocessor<TResult>[];
+        /**
+         * Array of validator functions
+         */
+        validators: Validator<TResult>[];
+        type: string;
+        isRequired: boolean;
+    };
+    /**
+     * @hidden
+     */
+    hasType<T>(notUsed?: T): StringSchemaBuilder<T, true>;
+    /**
+     * @hidden
+     */
+    clearHasType(): StringSchemaBuilder<string, TRequired>;
+    /**
+     * Performs validion of string schema over `object`.
+     * @param context Optional `ValidationContext` settings.
+     */
+    validate(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    protected createFromProps<T, TReq extends boolean>(props: StringSchemaBuilderCreateProps<T, TReq>): this;
+    /**
+     * Restricts object to be equal to `value`.
+     */
+    equals<T extends string>(value: T): StringSchemaBuilder<T, TRequired>;
+    /**
+     * Cancels `equals()` call.
+     */
+    clearEquals(): StringSchemaBuilder<string, TRequired>;
+    /**
+     * @hidden
+     */
+    required(): StringSchemaBuilder<TResult, true>;
+    /**
+     * @hidden
+     */
+    optional(): StringSchemaBuilder<TResult, false>;
+    /**
+     * Set minimal length of the valid value for schema.
+     * @param {number} length
+     */
+    minLength(length: number): StringSchemaBuilder<TResult, TRequired>;
+    /**
+     * Cancel `minLength()` call.
+     */
+    clearMinLength(): StringSchemaBuilder<TResult, TRequired>;
+    /**
+     * Set maximal length of the valid value for schema.
+     * @length {number} length
+     */
+    maxLength(length: number): StringSchemaBuilder<TResult, TRequired>;
+    /**
+     * cancel `maxLength()` call.
+     */
+    clearMaxLength(): StringSchemaBuilder<TResult, TRequired>;
 }
-export declare const string: <T extends string = undefined>(equals?: T) => IStringSchemaBuilder<true, false, undefined, undefined, T extends undefined ? undefined : T>;
+/**
+ * Creates a string schema restricted to be equal to `equals`.
+ * @param equals number value
+ */
+export declare function string<T extends string>(equals: T): StringSchemaBuilder<T, true>;
+export declare function string(): StringSchemaBuilder<string, true>;
+export {};

package/dist/builders/StringSchemaBuilder.js

@@ -1,140 +1,286 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.string = void 0;
-const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
-const defaultSchemas_js_1 = require("../defaultSchemas.js");
-class StringSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
-    _minLength;
-    _maxLength;
-    _equals;
-    type = 'string';
-    clone() {
-        return StringSchemaBuilder.create(this._schema);
-    }
-    get _schema() {
-        return Object.assign({
-            type: this.type
-        }, this.getCommonSchema(), typeof this._minLength !== 'undefined'
-            ? { minLength: this._minLength }
-            : {}, typeof this._maxLength !== 'undefined'
-            ? { maxLength: this._maxLength }
-            : {}, typeof this._equals !== 'undefined' ? { equals: this._equals } : {});
+import { SchemaBuilder } from './SchemaBuilder.js';
+/**
+ * Allows to define a schema for a string. It can be: required or optional,
+ * restricted to be equal to a certain value, restricted to have a certain
+ * length.
+ *
+ * **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 string | string()} function instead.
+ *
+ * @example ```ts
+ * const schema = string().equals('hello');
+ * const result = await schema.validate('hello');
+ * // result.valid === true
+ * // result.object === 'hello'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().equals('hello');
+ * const result = await schema.validate('world');
+ * // result.valid === false
+ * // result.errors[0].message === "is expected to be equal to 'hello'"
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(5);
+ * const result = await schema.validate('hello');
+ * // result.valid === true
+ * // result.object === 'hello'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(5);
+ * const result = await schema.validate('hi');
+ * // result.valid === false
+ * // result.errors[0].message === 'is expected to have a length of at least 5'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string().minLength(2).maxLength(5);
+ * const result = await schema.validate('yes');
+ * // result.valid === true
+ * // result.object === 'yes'
+ * ```
+ *
+ * @example ```ts
+ * const schema = string('no');
+ * const result = await schema.validate('yes');
+ * // result.valid === false
+ * // result.errors[0].message === "is expected to be equal to 'no'"
+ * ```
+ *
+ * @see {@link string}
+ */
+export class StringSchemaBuilder extends SchemaBuilder {
+    #minLength;
+    #maxLength;
+    #equalsTo;
+    static create(props) {
+        return new StringSchemaBuilder({
+            type: 'string',
+            ...props
+        });
     }
-    optional() {
-        if (this.isRequired === false) {
-            return this;
+    constructor(props) {
+        super(props);
+        if (typeof props.minLength === 'number') {
+            this.#minLength = props.minLength;
         }
-        return StringSchemaBuilder.create({
-            ...this._schema,
-            isRequired: false
+        if (typeof props.maxLength === 'number') {
+            this.#maxLength = props.maxLength;
+        }
+        if (typeof props.equalsTo === 'string' ||
+            typeof props.equalsTo === 'undefined') {
+            this.#equalsTo = props.equalsTo;
+        }
+    }
+    introspect() {
+        return {
+            ...super.introspect(),
+            /**
+             * Min length of the string (if defined).
+             */
+            minLength: this.#minLength,
+            /**
+             * Max length of the string (if defined).
+             */
+            maxLength: this.#maxLength,
+            /**
+             * If set, restrict object to be equal to a certain value.
+             */
+            equalsTo: this.#equalsTo,
+            /**
+             * 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()
         });
     }
-    required() {
-        if (this.isRequired === true) {
-            return this;
-        }
-        return StringSchemaBuilder.create({
-            ...this._schema,
-            isRequired: true
+    /**
+     * @hidden
+     */
+    clearHasType() {
+        return this.createFromProps({
+            ...this.introspect()
         });
     }
-    nullable() {
-        if (this.isNullable === true) {
-            return this;
+    /**
+     * Performs validion of string 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 StringSchemaBuilder.create({
-            ...this._schema,
-            isNullable: true
+        const { object: { validatedObject: objToValidate } } = preValidationTransaction;
+        if ((typeof objToValidate === 'undefined' || objToValidate === null) &&
+            this.isRequired === false) {
+            return {
+                valid: true,
+                object: objToValidate
+            };
+        }
+        if (typeof objToValidate !== 'string')
+            return {
+                valid: false,
+                errors: [
+                    {
+                        message: `expected type string, 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 (typeof this.#minLength !== 'undefined') {
+            if (objToValidate.length < this.#minLength)
+                return {
+                    valid: false,
+                    errors: [
+                        {
+                            message: `expected to has at least ${this.#minLength} characters length`,
+                            path: path
+                        }
+                    ]
+                };
+        }
+        if (typeof this.#maxLength !== 'undefined') {
+            if (objToValidate.length > this.#maxLength)
+                return {
+                    valid: false,
+                    errors: [
+                        {
+                            message: `must not exceed ${this.#maxLength} characters`,
+                            path: path
+                        }
+                    ]
+                };
+        }
+        return {
+            valid: true,
+            object: objToValidate
+        };
+    }
+    createFromProps(props) {
+        return StringSchemaBuilder.create(props);
+    }
+    /**
+     * Restricts object to be equal to `value`.
+     */
+    equals(value) {
+        if (typeof value !== 'string')
+            throw new Error('string expected');
+        return this.createFromProps({
+            ...this.introspect(),
+            equalsTo: value
         });
     }
-    notNullable() {
-        if (this.isNullable === false) {
-            return this;
-        }
-        return StringSchemaBuilder.create({
-            ...this._schema,
-            isNullable: false
+    /**
+     * Cancels `equals()` call.
+     */
+    clearEquals() {
+        return this.createFromProps({
+            ...this.introspect(),
+            equalsTo: undefined
         });
     }
-    minLength(val) {
-        if (this._minLength === val) {
-            return this;
-        }
-        return StringSchemaBuilder.create({
-            ...this._schema,
-            minLength: val
+    /**
+     * @hidden
+     */
+    required() {
+        return super.required();
+    }
+    /**
+     * @hidden
+     */
+    optional() {
+        return super.optional();
+    }
+    /**
+     * Set minimal length of the valid value for schema.
+     * @param {number} length
+     */
+    minLength(length) {
+        if (typeof length !== 'number')
+            throw new Error('length must be a number');
+        return this.createFromProps({
+            ...this.introspect(),
+            minLength: length
         });
     }
+    /**
+     * Cancel `minLength()` call.
+     */
     clearMinLength() {
-        if (typeof this._minLength === 'undefined') {
-            return this;
-        }
-        return StringSchemaBuilder.create({
-            ...this._schema,
-            minLength: undefined
+        const schema = this.introspect();
+        delete schema.minLength;
+        return this.createFromProps({
+            ...schema
         });
     }
-    maxLength(val) {
-        if (this._maxLength === val) {
-            return this;
-        }
-        return StringSchemaBuilder.create({
-            ...this._schema,
-            maxLength: val
+    /**
+     * Set maximal length of the valid value for schema.
+     * @length {number} length
+     */
+    maxLength(length) {
+        if (typeof length !== 'number')
+            throw new Error('length must be a number');
+        return this.createFromProps({
+            ...this.introspect(),
+            maxLength: length
         });
     }
+    /**
+     * cancel `maxLength()` call.
+     */
     clearMaxLength() {
-        if (typeof this._maxLength === 'undefined') {
-            return this;
-        }
-        return StringSchemaBuilder.create({
-            ...this._schema,
-            maxLength: undefined
+        const schema = this.introspect();
+        delete schema.maxLength;
+        return this.createFromProps({
+            ...schema
         });
     }
-    equals(val) {
-        if (this._equals === val) {
-            return this;
-        }
-        return StringSchemaBuilder.create({
-            ...this._schema,
-            equals: val
-        });
-    }
-    clearEquals() {
-        if (typeof this._equals === 'undefined') {
-            return this;
-        }
+}
+/**
+ * Creates a string schema.
+ */
+export function string(equals) {
+    if (typeof equals === 'string') {
         return StringSchemaBuilder.create({
-            ...this._schema,
-            equals: undefined
+            isRequired: true,
+            equalsTo: equals
         });
     }
-    static create(obj) {
-        return new StringSchemaBuilder(obj);
-    }
-    constructor(obj) {
-        super(obj);
-        if (typeof obj === 'object' && obj) {
-            if (typeof obj.minLength !== 'undefined') {
-                this._minLength = obj.minLength;
-            }
-            if (typeof obj.maxLength !== 'undefined') {
-                this._maxLength = obj.maxLength;
-            }
-            if (typeof obj.equals !== 'undefined') {
-                this._equals = obj.equals;
-            }
-        }
-        else {
-            const defaultSchema = defaultSchemas_js_1.defaultSchemas['string'];
-            this.isRequired = defaultSchema.isRequired;
-            this.isNullable = defaultSchema.isNullable;
-        }
-    }
+    return StringSchemaBuilder.create({
+        isRequired: true
+    });
 }
-const string = (equals) => {
-    const res = StringSchemaBuilder.create();
-    return typeof equals === 'string' ? res.equals(equals) : res;
-};
-exports.string = string;