@astral/validations 4.4.0 → 4.6.0

package/README.md

@@ -59,6 +59,7 @@
   - [Связанные поля](#связанные-поля)
   - [Доступ к ctx.global.values](#доступ-к-высокоуровневым-values-ctxglobalvalues)
   - [Переиспользуемое правило](#переиспользуемое-правило)
+  - [Кастомная условная валидация](#кастомная-условная-валидация)
 - [Common](#common)
   - [optional](#optional)
   - [when. Условная валидация](#when-условная-валидация)
@@ -1119,7 +1120,7 @@ validate([1, 2]);
 
 ## any
 
-Позволяет выключить любые проверки.
+Позволяет выключить любые проверки и делать композицию для правил, валидирующих любые значения.
 
 ```ts
 type Values = { name: string; isAgree: boolean };
@@ -1141,8 +1142,15 @@ toPrettyError(
   validate({ isAgree: true, name: '' })
 );
 ```
+```ts
+  const validate = any(transform((value) => new Date(value), date()));
 
----
+// undefined
+validate('12.22.2022');
+
+// invalid date error
+validate('13.22.2022');
+```
 
 ## Define. Переопределение дефолтных параметров guard
 
@@ -1294,6 +1302,34 @@ validate('Hello');
 includesWorld()('Hello')
 ```
 
+## Кастомная условная валидация
+
+Для условной валидации рекомендуется использовать [when](#when-условная-валидация), но также доступна возможность реализации кастомной условной валидации.
+
+```ts
+import { object, string, boolean, optional } from '@astral/validations';
+
+type Values = {
+  isAgree: boolean;
+  info: {
+    name: string
+  }
+};
+
+const validate = object<Values>({
+  isAgree: optional(boolean()),
+  info: object<Values['info']>({
+    name: (value, ctx) => {
+      if(ctx.global.values?.isAgree) {
+        return string();
+      }
+      
+      return any();
+    }
+  })
+});
+```
+
 ---
 
 # Common

package/any/any.d.ts

@@ -1,5 +1,7 @@
+import { ValidationRule } from '../core';
 /**
- * @description Выключает любые проверки
+ * @description Выключает любые проверки и валидирует value
+ * @param rules - правила, валидирующие любые значения
  * @example
  * ```ts
  *   type Values = { name: string; surname?: string };
@@ -9,5 +11,13 @@
  *   // undefined
  *   validate({});
  * ```
+ *   const validate = any(transform((value) => new Date(value), date()));
+ *
+ *    // undefined
+ *    validate('12.22.2022');
+ *
+ *    // invalid date error
+ *    validate('13.22.2022');
+ * ```
  */
-export declare const any: <TLastSchemaValues extends Record<string, unknown>>() => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export declare const any: <TLastSchemaValues extends Record<string, unknown>>(...rules: ValidationRule<unknown, TLastSchemaValues>[]) => (value: unknown, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;

package/any/any.js

@@ -1,6 +1,7 @@
-import { createRule } from '../core';
+import { compose, createRule } from '../core';
 /**
- * @description Выключает любые проверки
+ * @description Выключает любые проверки и валидирует value
+ * @param rules - правила, валидирующие любые значения
  * @example
  * ```ts
  *   type Values = { name: string; surname?: string };
@@ -10,5 +11,15 @@ import { createRule } from '../core';
  *   // undefined
  *   validate({});
  * ```
+ *   const validate = any(transform((value) => new Date(value), date()));
+ *
+ *    // undefined
+ *    validate('12.22.2022');
+ *
+ *    // invalid date error
+ *    validate('13.22.2022');
+ * ```
  */
-export const any = () => createRule(() => undefined);
+export const any = (...rules) => createRule((value, ctx) => {
+    return compose(...rules)(value, ctx);
+});

package/core/compose/compose.js

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

package/core/rule/callRule/callRule.d.ts

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

package/core/rule/callRule/callRule.js

@@ -0,0 +1,9 @@
+/**
+ * Позволяет рекурсивно вызывать правила. Rule может возвращать другой rule
+ */
+export const callRule = (rule, value, ctx) => {
+    const ruleResult = rule(value, ctx);
+    return typeof ruleResult === 'function'
+        ? callRule(ruleResult, value, ctx)
+        : ruleResult;
+};

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

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

package/core/rule/callRule/index.js

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

package/core/rule/index.d.ts

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

package/core/rule/index.js

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

package/core/rule/types.d.ts

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

package/object/object.js

@@ -1,5 +1,5 @@
 import isPlainObject from 'is-plain-obj';
-import { createContext, createErrorMap, createGuard, } from '../core';
+import { callRule as callRecursiveRule, createContext, createErrorMap, createGuard, } from '../core';
 import { optional } from '../optional';
 import { isEmptyErrors } from './isEmptyErrors';
 import { OBJECT_TYPE_ERROR_INFO } from './constants';
@@ -37,7 +37,7 @@ export const object = (schema) => createGuard((value, ctx, { typeErrorMessage, i
         return schemaEntries.reduce((errorMap, [key, rule]) => {
             const isGuard = 'define' in rule;
             const callRule = isGuard && isOptional ? optional(rule) : rule;
-            errorMap[key] = callRule(value[key], context);
+            errorMap[key] = callRecursiveRule(callRule, value[key], context);
             return errorMap;
         }, {});
     };

package/or/or.js

@@ -1,4 +1,4 @@
-import { createRule } from '../core';
+import { callRule, createRule, } from '../core';
 /**
  * @description Выполняет переданные правила аналогично оператору ||. Если одно из правил не завершилось ошибкой, то or вернет undefined
  * Если все переданные правила завершились с ошибкой, то вернется ошибка из последнего правила
@@ -14,7 +14,7 @@ import { createRule } from '../core';
 export const or = (...rules) => createRule((value, ctx) => {
     let result;
     rules.some((rule) => {
-        result = rule(value, ctx);
+        result = callRule(rule, value, ctx);
         return result ? false : true;
     });
     return result;

package/package.json

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

package/when/when.js

@@ -1,4 +1,4 @@
-import { createRule } from '../core';
+import { callRule, createRule, } from '../core';
 /**
  * @description Позволяет указывать условные валидации
  * @example
@@ -23,7 +23,7 @@ import { createRule } from '../core';
  */
 export const when = ({ is, then, otherwise, }) => createRule((value, ctx) => {
     if (is(value, ctx)) {
-        return then(value, ctx);
+        return callRule(then, value, ctx);
     }
-    return otherwise(value, ctx);
+    return callRule(otherwise, value, ctx);
 });