@astral/validations 4.6.0 → 4.7.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)
@@ -1464,6 +1465,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/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,23 +1,6 @@
 import { ValidationResult } 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 = unknown;
+import { GuardDefOptions, GuardValue } from '../types';
 /**
  * @description Интерфейс функции guard, которая в прототипе содержит метод define
  */
@@ -28,12 +11,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<AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<Record<string, unknown>>, defOptions: DefOptions<AddDefOptions>) => ValidationResult;
+type GuardExecutor<AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<Record<string, unknown>>, defOptions: GuardDefOptions<AddDefOptions>) => ValidationResult;
+/**
+ * @description Функция, которая позволяет определять частную логику для guard
+ */
+type AsyncGuardExecutor<AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<Record<string, unknown>>, defOptions: GuardDefOptions<AddDefOptions>) => Promise<ValidationResult>;
 /**
  * @description Создает guard. Guard - функция, проверяющая тип значения
  * По-дефолту проверяет value на required. Для выключения required необходимо использовать optional().
@@ -50,8 +49,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<AddDefOptions>): Guard<TLastSchemaValues, AddDefOptions>;
+export declare function createGuard<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown> = {}>(executor: AsyncGuardExecutor<AddDefOptions>): AsyncGuard<TLastSchemaValues, AddDefOptions>;
 export {};

package/core/guard/createGuard/createGuard.js

@@ -1,41 +1,22 @@
-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 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) {
+            const requiredResult = required({
+                message: defOptions === null || defOptions === void 0 ? void 0 : defOptions.requiredErrorMessage,
+            })(value, ctx);
+            if ((defOptions === null || defOptions === void 0 ? void 0 : defOptions.isOptional) && requiredResult) {
                 return undefined;
             }
-            return validationResult;
+            return requiredResult || executor(value, ctx, defOptions);
         };
         guard.define = (overridesDefOptions) => createInnerGuard(overridesDefOptions);
         return guard;
     };
     return createInnerGuard();
-};
+}

package/core/guard/types.d.ts

@@ -0,0 +1,18 @@
+export type GuardDefOptions<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;
+};
+export type GuardValue = unknown;

package/core/guard/types.js

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

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/max/max.d.ts

@@ -21,6 +21,6 @@ type MaxParams<ValidationType> = {
  *  date(max(new Date())));
  * ```
  */
-export declare function max<ValidationType extends Date>(threshold: Date, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<Date>>;
-export declare function max<ValidationType extends BaseMaxValidationTypes>(threshold: number, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<BaseMaxValidationTypes>>;
+export declare function max<ValidationType extends Date, TLastSchemaValues extends Record<string, unknown> = {}>(threshold: Date, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<Date, TLastSchemaValues>>;
+export declare function max<ValidationType extends BaseMaxValidationTypes, TLastSchemaValues extends Record<string, unknown> = {}>(threshold: number, params?: MaxParams<ValidationType>): ReturnType<typeof createRule<BaseMaxValidationTypes, TLastSchemaValues>>;
 export {};

package/min/min.d.ts

@@ -21,6 +21,6 @@ type MinParams<ValidationType> = {
  *  date(min(new Date())));
  * ```
  */
-export declare function min<ValidationType extends Date>(threshold: Date, params?: MinParams<ValidationType>): ReturnType<typeof createRule<Date>>;
-export declare function min<ValidationType extends BaseMinValidationTypes>(threshold: number, params?: MinParams<ValidationType>): ReturnType<typeof createRule<BaseMinValidationTypes>>;
+export declare function min<ValidationType extends Date, TLastSchemaValues extends Record<string, unknown> = {}>(threshold: Date, params?: MinParams<ValidationType>): ReturnType<typeof createRule<Date, TLastSchemaValues>>;
+export declare function min<ValidationType extends BaseMinValidationTypes, TLastSchemaValues extends Record<string, unknown> = {}>(threshold: number, params?: MinParams<ValidationType>): ReturnType<typeof createRule<BaseMinValidationTypes, TLastSchemaValues>>;
 export {};

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/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,71 @@
+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, 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astral/validations",
-  "version": "4.6.0",
+  "version": "4.7.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';