@astral/validations 2.26.0 → 3.0.0-beta.0

package/object/object.d.ts

@@ -0,0 +1,52 @@
+import { Guard, ValidationContext, ValidationRule } from '../core';
+/**
+ * @description Специальный итерфейс Guard для object. В данном интерфейсе ctx required
+ * Переопределение необходимо для того, чтобы ts показывал, что ctx required в кастомных правилах
+ */
+interface ObjectPropGuard<TValues> {
+    (value: Parameters<Guard<unknown, TValues>>[0], ctx: ValidationContext<TValues>): ReturnType<Guard<unknown, TValues>>;
+    define: Guard<unknown, TValues>['define'];
+}
+type AdditionalDefOptions = {
+    /**
+     * @description Делает все свойства объекта partial
+     */
+    isPartial?: boolean;
+};
+/**
+ * @description Тип, который необходим для того, чтобы object невозможно было использовать без использования generic
+ */
+type NeverSchema = Record<'__never', never>;
+/**
+ * @description Возможные значения, принимаемые схемой
+ */
+export type SchemaValue<TValues> = ObjectPropGuard<TValues> | ValidationRule<unknown, TValues>;
+/**
+ * @description Схема правил валдиации для объекта
+ */
+export type Schema<TValue extends Record<string, unknown>, TValues = unknown> = Record<keyof TValue, SchemaValue<TValues>>;
+/**
+ * @description Guard для объекта
+ * @param schema - схема валидации объекта
+ * @example
+ * ```ts
+ * type Values = {
+ *   name: string;
+ *   age?: number;
+ *   info: { surname: string };
+ * };
+ *
+ * const values: Values = { name: 'Vasya', info: { surname: 'Vasin' } };
+ *
+ * const validateObject = object<Values>({
+ *   name: string(min(2)),
+ *   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 object: <Value extends Record<string, unknown> = NeverSchema, TValues = unknown>(schema: Schema<Value, TValues>) => Guard<Value, TValues, AdditionalDefOptions>;
+export {};

package/object/object.js

@@ -0,0 +1,50 @@
+import isPlainObject from 'is-plain-obj';
+import { createErrorMap, createGuard, } from '../core';
+import { optional } from '../optional';
+import { isEmptyErrors } from './isEmptyErrors';
+import { OBJECT_TYPE_ERROR_INFO } from './constants';
+/**
+ * @description Guard для объекта
+ * @param schema - схема валидации объекта
+ * @example
+ * ```ts
+ * type Values = {
+ *   name: string;
+ *   age?: number;
+ *   info: { surname: string };
+ * };
+ *
+ * const values: Values = { name: 'Vasya', info: { surname: 'Vasin' } };
+ *
+ * const validateObject = object<Values>({
+ *   name: string(min(2)),
+ *   age: optional(number()),
+ *   info: object<Values['info']>({ surname: string(min(2)) }),
+ *   customField: (value, ctx) => {
+ *     return ctx.createError({ message: 'error', code: 'custom error' })
+ *   }
+ * });
+ * ```
+ */
+export const object = (schema) => createGuard((value, ctx, { typeErrorMessage, isPartial }) => {
+    if (!isPlainObject(value)) {
+        return ctx.createError(Object.assign(Object.assign({}, OBJECT_TYPE_ERROR_INFO), { message: typeErrorMessage || OBJECT_TYPE_ERROR_INFO.message }));
+    }
+    const generateErrorMap = () => {
+        const schemaEntries = Object.entries(schema);
+        const isOptional = ctx.global.overrides.objectIsPartial || isPartial;
+        return schemaEntries.reduce((errorMap, [key, rule]) => {
+            const isGuard = 'define' in rule;
+            const callRule = isGuard && isOptional
+                ? optional(rule)
+                : rule;
+            errorMap[key] = callRule(value[key], ctx);
+            return errorMap;
+        }, {});
+    };
+    const errorMap = generateErrorMap();
+    if (!isEmptyErrors(errorMap)) {
+        return createErrorMap(errorMap);
+    }
+    return undefined;
+});

package/ogrnIP/constants.d.ts

@@ -0,0 +1,3 @@
+import { ErrorInfo } from '../core';
+export declare const OGRN_IP_ERROR_INFO: ErrorInfo;
+export declare const OGRN_IP_LENGTH = 15;

package/ogrnIP/constants.js

@@ -0,0 +1,6 @@
+import { createErrorCode } from '../core';
+export const OGRN_IP_ERROR_INFO = {
+    code: createErrorCode('ogrnIP'),
+    message: 'Некорректный ОГРН ИП',
+};
+export const OGRN_IP_LENGTH = 15;

package/ogrnIP/index.d.ts

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

package/ogrnIP/index.js

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

package/ogrnIP/ogrnIP.d.ts

@@ -0,0 +1,25 @@
+import { CommonRuleParams } from '../core';
+type OgrnIPParams = CommonRuleParams<string> & {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет валиден ли ОГРН ИП
+ * @example
+ * ```ts
+ * const validate = string(ogrnIP());
+ * validate('7728168971');
+ * ```
+ */
+export declare const ogrnIP: <TValues>(params?: OgrnIPParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/ogrnIP/ogrnIP.js

@@ -0,0 +1,27 @@
+import { createRule, isStringOfZeros } from '../core';
+import { OGRN_IP_ERROR_INFO, OGRN_IP_LENGTH } from './constants';
+/**
+ * @description Проверяет валиден ли ОГРН ИП
+ * @example
+ * ```ts
+ * const validate = string(ogrnIP());
+ * validate('7728168971');
+ * ```
+ */
+export const ogrnIP = (params) => createRule((value, ctx) => {
+    const createOgrnIPError = () => ctx.createError({
+        message: (params === null || params === void 0 ? void 0 : params.message) || OGRN_IP_ERROR_INFO.message,
+        code: OGRN_IP_ERROR_INFO.code,
+    });
+    if (isStringOfZeros(value)) {
+        return createOgrnIPError();
+    }
+    if (value.length !== OGRN_IP_LENGTH) {
+        return createOgrnIPError();
+    }
+    const checkSum = (parseInt(value.slice(0, -1)) % 13).toString().slice(-1);
+    if (value.slice(14, 15) !== checkSum) {
+        return createOgrnIPError();
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/ogrnUL/constants.d.ts

@@ -0,0 +1,3 @@
+import { ErrorInfo } from '../core';
+export declare const OGRN_UL_ERROR_INFO: ErrorInfo;
+export declare const OGRN_UL_LENGTH = 13;

package/ogrnUL/constants.js

@@ -0,0 +1,6 @@
+import { createErrorCode } from '../core';
+export const OGRN_UL_ERROR_INFO = {
+    code: createErrorCode('ogrnUL'),
+    message: 'Некорректный ОГРН ЮЛ',
+};
+export const OGRN_UL_LENGTH = 13;

package/ogrnUL/index.d.ts

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

package/ogrnUL/index.js

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

package/ogrnUL/ogrnUL.d.ts

@@ -0,0 +1,25 @@
+import { CommonRuleParams } from '../core';
+type OgrnULParams = CommonRuleParams<string> & {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет валиден ли ОГРН ЮЛ
+ * @example
+ * ```ts
+ * const validate = string(ogrnIP());
+ * validate('7728168971');
+ * ```
+ */
+export declare const ogrnUL: <TValues>(params?: OgrnULParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/ogrnUL/ogrnUL.js

@@ -0,0 +1,27 @@
+import { createRule, isStringOfZeros } from '../core';
+import { OGRN_UL_ERROR_INFO, OGRN_UL_LENGTH } from './constants';
+/**
+ * @description Проверяет валиден ли ОГРН ЮЛ
+ * @example
+ * ```ts
+ * const validate = string(ogrnIP());
+ * validate('7728168971');
+ * ```
+ */
+export const ogrnUL = (params) => createRule((value, ctx) => {
+    const createOgrnUlError = () => ctx.createError({
+        message: (params === null || params === void 0 ? void 0 : params.message) || OGRN_UL_ERROR_INFO.message,
+        code: OGRN_UL_ERROR_INFO.code,
+    });
+    if (isStringOfZeros(value)) {
+        return createOgrnUlError();
+    }
+    if (value.length !== OGRN_UL_LENGTH) {
+        return createOgrnUlError();
+    }
+    const checkSum = (parseInt(value.slice(0, -1)) % 11).toString().slice(-1);
+    if (value.slice(12, 13) !== checkSum) {
+        return createOgrnUlError();
+    }
+    return undefined;
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/onlyNumber/constants.d.ts

@@ -0,0 +1,2 @@
+import { ErrorCode } from '../core';
+export declare const ONLY_NUMBER_ERROR_CODE: ErrorCode;

package/onlyNumber/constants.js

@@ -0,0 +1,2 @@
+import { createErrorCode } from '../core';
+export const ONLY_NUMBER_ERROR_CODE = createErrorCode('onlyNumber');

package/onlyNumber/index.d.ts

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

package/onlyNumber/index.js

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

package/onlyNumber/onlyNumber.d.ts

@@ -0,0 +1,24 @@
+type OnlyNumberParams = {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет на наличие только чисел в строке
+ * @example
+ * ```ts
+ *  const validate = string(onlyNumber());
+ *  validate('123');
+ * ```
+ */
+export declare const onlyNumber: <TValues>(params?: OnlyNumberParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/onlyNumber/onlyNumber.js

@@ -0,0 +1,20 @@
+import { createRule } from '../core';
+import { ONLY_NUMBER_ERROR_CODE } from './constants';
+/**
+ * @description Проверяет на наличие только чисел в строке
+ * @example
+ * ```ts
+ *  const validate = string(onlyNumber());
+ *  validate('123');
+ * ```
+ */
+export const onlyNumber = (params) => createRule((value, ctx) => {
+    const isExtraValues = Boolean(value.replace(/^[0-9]+$/g, ''));
+    if (isExtraValues) {
+        return ctx.createError({
+            code: ONLY_NUMBER_ERROR_CODE,
+            message: (params === null || params === void 0 ? void 0 : params.message) || 'Строка должна содержать только числа',
+        });
+    }
+    return undefined;
+});

package/optional/index.d.ts

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

package/optional/index.js

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

package/optional/optional.d.ts

@@ -0,0 +1,7 @@
+import { Guard } from '../core';
+/**
+ * @description Выключает проверку на required в guard
+ * @param guard - правило, проверяющее тип значения
+ * @example object({ name: optional(string(min(22))) })
+ */
+export declare const optional: <ValidationType extends unknown, TValues>(guard: Guard<ValidationType, TValues, {}>) => Guard<ValidationType, TValues, {}>;

package/optional/optional.js

@@ -0,0 +1,15 @@
+import { string } from '../string';
+/**
+ * @description Выключает проверку на required в guard
+ * @param guard - правило, проверяющее тип значения
+ * @example object({ name: optional(string(min(22))) })
+ */
+export const optional = (guard) => guard.define({ isOptional: true });
+const validateCustomString = string().define({
+    typeErrorMessage: 'Только строка',
+    requiredErrorMessage: 'Не может быть пустым',
+});
+// { message: 'Не может быть пустым' }
+validateCustomString(undefined);
+// { message: 'Только строка' }
+validateCustomString(20);

package/or/index.d.ts

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

package/or/index.js

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

package/or/or.d.ts

@@ -0,0 +1,22 @@
+import { ValidationResult, ValidationRule } from '../core';
+/**
+ * @description Выполняет переданные правила аналогично оператору ||. Если одно из правил не завершилось ошибкой, то or вернет undefined
+ * Если все переданные правила завершились с ошибкой, то вернется ошибка из последнего правила
+ * @param rules - любые правила валдиаций
+ * @example
+ * ```ts
+ *  const validate = or(number(), string(), array());
+ *
+ *  // undefined
+ *  const result = validate('string');
+ * ```
+ */
+export declare const or: <TValues>(...rules: ValidationRule<unknown, TValues>[]) => (value: unknown, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => ValidationResult;

package/or/or.js

@@ -0,0 +1,21 @@
+import { createRule } from '../core';
+/**
+ * @description Выполняет переданные правила аналогично оператору ||. Если одно из правил не завершилось ошибкой, то or вернет undefined
+ * Если все переданные правила завершились с ошибкой, то вернется ошибка из последнего правила
+ * @param rules - любые правила валдиаций
+ * @example
+ * ```ts
+ *  const validate = or(number(), string(), array());
+ *
+ *  // undefined
+ *  const result = validate('string');
+ * ```
+ */
+export const or = (...rules) => createRule((value, ctx) => {
+    let result;
+    rules.some((rule) => {
+        result = rule(value, ctx);
+        return result ? false : true;
+    });
+    return result;
+});

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@astral/validations",
-  "version": "2.26.0",
+  "version": "3.0.0-beta.0",
   "browser": "./index.js",
   "main": "./index.js",
   "dependencies": {
-    "lodash.isempty": "^4.4.0"
+    "is-plain-obj": "^4.1.0"
   },
   "author": "Astral.Soft",
   "license": "MIT",

package/partial/index.d.ts

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

package/partial/index.js

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

package/partial/partial.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @description Выключает проверку на required для всех полей объекта
+ * @param objectGuard
+ * @example partial(object({ name: string() }))
+ */
+export declare const partial: (objectGuard: import("../core").Guard<Record<string, unknown>, unknown, {
+    isPartial?: boolean | undefined;
+}>) => import("../core").Guard<Record<string, unknown>, unknown, {
+    isPartial?: boolean | undefined;
+}>;

package/partial/partial.js

@@ -0,0 +1,6 @@
+/**
+ * @description Выключает проверку на required для всех полей объекта
+ * @param objectGuard
+ * @example partial(object({ name: string() }))
+ */
+export const partial = (objectGuard) => objectGuard.define({ isPartial: true });

package/pattern/constants.d.ts

@@ -0,0 +1,2 @@
+import { ErrorCode } from '../core';
+export declare const PATTERN_ERROR_CODE: ErrorCode;

package/pattern/constants.js

@@ -0,0 +1,2 @@
+import { createErrorCode } from '../core';
+export const PATTERN_ERROR_CODE = createErrorCode('pattern');

package/pattern/index.d.ts

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

package/pattern/index.js

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

package/pattern/pattern.d.ts

@@ -0,0 +1,26 @@
+type PatternParams = {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет строку на соответствие регулярному выражению.
+ * @param regex - регулярное выражение
+ * @example
+ * ```ts
+ * string(pattern(/word/g))
+ *
+ * string(pattern(/[0-9]/))
+ * ```
+ */
+export declare const pattern: <TValues>(regex: RegExp, params?: PatternParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/pattern/pattern.js

@@ -0,0 +1,22 @@
+import { createRule } from '../core';
+import { PATTERN_ERROR_CODE } from './constants';
+/**
+ * @description Проверяет строку на соответствие регулярному выражению.
+ * @param regex - регулярное выражение
+ * @example
+ * ```ts
+ * string(pattern(/word/g))
+ *
+ * string(pattern(/[0-9]/))
+ * ```
+ */
+export const pattern = (regex, params) => createRule((value, ctx) => {
+    if (!regex.test(value)) {
+        return ctx.createError({
+            code: PATTERN_ERROR_CODE,
+            message: (params === null || params === void 0 ? void 0 : params.message) ||
+                `Должно подходить под регулярное выражение: "${regex}"`,
+        });
+    }
+    return undefined;
+});

package/snils/constants.d.ts

@@ -0,0 +1,4 @@
+import { ErrorInfo } from '../core';
+export declare const SNILS_ERROR_INFO: ErrorInfo;
+export declare const RESTRICTED_VALUES: string[];
+export declare const DEFAULT_CHECKED_SUM: number[];

package/snils/constants.js

@@ -0,0 +1,7 @@
+import { createErrorCode } from '../core';
+export const SNILS_ERROR_INFO = {
+    code: createErrorCode('snils'),
+    message: 'Некорректный СНИЛС',
+};
+export const RESTRICTED_VALUES = ['00000000000'];
+export const DEFAULT_CHECKED_SUM = [0, 100, 101];

package/snils/index.d.ts

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

package/snils/index.js

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

package/snils/snils.d.ts

@@ -0,0 +1,25 @@
+import { CommonRuleParams } from '../core';
+type SnilsParams = CommonRuleParams<string> & {
+    /**
+     * @description Замена стандартного сообщения ошибки.
+     */
+    message?: string;
+};
+/**
+ * @description Проверяет валиден ли СНИЛС
+ * @example
+ * ```ts
+ * const validate = string(snils());
+ * validate('15657325992');
+ * ```
+ */
+export declare const snils: <TValues>(params?: SnilsParams) => (value: string, prevCtx?: Readonly<{
+    global: Readonly<{
+        values: TValues;
+        overrides: Readonly<{
+            objectIsPartial: boolean;
+        }>;
+    }>;
+    createError: ({ message, code }: import("../core").ErrorInfo) => import("../core").ValidationSimpleError<{}>;
+}> | undefined) => import("../core").ValidationResult;
+export {};

package/{isSNILS/isSNILS.js → snils/snils.js}

@@ -1,8 +1,5 @@
-import { createRule } from '../createRule';
-import { isEmptyString, isStringOfZeros } from '../utils';
-export const IS_SNILS_DEFAULT_MESSAGE = 'Некорректный СНИЛС';
-const RESTRICTED_VALUES = ['00000000000'];
-const DEFAULT_CHECKED_SUM = [0, 100, 101];
+import { createRule, isStringOfZeros } from '../core';
+import { DEFAULT_CHECKED_SUM, RESTRICTED_VALUES, SNILS_ERROR_INFO, } from './constants';
 const removeSpecialCharacters = (value) => {
     return value.replace(/\D/g, '');
 };
@@ -18,27 +15,29 @@ const compareCheckSum = (calculatedCheckSum, checkSum) => {
 };
 /**
  * @description Проверяет валиден ли СНИЛС
- * @example isSNILS()('95145370513');
+ * @example
+ * ```ts
+ * const validate = string(snils());
+ * validate('15657325992');
+ * ```
  */
-export const isSNILS = createRule(({ message = IS_SNILS_DEFAULT_MESSAGE } = {}) => (value) => {
-    if (isEmptyString(value)) {
-        return undefined;
-    }
+export const snils = (params) => createRule((value, ctx) => {
+    const createSnilsError = () => ctx.createError({
+        message: (params === null || params === void 0 ? void 0 : params.message) || SNILS_ERROR_INFO.message,
+        code: SNILS_ERROR_INFO.code,
+    });
     if (isStringOfZeros(value)) {
-        return message;
-    }
-    if (typeof value !== 'string') {
-        return message;
+        return createSnilsError();
     }
     const formattedValue = removeSpecialCharacters(value);
     if (formattedValue.length !== value.length) {
-        return message;
+        return createSnilsError();
     }
     if (!/^(\d{11})$/.test(formattedValue)) {
-        return message;
+        return createSnilsError();
     }
     if (RESTRICTED_VALUES.includes(formattedValue)) {
-        return message;
+        return createSnilsError();
     }
     const checkSum = Number(formattedValue.slice(9, 11));
     const calculatedCheckSum = calcCheckSumForSNILS(formattedValue);
@@ -46,20 +45,20 @@ export const isSNILS = createRule(({ message = IS_SNILS_DEFAULT_MESSAGE } = {})
         if (calculatedCheckSum === checkSum) {
             return undefined;
         }
-        return message;
+        return createSnilsError();
     }
     if (calculatedCheckSum === DEFAULT_CHECKED_SUM[1] ||
         calculatedCheckSum === DEFAULT_CHECKED_SUM[2]) {
         if (checkSum === DEFAULT_CHECKED_SUM[0]) {
             return undefined;
         }
-        return message;
+        return createSnilsError();
     }
     if (calculatedCheckSum > DEFAULT_CHECKED_SUM[2]) {
         if (compareCheckSum(calculatedCheckSum, checkSum)) {
             return undefined;
         }
-        return message;
+        return createSnilsError();
     }
     return undefined;
-});
+}, { exclude: params === null || params === void 0 ? void 0 : params.exclude });

package/string/constants.d.ts

@@ -0,0 +1,2 @@
+import { ErrorInfo } from '../core';
+export declare const STRING_TYPE_ERROR_INFO: ErrorInfo;

package/string/constants.js

@@ -0,0 +1,5 @@
+import { createErrorCode } from '../core';
+export const STRING_TYPE_ERROR_INFO = {
+    code: createErrorCode('string'),
+    message: 'Не является строкой',
+};