@astral/validations 4.6.1 → 4.8.0

package/README.md

@@ -65,6 +65,7 @@
   - [when. Условная валидация](#when-условная-валидация)
   - [transform](#transform)
   - [or](#or)
+- [Async](#async)
 - [Integrations](#integrations)
   - [react-hook-form](#react-hook-form)
 - [Guides](#guides)
@@ -1363,6 +1364,26 @@ validate({
 });
 ```
 
+Позволяет делать optional вложенные правила:
+
+```ts
+type Values = { name: string | number; isAgree: boolean };
+
+const validate = object<Values>({
+  name: optional(
+    when({
+      is: (_, ctx) => Boolean(ctx.values?.isAgree),
+      then: string(),
+      otherwise: number(),
+    })
+  ),
+  isAgree: optional(boolean()),
+});
+
+// undefined
+validate({ isAgree: false, name: undefined });
+```
+
 ---
 
 ## when. Условная валидация
@@ -1464,6 +1485,45 @@ validate(new Date())
 
 ---
 
+# Async
+Пакет поддерживает асинхронную валидацию.
+
+Guard, поддерживающие асинхронную валидацию имеют постфиксы ```async```:
+- ```objectAsync```
+- ```stringAsync```
+
+Пример:
+
+```ts
+type Values = {
+    nickname: string;
+    phone: string;
+};
+
+const validate = objectAsync<Values>({
+    phone: string(),
+    nickname: stringAsync(min(3), async (value, ctx) => {
+        const nicknameIsAvailable = await checkNickname(value);
+
+        if (nicknameIsAvailable) {
+            return undefined;
+        }
+
+        return ctx.createError({
+            code: 'nickname-available',
+            message: 'Nickname занят',
+        });
+    }),
+});
+
+const result = await validate({ phone: '79308999999', nickname: 'Vasya' });
+
+// { nickname: 'Nickname занят' }
+toPrettyError(result);
+```
+
+---
+
 # Integrations
 
 ## react-hook-form

package/array/array.d.ts

@@ -12,11 +12,4 @@ import { ValidationRule } from '../core';
  * validateArray(value);
  * ```
  */
-export declare const array: <TItem extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(...rules: ValidationRule<TItem[], TLastSchemaValues>[]) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
-    define(overridesDefOptions: Partial<{}> & {
-        requiredErrorMessage?: string | undefined;
-        typeErrorMessage?: string | undefined;
-        isOptional?: boolean | undefined;
-    }): any;
-};
+export declare const array: <TItem extends unknown, TLastSchemaValues extends Record<string, unknown> = {}>(...rules: ValidationRule<TItem[], TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;

package/boolean/boolean.d.ts

@@ -10,11 +10,4 @@ import { ValidationRule } from '../core';
  *  validate(true);
  * ```
  */
-export declare const boolean: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<boolean, TLastSchemaValues>[]) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
-    define(overridesDefOptions: Partial<{}> & {
-        requiredErrorMessage?: string | undefined;
-        typeErrorMessage?: string | undefined;
-        isOptional?: boolean | undefined;
-    }): any;
-};
+export declare const boolean: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<boolean, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;

package/core/composeAsync/composeAsync.d.ts

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

package/core/composeAsync/composeAsync.js

@@ -0,0 +1,24 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { callAsyncRule, } from '../rule';
+/**
+ * Объединяет переданные асинхронные правила в цепочку правил, останавливает выполнение цепочки, если появилась ошибка. Выполняет правила слева направо
+ * @example composeAsync(stringAsync(), max());
+ */
+export const composeAsync = (...rules) => (value, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    let result;
+    for (const rule of rules) {
+        result = yield callAsyncRule(rule, value, ctx);
+        if (result) {
+            break;
+        }
+    }
+    return result;
+});

package/core/composeAsync/index.d.ts

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

package/core/composeAsync/index.js

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

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

@@ -1,8 +1,19 @@
+import { DeepPartial } from 'utility-types';
 import { ValidationContext } from '../types';
 import { ValidationTypes } from '../../types';
+type Params<TLastSchemaValues extends Record<string, unknown>> = {
+    /**
+     * Value последнего валидируемого объекта
+     */
+    lastSchemaValue?: DeepPartial<TLastSchemaValues>;
+    /**
+     * Позволяет создать ctx, в котором будет соответсвующий isOptional
+     */
+    isOptional?: boolean;
+};
 /**
  * @description Создает context валидации. Используется внутри фабрик guard и rule
  * @default по-дефолту сбрасывает все флаги в false
  */
-export declare function createContext<TValue extends ValidationTypes>(prevCtx: ValidationContext<{}, TValue> | undefined, value: TValue): ValidationContext<{}, TValue>;
-export declare function createContext<TValue extends ValidationTypes, TLastSchemaValues extends Record<string, unknown>>(prevCtx: ValidationContext<{}> | undefined, value: TValue, lastSchemaValue: TLastSchemaValues): ValidationContext<TLastSchemaValues, TValue>;
+export declare function createContext<TValue extends ValidationTypes, TLastSchemaValues extends Record<string, unknown> = {}>(prevCtx: ValidationContext<Record<string, unknown>> | undefined, value: TValue, { lastSchemaValue, isOptional }?: Params<TLastSchemaValues>): ValidationContext<TLastSchemaValues>;
+export {};

package/core/context/createContext/createContext.js

@@ -1,20 +1,21 @@
 import { createSimpleError } from '../../errors';
-export function createContext(prevCtx, value, lastSchemaValue) {
-    if (prevCtx && !lastSchemaValue) {
-        return prevCtx;
-    }
-    const currentLastSchemaValue = lastSchemaValue ? lastSchemaValue : undefined;
+/**
+ * @description Создает context валидации. Используется внутри фабрик guard и rule
+ * @default по-дефолту сбрасывает все флаги в false
+ */
+export function createContext(prevCtx, value, { lastSchemaValue, isOptional } = {}) {
     if (prevCtx) {
-        return Object.assign(Object.assign({}, prevCtx), { values: currentLastSchemaValue });
+        return Object.assign(Object.assign({}, prevCtx), { isOptional: isOptional !== null && isOptional !== void 0 ? isOptional : prevCtx.isOptional, values: lastSchemaValue || prevCtx.values });
     }
     return {
-        values: currentLastSchemaValue,
+        values: lastSchemaValue,
         global: {
             values: value,
             overrides: {
                 objectIsPartial: false,
             },
         },
+        isOptional: isOptional !== null && isOptional !== void 0 ? isOptional : false,
         createError: createSimpleError,
     };
 }

package/core/context/types.d.ts

@@ -11,7 +11,7 @@ export type ValidationContext<TLastSchemaValues extends Record<string, unknown>
     /**
      * @description Глобальные значения, идущие от самого верхнего правила к самому нижнему
      */
-    global: {
+    global: DeepReadonly<{
         /**
          * @description Значения, которые валидируется guard самого высоко порядка
          */
@@ -25,9 +25,13 @@ export type ValidationContext<TLastSchemaValues extends Record<string, unknown>
              */
             objectIsPartial: boolean;
         };
-    };
+    }>;
     /**
      * @description Фабрика ошибок. Возвращает новую ошибку валидации
      */
     createError: typeof createSimpleError;
+    /**
+     * @description Флаг, позволяющий отключать в guard'ах required правило. Первый guard, который примет isOptional===true сбросит его
+     */
+    isOptional: boolean;
 }>;

package/core/errors/constants.d.ts

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

package/core/errors/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from './createErrorCode';
+export const REJECT_PROMISE_ERROR_INFO = {
+    code: createErrorCode('reject-promise'),
+    message: 'Неизвестная ошибка',
+};

package/core/errors/index.d.ts

@@ -3,3 +3,4 @@ export * from './ArrayError';
 export * from './ErrorMap';
 export * from './types';
 export * from './createErrorCode';
+export * from './constants';

package/core/errors/index.js

@@ -3,3 +3,4 @@ export * from './ArrayError';
 export * from './ErrorMap';
 export * from './types';
 export * from './createErrorCode';
+export * from './constants';

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

@@ -1,6 +1,6 @@
 import { ValidationResult } from '../../types';
 import { ValidationContext } from '../../context';
-type DefOptions<AddDefOptions extends Record<string, unknown>> = Partial<AddDefOptions> & {
+export type GuardDefOptions<AddDefOptions extends Record<string, unknown>> = Partial<AddDefOptions> & {
     /**
      * @description Переопределяет дефолтное сообщения ошибки для required
      * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
@@ -17,7 +17,7 @@ type DefOptions<AddDefOptions extends Record<string, unknown>> = Partial<AddDefO
      */
     isOptional?: boolean;
 };
-type GuardValue = unknown;
+export type GuardValue = unknown;
 /**
  * @description Интерфейс функции guard, которая в прототипе содержит метод define
  */
@@ -28,12 +28,28 @@ export interface Guard<TLastSchemaValues extends Record<string, unknown> = {}, A
      * @param options - параметры, позволяющие переопределить дефолтные настройки guard
      * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
      */
-    define(options: DefOptions<AddDefOptions>): Guard<TLastSchemaValues, AddDefOptions>;
+    define(options: GuardDefOptions<AddDefOptions>): Guard<TLastSchemaValues, AddDefOptions>;
 }
+/**
+ * @description Интерфейс асинхронной функции guard, которая в прототипе содержит метод define
+ */
+export interface AsyncGuard<TLastSchemaValues extends Record<string, unknown> = {}, AddDefOptions extends Record<string, unknown> = {}> {
+    (value: GuardValue, ctx?: ValidationContext<TLastSchemaValues>): Promise<ValidationResult>;
+    /**
+     * @description Функция для создания нового guard с переопределенными дефолтными параметрами. Возвращает новый guard
+     * @param options - параметры, позволяющие переопределить дефолтные настройки guard
+     * @example string.define({ requiredMessage: 'ИНН не может быть пустым' })(inn())
+     */
+    define(options: GuardDefOptions<AddDefOptions>): AsyncGuard<TLastSchemaValues, AddDefOptions>;
+}
+/**
+ * @description Функция, которая позволяет определять частную логику для guard
+ */
+type GuardExecutor<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, defOptions: GuardDefOptions<AddDefOptions>) => ValidationResult;
 /**
  * @description Функция, которая позволяет определять частную логику для guard
  */
-type GuardExecutor<AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<Record<string, unknown>>, defOptions: DefOptions<AddDefOptions>) => ValidationResult;
+type AsyncGuardExecutor<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, defOptions: GuardDefOptions<AddDefOptions>) => Promise<ValidationResult>;
 /**
  * @description Создает guard. Guard - функция, проверяющая тип значения
  * По-дефолту проверяет value на required. Для выключения required необходимо использовать optional().
@@ -50,8 +66,6 @@ type GuardExecutor<AddDefOptions extends Record<string, unknown>> = (value: unkn
  *   });
  * ```
  */
-export declare const createGuard: <TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executeGuard: GuardExecutor<AddDefOptions>) => {
-    (value: unknown, prevCtx?: ValidationContext<TLastSchemaValues> | undefined): ValidationResult;
-    define(overridesDefOptions: DefOptions<AddDefOptions>): any;
-};
+export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executor: GuardExecutor<TLastSchemaValues, AddDefOptions>): Guard<TLastSchemaValues, AddDefOptions>;
+export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executor: AsyncGuardExecutor<TLastSchemaValues, AddDefOptions>): AsyncGuard<TLastSchemaValues, AddDefOptions>;
 export {};

package/core/guard/createGuard/createGuard.js

@@ -1,41 +1,26 @@
-import { REQUIRED_ERROR_INFO, required } from '../../rule';
+import { required } from '../../rule';
 import { createContext } from '../../context';
-import { compose } from '../../compose';
-/**
- * @description Создает guard. Guard - функция, проверяющая тип значения
- * По-дефолту проверяет value на required. Для выключения required необходимо использовать optional().
- * После первого вызова guard в прототипу функции становится доступен метод define, который позволяет переопределить дефолтное поведение guard (например, изменить текст для required правила)
- * @example
- * ```ts
- * const string = <TLastSchemaValues extends Record<string, unknown>>(...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 const createGuard = (executeGuard) => {
+export function createGuard(executor) {
     // выделено в отдельную именованную функцию для того, чтобы ее можно было рекурсивно вызывать в define
     const createInnerGuard = (defOptions = {}) => {
         const guard = (value, prevCtx) => {
+            const actualDefOptions = Object.assign(Object.assign({}, defOptions), { isOptional: (prevCtx === null || prevCtx === void 0 ? void 0 : prevCtx.isOptional) || defOptions.isOptional });
             const ctx = createContext(prevCtx, 
             // при создании контекста сейчас не имеет значение какого типа будет ctx.values
-            value);
-            const validationResult = compose(
-            // возможность переопределить дефолтный message для required
-            required({ message: defOptions === null || defOptions === void 0 ? void 0 : defOptions.requiredErrorMessage }), (interValue, interCtx) => executeGuard(interValue, interCtx, defOptions))(value, ctx);
-            // если включен isOptional режим и required упал с ошибкой, то необходимо проигнорировать ошибку
-            if ((defOptions === null || defOptions === void 0 ? void 0 : defOptions.isOptional) &&
-                (validationResult === null || validationResult === void 0 ? void 0 : validationResult.cause.code) === REQUIRED_ERROR_INFO.code) {
+            value, {
+                lastSchemaValue: value,
+                isOptional: false,
+            });
+            const requiredResult = required({
+                message: actualDefOptions === null || actualDefOptions === void 0 ? void 0 : actualDefOptions.requiredErrorMessage,
+            })(value, ctx);
+            if ((actualDefOptions === null || actualDefOptions === void 0 ? void 0 : actualDefOptions.isOptional) && requiredResult) {
                 return undefined;
             }
-            return validationResult;
+            return requiredResult || executor(value, ctx, actualDefOptions);
         };
         guard.define = (overridesDefOptions) => createInnerGuard(overridesDefOptions);
         return guard;
     };
     return createInnerGuard();
-};
+}

package/core/index.d.ts

@@ -5,4 +5,5 @@ export * from './errors';
 export * from './guard';
 export * from './rule';
 export * from './compose';
+export * from './composeAsync';
 export * from './utils';

package/core/index.js

@@ -5,4 +5,5 @@ export * from './errors';
 export * from './guard';
 export * from './rule';
 export * from './compose';
+export * from './composeAsync';
 export * from './utils';

package/core/logger/index.d.ts

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

package/core/logger/index.js

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

package/core/logger/logger.d.ts

@@ -0,0 +1,6 @@
+declare class Logger {
+    private packageName;
+    error: (message: string, err: Error) => void;
+}
+export declare const logger: Logger;
+export {};

package/core/logger/logger.js

@@ -0,0 +1,9 @@
+class Logger {
+    constructor() {
+        this.packageName = '@astral/validations';
+        this.error = (message, err) => {
+            console.error(`${this.packageName}: ${message}`, err);
+        };
+    }
+}
+export const logger = new Logger();

package/core/rule/callAsyncRule/callAsyncRule.d.ts

@@ -0,0 +1,8 @@
+import { AsyncValidationRule, ValidationRule } from '../types';
+import { ValidationResult } from '../../types';
+import { ValidationContext } from '../../context';
+/**
+ * Позволяет рекурсивно вызывать асинхронные правила. Rule может возвращать другой rule
+ * Если один из rule выбросит exception, то функция его обработает и вернет дефолтную ошибку
+ */
+export declare const callAsyncRule: <TValue, TLastSchemaValues extends Record<string, unknown>>(rule: ValidationRule<TValue, TLastSchemaValues> | AsyncValidationRule<TValue, TLastSchemaValues>, value: TValue, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult | Promise<ValidationResult>;

package/core/rule/callAsyncRule/callAsyncRule.js

@@ -0,0 +1,25 @@
+import { REJECT_PROMISE_ERROR_INFO } from '../../errors';
+import { logger } from '../../logger';
+/**
+ * Позволяет рекурсивно вызывать асинхронные правила. Rule может возвращать другой rule
+ * Если один из rule выбросит exception, то функция его обработает и вернет дефолтную ошибку
+ */
+export const callAsyncRule = (rule, value, ctx) => {
+    const ruleResult = rule(value, ctx);
+    if (ruleResult && 'then' in ruleResult) {
+        return ruleResult
+            .then((result) => {
+            if (typeof result === 'function') {
+                return callAsyncRule(result, value, ctx);
+            }
+            return result;
+        })
+            .catch((err) => {
+            logger.error('Ошибка при выполнении асинхронного правила', err);
+            return ctx.createError(REJECT_PROMISE_ERROR_INFO);
+        });
+    }
+    return typeof ruleResult === 'function'
+        ? callAsyncRule(ruleResult, value, ctx)
+        : ruleResult;
+};

package/core/rule/callAsyncRule/index.d.ts

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

package/core/rule/callAsyncRule/index.js

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

package/core/rule/index.d.ts

@@ -2,3 +2,4 @@ export * from './createRule';
 export * from './types';
 export * from './required';
 export * from './callRule';
+export * from './callAsyncRule';

package/core/rule/index.js

@@ -2,3 +2,4 @@ export * from './createRule';
 export * from './types';
 export * from './required';
 export * from './callRule';
+export * from './callAsyncRule';

package/core/rule/types.d.ts

@@ -4,10 +4,18 @@ import { ValidationResult } from '../types';
  * @description Самостоятельное правило для валидации. Может использоваться вне guard'ов
  */
 export type IndependentValidationRule<TValue, TLastSchemaValues extends Record<string, unknown>> = (value: TValue, ctx?: ValidationContext<TLastSchemaValues>) => ValidationResult;
+/**
+ * @description Самостоятельное асинхронное правило для валидации. Может использоваться вне guard'ов
+ */
+export type AsyncIndependentValidationRule<TValue, TLastSchemaValues extends Record<string, unknown>> = (value: TValue, ctx?: ValidationContext<TLastSchemaValues>) => Promise<ValidationResult>;
 /**
  * @description Правило для валидации, работающее исключительно с guard'ами
  */
 export type ValidationRule<TValue, TLastSchemaValues extends Record<string, unknown> = {}> = (value: TValue, ctx: ValidationContext<TLastSchemaValues>) => ValidationResult | ValidationRule<TValue, TLastSchemaValues>;
+/**
+ * @description Асинхронное правило для валидации, работающее исключительно с guard'ами
+ */
+export type AsyncValidationRule<TValue, TLastSchemaValues extends Record<string, unknown> = {}> = (value: TValue, ctx: ValidationContext<TLastSchemaValues>) => Promise<ValidationResult | AsyncValidationRule<TValue, TLastSchemaValues> | ValidationRule<TValue, TLastSchemaValues>>;
 /**
  * @description Композиционное правило валидации, умеющее работать с любыми значениями.
  * В основном используется для композиционных правил, которые принимают rule, умеющие валидировать разные значения (optional, transform...)

package/date/date.d.ts

@@ -15,12 +15,5 @@ type AdditionalDefOptions = {
  *  validate(new Date('22.22.2022'));
  * ```
  */
-export declare const date: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<Date, TLastSchemaValues>[]) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
-    define(overridesDefOptions: Partial<AdditionalDefOptions> & {
-        requiredErrorMessage?: string | undefined;
-        typeErrorMessage?: string | undefined;
-        isOptional?: boolean | undefined;
-    }): any;
-};
+export declare const date: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<Date, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, AdditionalDefOptions>;
 export {};

package/index.d.ts

@@ -1,6 +1,6 @@
-export { object, OBJECT_TYPE_ERROR_INFO, type Schema, type SchemaValue, type ObjectGuard, } from './object';
+export { object, objectAsync, OBJECT_TYPE_ERROR_INFO, type Schema, type SchemaValue, type ObjectGuard, type ObjectAsyncGuard, } from './object';
 export { optional } from './optional';
-export { string, STRING_TYPE_ERROR_INFO } from './string';
+export { string, STRING_TYPE_ERROR_INFO, stringAsync } from './string';
 export { date, INVALID_DATE_ERROR_INFO, DATE_TYPE_ERROR_INFO } from './date';
 export { number, NAN_NUMBER_ERROR_INFO, NUMBER_TYPE_ERROR_INFO, INFINITY_NUMBER_ERROR_INFO, } from './number';
 export { boolean, BOOLEAN_TYPE_ERROR_INFO } from './boolean';

package/index.js

@@ -1,6 +1,6 @@
-export { object, OBJECT_TYPE_ERROR_INFO, } from './object';
+export { object, objectAsync, OBJECT_TYPE_ERROR_INFO, } from './object';
 export { optional } from './optional';
-export { string, STRING_TYPE_ERROR_INFO } from './string';
+export { string, STRING_TYPE_ERROR_INFO, stringAsync } from './string';
 export { date, INVALID_DATE_ERROR_INFO, DATE_TYPE_ERROR_INFO } from './date';
 export { number, NAN_NUMBER_ERROR_INFO, NUMBER_TYPE_ERROR_INFO, INFINITY_NUMBER_ERROR_INFO, } from './number';
 export { boolean, BOOLEAN_TYPE_ERROR_INFO } from './boolean';

package/number/number.d.ts

@@ -15,12 +15,5 @@ type AdditionalDefOptions = {
  *  validate(24);
  * ```
  */
-export declare const number: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<number, TLastSchemaValues>[]) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
-    define(overridesDefOptions: Partial<AdditionalDefOptions> & {
-        requiredErrorMessage?: string | undefined;
-        typeErrorMessage?: string | undefined;
-        isOptional?: boolean | undefined;
-    }): any;
-};
+export declare const number: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<number, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, AdditionalDefOptions>;
 export {};

package/object/index.d.ts

@@ -1,2 +1,3 @@
 export * from './object';
 export * from './constants';
+export * from './objectAsync';

package/object/index.js

@@ -1,2 +1,3 @@
 export * from './object';
 export * from './constants';
+export * from './objectAsync';

package/object/object.d.ts

@@ -44,13 +44,6 @@ export type Schema<TValue extends Record<string, unknown>> = Record<keyof TValue
  * });
  * ```
  */
-export declare const object: <TValue extends Record<string, unknown>, TLastSchemaValues extends Record<string, unknown> = {}>(schema: Schema<TValue>) => {
-    (value: unknown, prevCtx?: ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
-    define(overridesDefOptions: Partial<AdditionalDefOptions> & {
-        requiredErrorMessage?: string | undefined;
-        typeErrorMessage?: string | undefined;
-        isOptional?: boolean | undefined;
-    }): any;
-};
+export declare const object: <TValue extends Record<string, unknown>, TLastSchemaValues extends Record<string, unknown> = {}>(schema: Schema<TValue>) => Guard<TLastSchemaValues, AdditionalDefOptions>;
 export type ObjectGuard<TValue extends Record<string, unknown>> = ReturnType<typeof object<TValue>>;
 export {};

package/object/object.js

@@ -27,7 +27,9 @@ import { OBJECT_TYPE_ERROR_INFO } from './constants';
  * ```
  */
 export const object = (schema) => createGuard((value, ctx, { typeErrorMessage, isPartial }) => {
-    const context = createContext(ctx, value, value);
+    const context = createContext(ctx, value, {
+        lastSchemaValue: value,
+    });
     if (!isPlainObject(value)) {
         return context.createError(Object.assign(Object.assign({}, OBJECT_TYPE_ERROR_INFO), { message: typeErrorMessage || OBJECT_TYPE_ERROR_INFO.message }));
     }

package/object/objectAsync/index.d.ts

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

package/object/objectAsync/index.js

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

package/object/objectAsync/objectAsync.d.ts

@@ -0,0 +1,61 @@
+import { AsyncGuard, AsyncValidationRule, Guard, ValidationContext, ValidationRule } from '../../core';
+/**
+ * @description Специальный итерфейс Guard для object. В данном интерфейсе ctx required
+ * Переопределение необходимо для того, чтобы ts показывал, что ctx required в кастомных правилах
+ */
+interface ObjectPropGuard<TLastSchemaValues extends Record<string, unknown>> {
+    (value: Parameters<Guard<TLastSchemaValues>>[0], ctx: ValidationContext<TLastSchemaValues>): ReturnType<Guard<TLastSchemaValues>>;
+    define: Guard<TLastSchemaValues>['define'];
+}
+interface AsyncObjectPropGuard<TLastSchemaValues extends Record<string, unknown>> {
+    (value: Parameters<Guard<TLastSchemaValues>>[0], ctx: ValidationContext<TLastSchemaValues>): ReturnType<AsyncGuard<TLastSchemaValues>>;
+    define: AsyncGuard<TLastSchemaValues>['define'];
+}
+type AdditionalDefOptions = {
+    /**
+     * @description Делает все свойства объекта partial
+     */
+    isPartial?: boolean;
+};
+/**
+ * @description Возможные значения, принимаемые схемой
+ */
+export type AsyncSchemaValue<TValue extends Record<string, unknown>> = ObjectPropGuard<TValue> | AsyncObjectPropGuard<TValue> | ValidationRule<unknown, TValue> | AsyncValidationRule<unknown, TValue>;
+/**
+ * @description Схема правил валдиации для объекта
+ */
+export type AsyncSchema<TValue extends Record<string, unknown>> = Record<keyof TValue, AsyncSchemaValue<TValue>>;
+/**
+ * @description Guard для объекта, который поддерживает асинхронную валидацию
+ * @example
+ * ```ts
+ * type Values = {
+ *   name: string;
+ *   age?: number;
+ *   info: { surname: string };
+ * };
+ *
+ * const values: Values = { name: 'Vasya', info: { surname: 'Vasin' } };
+ *
+ * const validateObject = objectAsync<Values>({
+ *   name: string(min(2), async (value, ctx) => {
+ *     const result = await validateName(value);
+ *
+ *     return result.isInvalid
+ *       ? ctx.createError({
+ *           message: 'Имя занято',
+ *           code: 'name-is-not-available',
+ *         })
+ *       : undefined;
+ *   }),
+ *   age: optional(number()),
+ *   info: object<Values['info']>({ surname: string(min(2)) }),
+ *   customField: (value, ctx) => {
+ *     return ctx.createError({ message: 'error', code: 'custom error' });
+ *   },
+ * });
+ * ```
+ */
+export declare const objectAsync: <TValue extends Record<string, unknown>, TLastSchemaValues extends Record<string, unknown> = {}>(schema: AsyncSchema<TValue>) => AsyncGuard<TLastSchemaValues, AdditionalDefOptions>;
+export type ObjectAsyncGuard<TValue extends Record<string, unknown>> = ReturnType<typeof objectAsync<TValue>>;
+export {};

package/object/objectAsync/objectAsync.js

@@ -0,0 +1,73 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import isPlainObject from 'is-plain-obj';
+import { callAsyncRule as callAsyncRecursiveRule, createContext, createErrorMap, createGuard, } from '../../core';
+import { optional } from '../../optional';
+import { isEmptyErrors } from '../isEmptyErrors';
+import { OBJECT_TYPE_ERROR_INFO } from '../constants';
+// TODO: необходимо реализовать переиспользование логики между object и objectAsync
+/**
+ * @description Guard для объекта, который поддерживает асинхронную валидацию
+ * @example
+ * ```ts
+ * type Values = {
+ *   name: string;
+ *   age?: number;
+ *   info: { surname: string };
+ * };
+ *
+ * const values: Values = { name: 'Vasya', info: { surname: 'Vasin' } };
+ *
+ * const validateObject = objectAsync<Values>({
+ *   name: string(min(2), async (value, ctx) => {
+ *     const result = await validateName(value);
+ *
+ *     return result.isInvalid
+ *       ? ctx.createError({
+ *           message: 'Имя занято',
+ *           code: 'name-is-not-available',
+ *         })
+ *       : undefined;
+ *   }),
+ *   age: optional(number()),
+ *   info: object<Values['info']>({ surname: string(min(2)) }),
+ *   customField: (value, ctx) => {
+ *     return ctx.createError({ message: 'error', code: 'custom error' });
+ *   },
+ * });
+ * ```
+ */
+export const objectAsync = (schema) => createGuard((value, ctx, { typeErrorMessage, isPartial }) => __awaiter(void 0, void 0, void 0, function* () {
+    const context = createContext(ctx, value, {
+        lastSchemaValue: value,
+    });
+    if (!isPlainObject(value)) {
+        return context.createError(Object.assign(Object.assign({}, OBJECT_TYPE_ERROR_INFO), { message: typeErrorMessage || OBJECT_TYPE_ERROR_INFO.message }));
+    }
+    const generateErrorMap = () => __awaiter(void 0, void 0, void 0, function* () {
+        const schemaEntries = Object.entries(schema);
+        const isOptional = context.global.overrides.objectIsPartial || isPartial;
+        const results = yield Promise.all(schemaEntries.map(([key, rule]) => {
+            const isGuard = 'define' in rule;
+            const callRule = isGuard && isOptional ? optional(rule) : rule;
+            return callAsyncRecursiveRule(callRule, value[key], context);
+        }));
+        return results.reduce((errorMap, validationResult, index) => {
+            const [key] = schemaEntries[index];
+            errorMap[key] = validationResult;
+            return errorMap;
+        }, {});
+    });
+    const errorMap = yield generateErrorMap();
+    if (!isEmptyErrors(errorMap)) {
+        return createErrorMap(errorMap);
+    }
+    return undefined;
+}));

package/optional/optional.d.ts

@@ -1,7 +1,6 @@
-import { Guard } from '../core';
+import { IndependentValidationRule, ValidationRule } from '../core';
 /**
  * @description Выключает проверку на required в guard
- * @param guard - правило, проверяющее тип значения
  * @example object({ name: optional(string(min(22))) })
  */
-export declare const optional: <TLastSchemaValues extends Record<string, unknown>>(guard: Guard<TLastSchemaValues, {}>) => Guard<TLastSchemaValues, {}>;
+export declare const optional: <TLastSchemaValues extends Record<string, unknown>>(rule: ValidationRule<unknown, TLastSchemaValues>) => IndependentValidationRule<unknown, TLastSchemaValues>;

package/optional/optional.js

@@ -1,6 +1,6 @@
+import { callRule, createContext, } from '../core';
 /**
  * @description Выключает проверку на required в guard
- * @param guard - правило, проверяющее тип значения
  * @example object({ name: optional(string(min(22))) })
  */
-export const optional = (guard) => guard.define({ isOptional: true });
+export const optional = (rule) => (value, ctx) => callRule(rule, value, createContext(ctx, value, { isOptional: true }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astral/validations",
-  "version": "4.6.1",
+  "version": "4.8.0",
   "browser": "./index.js",
   "main": "./index.js",
   "dependencies": {

package/partial/partial.d.ts

@@ -4,13 +4,6 @@ import { object } from '../object';
  * @param objectGuard
  * @example partial(object({ name: string() }))
  */
-export declare const partial: (objectGuard: ReturnType<typeof object>) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<Record<string, unknown>> | undefined): import("../core").ValidationResult;
-    define(overridesDefOptions: Partial<{
-        isPartial?: boolean | undefined;
-    }> & {
-        requiredErrorMessage?: string | undefined;
-        typeErrorMessage?: string | undefined;
-        isOptional?: boolean | undefined;
-    }): any;
-};
+export declare const partial: (objectGuard: ReturnType<typeof object>) => import("../core").Guard<Record<string, unknown>, {
+    isPartial?: boolean | undefined;
+}>;

package/string/index.d.ts

@@ -1,2 +1,3 @@
 export * from './string';
+export * from './stringAsync';
 export * from './constants';

package/string/index.js

@@ -1,2 +1,3 @@
 export * from './string';
+export * from './stringAsync';
 export * from './constants';

package/string/string.d.ts

@@ -1,9 +1,2 @@
 import { ValidationRule } from '../core';
-export declare const string: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<string, TLastSchemaValues>[]) => {
-    (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined): import("../core").ValidationResult;
-    define(overridesDefOptions: Partial<{}> & {
-        requiredErrorMessage?: string | undefined;
-        typeErrorMessage?: string | undefined;
-        isOptional?: boolean | undefined;
-    }): any;
-};
+export declare const string: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<string, TLastSchemaValues>[]) => import("../core").Guard<TLastSchemaValues, {}>;

package/string/string.js

@@ -1,7 +1,8 @@
 import { compose, createGuard } from '../core';
 import { STRING_TYPE_ERROR_INFO } from './constants';
+import { isString } from './utils';
 export const string = (...rules) => createGuard((value, ctx, { typeErrorMessage }) => {
-    if (typeof value !== 'string') {
+    if (!isString(value)) {
         return ctx.createError(Object.assign(Object.assign({}, STRING_TYPE_ERROR_INFO), { message: typeErrorMessage || STRING_TYPE_ERROR_INFO.message }));
     }
     return compose(...rules)(value, ctx);

package/string/stringAsync/index.d.ts

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

package/string/stringAsync/index.js

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

package/string/stringAsync/stringAsync.d.ts

@@ -0,0 +1,6 @@
+import { AsyncValidationRule, ValidationRule } from '../../core';
+/**
+ * Позволяет использовать для валидации асинхронные правила
+ * @example stringAsync(async () => undefined)
+ */
+export declare const stringAsync: <TLastSchemaValues extends Record<string, unknown>>(...rules: (ValidationRule<string, TLastSchemaValues> | AsyncValidationRule<string, TLastSchemaValues>)[]) => import("../../core").AsyncGuard<TLastSchemaValues, {}>;

package/string/stringAsync/stringAsync.js

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { composeAsync, createGuard, } from '../../core';
+import { isString } from '../utils';
+import { STRING_TYPE_ERROR_INFO } from '../constants';
+// TODO: необходимо реализовать переиспользование логики между string и stringAsync
+/**
+ * Позволяет использовать для валидации асинхронные правила
+ * @example stringAsync(async () => undefined)
+ */
+export const stringAsync = (...rules) => createGuard((value, ctx, { typeErrorMessage }) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isString(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, STRING_TYPE_ERROR_INFO), { message: typeErrorMessage || STRING_TYPE_ERROR_INFO.message }));
+    }
+    return composeAsync(...rules)(value, ctx);
+}));

package/string/utils/index.d.ts

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

package/string/utils/index.js

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

package/string/utils/isString/index.d.ts

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

package/string/utils/isString/index.js

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

package/string/utils/isString/isString.d.ts

@@ -0,0 +1 @@
+export declare const isString: (value: unknown) => value is string;

package/string/utils/isString/isString.js

@@ -0,0 +1 @@
+export const isString = (value) => typeof value === 'string';