@astral/validations 4.7.0 → 4.8.0

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. Условная валидация

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/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/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.7.0",
+  "version": "4.8.0",
   "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 {};