@astral/validations 4.3.0 → 4.5.0

package/README.md

@@ -25,6 +25,7 @@
     - [min](#min-string)
     - [max](#max-string)
     - [email](#email)
+    - [guid](#guid)
     - [pattern](#pattern)
     - [onlyNumber](#onlyNumber)
     - [snils](#snils)
@@ -58,6 +59,7 @@
   - [Связанные поля](#связанные-поля)
   - [Доступ к ctx.global.values](#доступ-к-высокоуровневым-values-ctxglobalvalues)
   - [Переиспользуемое правило](#переиспользуемое-правило)
+  - [Кастомная условная валидация](#кастомная-условная-валидация)
 - [Common](#common)
   - [optional](#optional)
   - [when. Условная валидация](#when-условная-валидация)
@@ -386,6 +388,25 @@ validateEmail('longlonglong.......')
 
 ---
 
+### guid
+
+Проверяет валиден ли GUID.
+
+```ts
+import { string, guid } from '@astral/validations';
+
+const validate = string(guid());
+
+// undefined
+validate('C56A4180-65AA-42EC-A945-5FD21DEC0538');
+
+
+// { message: 'Некорректный GUID' }
+validate('x56a4180-h5aa-42ec-a945-5fd21dec0538');
+```
+
+---
+
 ### pattern
 
 Проверяет строку на соответствие регулярному выражению.
@@ -1274,6 +1295,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/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/guid/constants.d.ts

@@ -0,0 +1,3 @@
+import { ErrorInfo } from '../core';
+export declare const GUID_REGEXP: RegExp;
+export declare const INVALID_GUID_ERROR_INFO: ErrorInfo;

package/guid/constants.js

@@ -0,0 +1,6 @@
+import { createErrorCode } from '../core';
+export const GUID_REGEXP = /^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/;
+export const INVALID_GUID_ERROR_INFO = {
+    code: createErrorCode('guid-invalid'),
+    message: 'Некорректный GUID',
+};

package/guid/guid.d.ts

@@ -0,0 +1,16 @@
+type GuidParams = {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет валидность GUID.
+ * @example
+ * ```ts
+ *  const validate = string(guid());
+ *  validate('C56A4180-65AA-42EC-A945-5FD21DEC0538');
+ * ```
+ */
+export declare const guid: <TLastSchemaValues extends Record<string, unknown>>(params?: GuidParams) => (value: string, prevCtx?: import("../core").ValidationContext<TLastSchemaValues> | undefined) => import("../core").ValidationResult;
+export {};

package/guid/guid.js

@@ -0,0 +1,16 @@
+import { createRule } from '../core';
+import { GUID_REGEXP, INVALID_GUID_ERROR_INFO } from './constants';
+/**
+ * @description Проверяет валидность GUID.
+ * @example
+ * ```ts
+ *  const validate = string(guid());
+ *  validate('C56A4180-65AA-42EC-A945-5FD21DEC0538');
+ * ```
+ */
+export const guid = (params) => createRule((value, ctx) => {
+    if (!GUID_REGEXP.test(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, INVALID_GUID_ERROR_INFO), { message: (params === null || params === void 0 ? void 0 : params.message) || INVALID_GUID_ERROR_INFO.message }));
+    }
+    return undefined;
+});

package/guid/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './guid';

package/guid/index.js

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './guid';

package/index.d.ts

@@ -16,6 +16,7 @@ export { pattern, PATTERN_ERROR_CODE } from './pattern';
 export { onlyNumber, ONLY_NUMBER_ERROR_CODE } from './onlyNumber';
 export { toPlainError } from './toPlainError';
 export { email, LENGTH_EMAIL_ERROR_INFO, INVALID_EMAIL_ERROR_INFO, } from './email';
+export { guid, INVALID_GUID_ERROR_INFO } from './guid';
 export { mobilePhone, MOBILE_PHONE_ERROR_INFO } from './mobilePhone';
 export { innUL, INN_UL_ERROR_INFO } from './innUL';
 export { innIP, INN_IP_ERROR_INFO } from './innIP';

package/index.js

@@ -16,6 +16,7 @@ export { pattern, PATTERN_ERROR_CODE } from './pattern';
 export { onlyNumber, ONLY_NUMBER_ERROR_CODE } from './onlyNumber';
 export { toPlainError } from './toPlainError';
 export { email, LENGTH_EMAIL_ERROR_INFO, INVALID_EMAIL_ERROR_INFO, } from './email';
+export { guid, INVALID_GUID_ERROR_INFO } from './guid';
 export { mobilePhone, MOBILE_PHONE_ERROR_INFO } from './mobilePhone';
 export { innUL, INN_UL_ERROR_INFO } from './innUL';
 export { innIP, INN_IP_ERROR_INFO } from './innIP';

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.3.0",
+  "version": "4.5.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);
 });