@astral/validations 2.26.0 → 3.0.0-beta.0

package/any/any.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @description Выключает любые проверки
+ * @example
+ * ```ts
+ *   type Values = { name: string; surname?: string };
+ *
+ *   const validate = object<Values>({ name: any(), surname: any() });
+ *
+ *   // undefined
+ *   validate({});
+ * ```
+ */
+export declare const any: <TValues>() => (value: unknown, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;

package/any/any.js

@@ -0,0 +1,14 @@
+import { createRule } from '../core';
+/**
+ * @description Выключает любые проверки
+ * @example
+ * ```ts
+ *   type Values = { name: string; surname?: string };
+ *
+ *   const validate = object<Values>({ name: any(), surname: any() });
+ *
+ *   // undefined
+ *   validate({});
+ * ```
+ */
+export const any = () => createRule(() => undefined);

package/any/index.d.ts

@@ -0,0 +1 @@
+export * from './any';

package/any/index.js

@@ -0,0 +1 @@
+export * from './any';

package/array/array.d.ts

@@ -0,0 +1,15 @@
+import { ValidationRule } from '../core';
+/**
+ * @description Guard для массива. Проверяет value на соответствие типу array
+ * @param rules - правила валидаций, применяющиеся ко всему массиву
+ * @example
+ * ```ts
+ * const value = ['Vasya', 'Ivan'];
+ *
+ * const validateArray = array(min(1), arrayItem(string()));
+ *
+ * // undefined
+ * validateArray(value);
+ * ```
+ */
+export declare const array: <TItem extends unknown, TValues = unknown>(...rules: ValidationRule<TItem[], TValues>[]) => import("../core").Guard<unknown[], TValues, {}>;

package/array/array.js

@@ -0,0 +1,21 @@
+import { compose, createGuard } from '../core';
+import { ARRAY_TYPE_ERROR_INFO } from './constants';
+/**
+ * @description Guard для массива. Проверяет value на соответствие типу array
+ * @param rules - правила валидаций, применяющиеся ко всему массиву
+ * @example
+ * ```ts
+ * const value = ['Vasya', 'Ivan'];
+ *
+ * const validateArray = array(min(1), arrayItem(string()));
+ *
+ * // undefined
+ * validateArray(value);
+ * ```
+ */
+export const array = (...rules) => createGuard((value, ctx, { typeErrorMessage }) => {
+    if (!Array.isArray(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, ARRAY_TYPE_ERROR_INFO), { message: typeErrorMessage || ARRAY_TYPE_ERROR_INFO.message }));
+    }
+    return compose(...rules)(value, ctx);
+});

package/array/constants.d.ts

@@ -0,0 +1,2 @@
+import { ErrorInfo } from '../core';
+export declare const ARRAY_TYPE_ERROR_INFO: ErrorInfo;

package/array/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const ARRAY_TYPE_ERROR_INFO = {
+    code: createErrorCode('array'),
+    message: 'Не является массивом',
+};

package/array/index.d.ts

@@ -0,0 +1,2 @@
+export * from './array';
+export * from './constants';

package/array/index.js

@@ -0,0 +1,2 @@
+export * from './array';
+export * from './constants';

package/arrayItem/arrayItem.d.ts

@@ -0,0 +1,35 @@
+import { ValidationRule } from '../core';
+/**
+ * @description Применяет правила к каждому элементу массива
+ * @param rules - правила валидации, которое применится к каждому элементу массива
+ * @example
+ * ```ts
+ * type Item = {
+ *   name: string;
+ *   age?: number;
+ * };
+ *
+ * const values: Values = [{ name: 'Vasya' }, { name: 'Vasya', age: 22 }];
+ *
+ * const validateArray = array(
+ *   arrayItem(
+ *     object<Item>({
+ *       name: string(min(2)),
+ *       age: optional(number()),
+ *     }),
+ *   ),
+ * );
+ *
+ * // undefined
+ * validateArray(values);
+ * ```
+ */
+export declare const arrayItem: <TItem extends unknown, TValues = unknown>(...rules: ValidationRule<TItem, TValues>[]) => (value: TItem[], prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;

package/arrayItem/arrayItem.js

@@ -0,0 +1,33 @@
+import { compose, createArrayError, createRule, } from '../core';
+/**
+ * @description Применяет правила к каждому элементу массива
+ * @param rules - правила валидации, которое применится к каждому элементу массива
+ * @example
+ * ```ts
+ * type Item = {
+ *   name: string;
+ *   age?: number;
+ * };
+ *
+ * const values: Values = [{ name: 'Vasya' }, { name: 'Vasya', age: 22 }];
+ *
+ * const validateArray = array(
+ *   arrayItem(
+ *     object<Item>({
+ *       name: string(min(2)),
+ *       age: optional(number()),
+ *     }),
+ *   ),
+ * );
+ *
+ * // undefined
+ * validateArray(values);
+ * ```
+ */
+export const arrayItem = (...rules) => createRule((array, ctx) => {
+    const validationItemsResult = array.map((item) => compose(...rules)(item, ctx));
+    if (validationItemsResult.some((result) => result !== undefined)) {
+        return createArrayError(validationItemsResult);
+    }
+    return undefined;
+});

package/arrayItem/index.d.ts

@@ -0,0 +1 @@
+export * from './arrayItem';

package/arrayItem/index.js

@@ -0,0 +1 @@
+export * from './arrayItem';

package/boolean/boolean.d.ts

@@ -0,0 +1,13 @@
+import { ValidationRule } from '../core';
+/**
+ * @description Guard для boolean. Проверяет значение на тип boolean
+ * @param rules - правила, валидирующие boolean или unknown value
+ * @example
+ * ```ts
+ *  const validate = boolean();
+ *
+ *  // undefined
+ *  validate(true);
+ * ```
+ */
+export declare const boolean: <TValues>(...rules: ValidationRule<boolean, TValues>[]) => import("../core").Guard<boolean, TValues, {}>;

package/boolean/boolean.js

@@ -0,0 +1,19 @@
+import { compose, createGuard } from '../core';
+import { BOOLEAN_TYPE_ERROR_INFO } from './constants';
+/**
+ * @description Guard для boolean. Проверяет значение на тип boolean
+ * @param rules - правила, валидирующие boolean или unknown value
+ * @example
+ * ```ts
+ *  const validate = boolean();
+ *
+ *  // undefined
+ *  validate(true);
+ * ```
+ */
+export const boolean = (...rules) => createGuard((value, ctx, { typeErrorMessage }) => {
+    if (typeof value !== 'boolean') {
+        return ctx.createError(Object.assign(Object.assign({}, BOOLEAN_TYPE_ERROR_INFO), { message: typeErrorMessage || BOOLEAN_TYPE_ERROR_INFO.message }));
+    }
+    return compose(...rules)(value, ctx);
+});

package/boolean/constants.d.ts

@@ -0,0 +1,2 @@
+import { ErrorInfo } from '../core';
+export declare const BOOLEAN_TYPE_ERROR_INFO: ErrorInfo;

package/boolean/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const BOOLEAN_TYPE_ERROR_INFO = {
+    code: createErrorCode('boolean-type'),
+    message: 'Не boolean',
+};

package/boolean/index.d.ts

@@ -0,0 +1,2 @@
+export * from './boolean';
+export * from './constants';

package/boolean/index.js

@@ -0,0 +1,2 @@
+export * from './boolean';
+export * from './constants';

package/core/compose/compose.d.ts

@@ -0,0 +1,6 @@
+import { IndependentValidationRule, ValidationRule } from '../rule';
+/**
+ * @description Объединяет переданные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
+ * @example compose(min(), max());
+ */
+export declare const compose: <ValidationType, TValues>(...rules: (IndependentValidationRule<ValidationType, TValues> | ValidationRule<ValidationType, TValues>)[]) => IndependentValidationRule<ValidationType, TValues>;

package/{compose → core/compose}/compose.js

@@ -1,6 +1,5 @@
 /**
  * @description Объединяет переданные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
- * @example compose(isRequired(), isEmail());
- * @example compose(isRequired(), compose(isIncludeDot(), isIncludeComma()));
+ * @example compose(min(), max());
  */
-export const compose = (...rules) => (value) => rules.reduce((result, rule) => result || rule(value), undefined);
+export const compose = (...rules) => (value, ctx) => rules.reduce((result, rule) => result || rule(value, ctx), undefined);

package/core/context/createContext/createContext.d.ts

@@ -0,0 +1,8 @@
+import { ValidationContext } from '../types';
+import { ValidationTypes } from '../../types';
+/**
+ * @description Создает context валидации. Используется внутри фабрик guard и rule
+ * @default по-дефолту сбрасывает все флаги в false
+ */
+export declare function createContext<Value extends ValidationTypes>(prevCtx: ValidationContext<Value> | undefined, value: Value): ValidationContext<Value>;
+export declare function createContext<Value extends ValidationTypes, Values>(prevCtx: ValidationContext<Values> | undefined, value: Value): ValidationContext<Values>;

package/core/context/createContext/createContext.js

@@ -0,0 +1,15 @@
+import { createSimpleError } from '../../errors';
+export function createContext(prevCtx, value) {
+    if (prevCtx) {
+        return prevCtx;
+    }
+    return {
+        global: {
+            values: value,
+            overrides: {
+                objectIsPartial: false,
+            },
+        },
+        createError: createSimpleError,
+    };
+}

package/core/context/createContext/index.d.ts

@@ -0,0 +1 @@
+export * from './createContext';

package/core/context/createContext/index.js

@@ -0,0 +1 @@
+export * from './createContext';

package/core/context/index.d.ts

@@ -0,0 +1,2 @@
+export * from './createContext';
+export * from './types';

package/core/context/index.js

@@ -0,0 +1,2 @@
+export * from './createContext';
+export * from './types';

package/core/context/types.d.ts

@@ -0,0 +1,28 @@
+import { createSimpleError } from '../errors';
+/**
+ * @description Контекст, который доступен в каждом правиле
+ */
+export type ValidationContext<TValues> = Readonly<{
+    /**
+     * @description Глобальные значения, идущие от самого верхнего правила к самому нижнему
+     */
+    global: Readonly<{
+        /**
+         * @description Значения, которые валидируется guard самого высоко порядка
+         */
+        values: TValues;
+        /**
+         * @description Глобальные переопределения (сквозные для всех правил)
+         */
+        overrides: Readonly<{
+            /**
+             * @description Делает для всех объектов в схеме все свойства необязательными
+             */
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    /**
+     * @description Фабрика ошибок. Возвращает новую ошибку валидации
+     */
+    createError: typeof createSimpleError;
+}>;

package/core/errors/ArrayError/ArrayError.d.ts

@@ -0,0 +1,18 @@
+import { ValidationResult } from '../../types';
+import { ValidationErrorData, ValidationSimpleError } from '../SimpleError';
+/**
+ * @description Доп. поля для ошибок элементов массива
+ */
+export type ValidationArrayErrorCause = {
+    /**
+     * @description Массив ошибок элементов валидируемого массива.
+     * Индекс errorArray соответвует индексу валидируемого элемента массива
+     */
+    errorArray: Array<ValidationResult>;
+};
+/**
+ * @description Array ошибок для массива
+ */
+export declare class ValidationArrayError extends ValidationSimpleError<ValidationArrayErrorCause> {
+    constructor(message: string, data: ValidationErrorData<ValidationArrayErrorCause>);
+}

package/core/errors/ArrayError/ArrayError.js

@@ -0,0 +1,10 @@
+import { ValidationSimpleError } from '../SimpleError';
+/**
+ * @description Array ошибок для массива
+ */
+export class ValidationArrayError extends ValidationSimpleError {
+    constructor(message, data) {
+        super(message, data);
+        this.cause = data.cause;
+    }
+}

package/core/errors/ArrayError/createArrayError/createArrayError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationArrayError, ValidationArrayErrorCause } from '../ArrayError';
+/**
+ * @description Создает array ошибок. Ошибка предназначена для результата валидации массива
+ */
+export declare const createArrayError: (errorArray: ValidationArrayErrorCause['errorArray']) => ValidationArrayError;

package/core/errors/ArrayError/createArrayError/createArrayError.js

@@ -0,0 +1,11 @@
+import { ValidationArrayError } from '../ArrayError';
+/**
+ * @description Создает array ошибок. Ошибка предназначена для результата валидации массива
+ */
+export const createArrayError = (errorArray) => {
+    const firstErrorIndex = errorArray.findIndex((error) => Boolean(error));
+    const firstError = errorArray[firstErrorIndex];
+    return new ValidationArrayError(`Ошибка в item[${firstErrorIndex}]: ${firstError.message}`, {
+        cause: { errorArray, code: firstError.cause.code },
+    });
+};

package/core/errors/ArrayError/createArrayError/index.d.ts

@@ -0,0 +1 @@
+export * from './createArrayError';

package/core/errors/ArrayError/createArrayError/index.js

@@ -0,0 +1 @@
+export * from './createArrayError';

package/core/errors/ArrayError/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ArrayError';
+export * from './createArrayError';

package/core/errors/ArrayError/index.js

@@ -0,0 +1,2 @@
+export * from './ArrayError';
+export * from './createArrayError';

package/core/errors/ErrorMap/ErrorMap.d.ts

@@ -0,0 +1,21 @@
+import { ValidationErrorData, ValidationSimpleError } from '../SimpleError';
+import { ValidationResult } from '../../types';
+/**
+ * @description Map, которое содержит результат валидации свойств
+ */
+export type ErrorMap = Record<string, ValidationResult>;
+/**
+ * @description Доп. поля для ошибки в объекте
+ */
+export type ValidationObjectErrorCause = {
+    /**
+     * @description Map, которое содержит результат валидации свойств
+     */
+    errorMap: Record<string, ValidationResult>;
+};
+/**
+ * @description Map ошибок для объекта
+ */
+export declare class ValidationErrorMap extends ValidationSimpleError<ValidationObjectErrorCause> {
+    constructor(message: string, data: ValidationErrorData<ValidationObjectErrorCause>);
+}

package/core/errors/ErrorMap/ErrorMap.js

@@ -0,0 +1,10 @@
+import { ValidationSimpleError } from '../SimpleError';
+/**
+ * @description Map ошибок для объекта
+ */
+export class ValidationErrorMap extends ValidationSimpleError {
+    constructor(message, data) {
+        super(message, data);
+        this.cause = data.cause;
+    }
+}

package/core/errors/ErrorMap/createErrorMap/createErrorMap.d.ts

@@ -0,0 +1,5 @@
+import { ValidationErrorMap, ValidationObjectErrorCause } from '../ErrorMap';
+/**
+ * @description Создает map ошибок валидаций. Ошибка предназначена для генерации результата валидации объекта
+ */
+export declare const createErrorMap: (errorMap: ValidationObjectErrorCause['errorMap']) => ValidationErrorMap;

package/core/errors/ErrorMap/createErrorMap/createErrorMap.js

@@ -0,0 +1,10 @@
+import { ValidationErrorMap } from '../ErrorMap';
+/**
+ * @description Создает map ошибок валидаций. Ошибка предназначена для генерации результата валидации объекта
+ */
+export const createErrorMap = (errorMap) => {
+    const [firstErrorPath, firstError] = Object.entries(errorMap).find(([, error]) => Boolean(error));
+    return new ValidationErrorMap(`Ошибка в свойстве ${firstErrorPath}: ${firstError.message}`, {
+        cause: { errorMap, code: firstError.cause.code },
+    });
+};

package/core/errors/ErrorMap/createErrorMap/index.d.ts

@@ -0,0 +1 @@
+export * from './createErrorMap';

package/core/errors/ErrorMap/createErrorMap/index.js

@@ -0,0 +1 @@
+export * from './createErrorMap';

package/core/errors/ErrorMap/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ErrorMap';
+export * from './createErrorMap';

package/core/errors/ErrorMap/index.js

@@ -0,0 +1,2 @@
+export * from './ErrorMap';
+export * from './createErrorMap';

package/core/errors/SimpleError/SimpleError.d.ts

@@ -0,0 +1,16 @@
+import { ErrorCode } from '../types';
+/**
+ * @description Причина ошибки валидации
+ */
+export type ValidationErrorData<AddCause extends Record<string, unknown>> = {
+    cause: AddCause & {
+        code: ErrorCode;
+    };
+};
+/**
+ * @description Простая ошибка правил валидации. Не имеет вложенных ошибок
+ */
+export declare class ValidationSimpleError<AddCause extends Record<string, unknown> = {}> extends Error {
+    cause: ValidationErrorData<AddCause>['cause'];
+    constructor(message: string, data: ValidationErrorData<AddCause>);
+}

package/core/errors/SimpleError/SimpleError.js

@@ -0,0 +1,9 @@
+/**
+ * @description Простая ошибка правил валидации. Не имеет вложенных ошибок
+ */
+export class ValidationSimpleError extends Error {
+    constructor(message, data) {
+        super(message);
+        this.cause = data.cause;
+    }
+}

package/core/errors/SimpleError/createSimpleError/createSimpleError.d.ts

@@ -0,0 +1,6 @@
+import { ValidationSimpleError } from '../SimpleError';
+import { ErrorInfo } from '../../types';
+/**
+ * @description Создает простую ошибки валидации. Используется в обычных rules
+ */
+export declare const createSimpleError: ({ message, code }: ErrorInfo) => ValidationSimpleError<{}>;

package/core/errors/SimpleError/createSimpleError/createSimpleError.js

@@ -0,0 +1,5 @@
+import { ValidationSimpleError } from '../SimpleError';
+/**
+ * @description Создает простую ошибки валидации. Используется в обычных rules
+ */
+export const createSimpleError = ({ message, code }) => new ValidationSimpleError(message, { cause: { code } });

package/core/errors/SimpleError/createSimpleError/index.d.ts

@@ -0,0 +1 @@
+export * from './createSimpleError';

package/core/errors/SimpleError/createSimpleError/index.js

@@ -0,0 +1 @@
+export * from './createSimpleError';

package/core/errors/SimpleError/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SimpleError';
+export * from './createSimpleError';

package/core/errors/SimpleError/index.js

@@ -0,0 +1,2 @@
+export * from './SimpleError';
+export * from './createSimpleError';

package/core/errors/createErrorCode/createErrorCode.d.ts

@@ -0,0 +1,5 @@
+import { ErrorCode } from '../types';
+/**
+ * @description Создает уникальный код ошибки
+ */
+export declare const createErrorCode: (errorName: string) => ErrorCode;

package/core/errors/createErrorCode/createErrorCode.js

@@ -0,0 +1,4 @@
+/**
+ * @description Создает уникальный код ошибки
+ */
+export const createErrorCode = (errorName) => `astral-validations-${errorName}`;

package/core/errors/createErrorCode/index.d.ts

@@ -0,0 +1 @@
+export * from './createErrorCode';

package/core/errors/createErrorCode/index.js

@@ -0,0 +1 @@
+export * from './createErrorCode';

package/core/errors/index.d.ts

@@ -0,0 +1,5 @@
+export * from './SimpleError';
+export * from './ArrayError';
+export * from './ErrorMap';
+export * from './types';
+export * from './createErrorCode';

package/core/errors/index.js

@@ -0,0 +1,5 @@
+export * from './SimpleError';
+export * from './ArrayError';
+export * from './ErrorMap';
+export * from './types';
+export * from './createErrorCode';

package/core/errors/types.d.ts

@@ -0,0 +1,18 @@
+import { ValidationErrorMap } from './ErrorMap';
+import { ValidationSimpleError } from './SimpleError';
+import { ValidationArrayError } from './ArrayError';
+/**
+ * @description Уникальный код ошибки валидации
+ */
+export type ErrorCode = string;
+/**
+ * @description Информация, которая есть для каждой ошибки
+ */
+export type ErrorInfo = {
+    code: ErrorCode;
+    message: string;
+};
+/**
+ * @description Union возможных ошибок
+ */
+export type ValidationError = ValidationSimpleError | ValidationArrayError | ValidationErrorMap;

package/core/errors/types.js

@@ -0,0 +1 @@
+export {};

package/core/guard/createGuard/createGuard.d.ts

@@ -0,0 +1,54 @@
+import { ValidationResult, ValidationTypes } from '../../types';
+import { ValidationContext } from '../../context';
+type DefOptions<AddDefOptions extends Record<string, unknown>> = Partial<AddDefOptions> & {
+    /**
+     * @description Переопределяет дефолтное сообщения ошибки для required
+     * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
+     */
+    requiredErrorMessage?: string;
+    /**
+     * @description Переопределяет сообщение об ошибке типа
+     * @example string.define({ typeErrorMessage: 'ИНН не может быть числом' })(inn())
+     */
+    typeErrorMessage?: string;
+    /**
+     * @description Позволяет выключать проверку на required
+     * @default false
+     */
+    isOptional?: boolean;
+};
+type GuardValue<ValidationType> = ValidationType | undefined | null | unknown;
+/**
+ * @description Интерфейс функции guard, которая в прототипе содержит метод define
+ */
+export interface Guard<ValidationType extends ValidationTypes, TValues, AddDefOptions extends Record<string, unknown> = {}> {
+    (value: GuardValue<ValidationType>, ctx?: ValidationContext<TValues>): ValidationResult;
+    /**
+     * @description Функция для создания нового guard с переопределенными дефолтными параметрами. Возвращает новый guard
+     * @param options - параметры, позволяющие переопределить дефолтные настройки guard
+     * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
+     */
+    define(options: DefOptions<AddDefOptions>): Guard<ValidationType, TValues, AddDefOptions>;
+}
+/**
+ * @description Функция, которая позволяет определять частную логику для guard
+ */
+type GuardExecutor<TValues, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TValues>, defOptions: DefOptions<AddDefOptions>) => ValidationResult;
+/**
+ * @description Создает guard. Guard - функция, проверяющая тип значения
+ * По-дефолту проверяет value на required. Для выключения required необходимо использовать optional().
+ * После первого вызова guard в прототипу функции становится доступен метод define, который позволяет переопределить дефолтное поведение guard (например, изменить текст для required правила)
+ * @example
+ * ```ts
+ * const string = <TValues>(...rules: ValidationRule<string, TValues>[]) =>
+ *   createGuard<string, TValues>((value, ctx) => {
+ *     if (typeof value !== 'string') {
+ *       return ctx.createError({ code: 'custom error', message: 'Не строка' });
+ *     }
+ *
+ *     return compose<string, TValues>(...rules)(value, ctx);
+ *   });
+ * ```
+ */
+export declare const createGuard: <ValidationType extends unknown, TValues, AddDefOptions extends Record<string, unknown> = {}>(executeGuard: GuardExecutor<TValues, AddDefOptions>) => Guard<ValidationType, TValues, AddDefOptions>;
+export {};