@astral/validations 4.7.0 → 4.8.1

package/README.md

@@ -1364,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. Условная валидация
@@ -1471,6 +1491,7 @@ validate(new Date())
 Guard, поддерживающие асинхронную валидацию имеют постфиксы ```async```:
 - ```objectAsync```
 - ```stringAsync```
+- ```optionalAsync```
 
 Пример:
 
@@ -1494,9 +1515,21 @@ const validate = objectAsync<Values>({
             message: 'Nickname занят',
         });
     }),
+    fullName: optionalAsync(stringAsync(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' });
+const result = await validate({ phone: '79308999999', nickname: 'Vasya', fullName: '' });
 
 // { nickname: 'Nickname занят' }
 toPrettyError(result);

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

@@ -1,6 +1,23 @@
 import { ValidationResult } from '../../types';
 import { ValidationContext } from '../../context';
-import { GuardDefOptions, GuardValue } from '../types';
+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;
 /**
  * @description Интерфейс функции guard, которая в прототипе содержит метод define
  */
@@ -28,11 +45,11 @@ export interface AsyncGuard<TLastSchemaValues extends Record<string, unknown> =
 /**
  * @description Функция, которая позволяет определять частную логику для guard
  */
-type GuardExecutor<AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<Record<string, unknown>>, defOptions: GuardDefOptions<AddDefOptions>) => ValidationResult;
+type GuardExecutor<TLastSchemaValues extends Record<string, unknown>, AddDefOptions extends Record<string, unknown>> = (value: unknown, ctx: ValidationContext<TLastSchemaValues>, 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>;
+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().
@@ -49,6 +66,6 @@ type AsyncGuardExecutor<AddDefOptions extends Record<string, unknown>> = (value:
  *   });
  * ```
  */
-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 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

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

package/index.d.ts

@@ -1,5 +1,5 @@
 export { object, objectAsync, OBJECT_TYPE_ERROR_INFO, type Schema, type SchemaValue, type ObjectGuard, type ObjectAsyncGuard, } from './object';
-export { optional } from './optional';
+export { optional, optionalAsync } from './optional';
 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';

package/index.js

@@ -1,5 +1,5 @@
 export { object, objectAsync, OBJECT_TYPE_ERROR_INFO, } from './object';
-export { optional } from './optional';
+export { optional, optionalAsync } from './optional';
 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';

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/objectAsync.js

@@ -45,7 +45,9 @@ import { OBJECT_TYPE_ERROR_INFO } from '../constants';
  * ```
  */
 export const objectAsync = (schema) => createGuard((value, ctx, { typeErrorMessage, isPartial }) => __awaiter(void 0, void 0, void 0, function* () {
-    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/optional/index.d.ts

@@ -1 +1,2 @@
 export * from './optional';
+export * from './optionalAsync';

package/optional/index.js

@@ -1 +1,2 @@
 export * from './optional';
+export * from './optionalAsync';

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/optional/optionalAsync/index.d.ts

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

package/optional/optionalAsync/index.js

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

package/optional/optionalAsync/optionalAsync.d.ts

@@ -0,0 +1,6 @@
+import { AsyncIndependentValidationRule, AsyncValidationRule } from '../../core';
+/**
+ * @description Выключает проверку на required в guard. Предназначен для асинхронных правил.
+ * @example object({ name: optionalAsync(stringAsync(min(22))) })
+ */
+export declare const optionalAsync: <TLastSchemaValues extends Record<string, unknown>>(rule: AsyncValidationRule<unknown, TLastSchemaValues>) => AsyncIndependentValidationRule<unknown, TLastSchemaValues>;

package/optional/optionalAsync/optionalAsync.js

@@ -0,0 +1,18 @@
+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, createContext, } from '../../core';
+// TODO: необходимо добавить возможность использовать вложенные guards
+/**
+ * @description Выключает проверку на required в guard. Предназначен для асинхронных правил.
+ * @example object({ name: optionalAsync(stringAsync(min(22))) })
+ */
+export const optionalAsync = (rule) => (value, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    return callAsyncRule(rule, value, createContext(ctx, value, { isOptional: true }));
+});

package/package.json

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

package/core/guard/types.d.ts

@@ -1,18 +0,0 @@
-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

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