@azure-net/kit 0.8.5 → 0.8.8

package/dist/core/delivery/schema/Schema.d.ts

@@ -0,0 +1,33 @@
+type DeepKeys<T> = T extends object ? {
+    [K in keyof T & string]: T[K] extends object ? K | `${K}.${DeepKeys<T[K]>}` : K;
+}[keyof T & string] : never;
+export type ValidationParams<T = unknown, V = unknown, K = string> = {
+    val: V;
+    listValues?: Partial<T>;
+    key?: K;
+};
+export type ValidationMessage = string | {
+    key: string;
+    vars?: Record<string, unknown>;
+};
+export interface ValidationErrorsMap {
+    [key: string]: ValidationMessage | ValidationErrorsMap;
+}
+export type ValidationResult = ValidationMessage | ValidationErrorsMap | ValidationErrorsMap[] | undefined;
+export type ValidationRuleResult<CurrentValue, ListValues = unknown, CurrentKey = string> = (params: ValidationParams<CurrentValue, ListValues, CurrentKey>) => ValidationResult;
+type ValidationErrors<T> = T extends ReadonlyArray<infer U> ? ValidationErrors<U>[] : T extends object ? {
+    [K in keyof T]?: ValidationErrors<T[K]>;
+} : ValidationMessage;
+export type RequestErrors<Dict> = Partial<ValidationErrors<Dict>>;
+export type RequestRules<D> = Partial<Record<DeepKeys<D>, ValidationRuleResult<D>[]>>;
+export declare const createSchemaFactory: <Rules>(rulesList: Rules) => <IncomingData, DataAfterTransform = IncomingData>(params: {
+    schema: (rules: Rules) => RequestRules<IncomingData>;
+    transform: (data: IncomingData) => DataAfterTransform;
+}) => {
+    from: (data: IncomingData) => void;
+    json: () => DataAfterTransform;
+    formData: () => FormData;
+    validate: () => undefined;
+    readonly errors: Partial<ValidationErrors<IncomingData>>;
+};
+export {};

package/dist/core/delivery/schema/Schema.js

@@ -0,0 +1,78 @@
+import { FormDataUtil } from 'azure-net-tools';
+export const createSchemaFactory = (rulesList) => {
+    return (params) => {
+        let schemaData;
+        let _errors = {};
+        let _isValid = true;
+        const { schema, transform = (data) => data } = params;
+        const definedSchema = schema(rulesList);
+        const getByPath = (path) => {
+            return path.split('.').reduce((o, k) => (o && typeof o === 'object' ? o[k] : undefined), schemaData);
+        };
+        const setByPath = (obj, path, value) => {
+            const keys = path.split('.');
+            let current = obj;
+            for (let i = 0; i < keys.length - 1; i++) {
+                const k = keys[i];
+                if (!(k in current) || typeof current[k] !== 'object') {
+                    current[k] = {};
+                }
+                current = current[k];
+            }
+            current[keys[(keys.length - 1)]] = value;
+        };
+        const prepare = (dataToPrepare) => {
+            if (dataToPrepare instanceof FormData) {
+                return FormDataUtil.toObject(dataToPrepare);
+            }
+            return dataToPrepare;
+        };
+        const validate = () => {
+            _isValid = true;
+            _errors = {};
+            if (typeof schemaData !== 'object') {
+                throw Error('Data to validate is not an object');
+            }
+            for (const key in definedSchema) {
+                const fieldRules = definedSchema[key] ?? [];
+                const value = getByPath(key);
+                for (const rule of fieldRules) {
+                    const failMessage = rule({
+                        val: value,
+                        listValues: schemaData,
+                        key: key
+                    });
+                    if (failMessage) {
+                        setByPath(_errors, key, failMessage);
+                        _isValid = false;
+                        break;
+                    }
+                }
+            }
+            if (!_isValid) {
+                throw this;
+            }
+            return this;
+        };
+        const from = (data) => {
+            schemaData = prepare(data);
+        };
+        const formData = () => {
+            validate();
+            return FormDataUtil.fromObject(transform(schemaData));
+        };
+        const json = () => {
+            validate();
+            return transform(schemaData);
+        };
+        return {
+            from,
+            json,
+            formData,
+            validate,
+            get errors() {
+                return _errors;
+            }
+        };
+    };
+};

package/dist/core/delivery/schema/index.d.ts

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

package/dist/core/delivery/schema/index.js

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

package/dist/core/delivery/schema/rules/Rules.d.ts

@@ -0,0 +1,59 @@
+import type { BaseValidationMessages } from './messages/types.js';
+import type { ValidationParams, ValidationRuleResult } from '../index.js';
+import { type CountryCode } from 'libphonenumber-js';
+export type ValidationRuleParams<T extends keyof BaseValidationMessages, D = object> = D & {
+    message?: BaseValidationMessages[T];
+};
+export type LengthParams = {
+    length?: {
+        min?: number;
+        max?: number;
+    };
+};
+export type RangeParams = {
+    range?: {
+        min?: number;
+        max?: number;
+    };
+};
+type ArrayItemRules<Context> = ValidationRuleResult<Context>[] | Record<string, ValidationRuleResult<Context>[]>;
+type ArrayParams<Context> = LengthParams & {
+    schema?: ArrayItemRules<Context>;
+};
+export declare const createRules: <M extends BaseValidationMessages>(validationMessages: M) => {
+    string: <T = unknown, D = unknown>(params?: ValidationRuleParams<"string", LengthParams>) => ValidationRuleResult<T, D>;
+    number: <T = unknown, D_1 = unknown>(params?: ValidationRuleParams<"number", RangeParams>) => ValidationRuleResult<T, D_1>;
+    required: <T = unknown, D_2 = unknown, J = unknown>(params?: ValidationRuleParams<"required", {
+        byCondition?: (params: ValidationParams<T, D_2, J>) => boolean;
+    }>) => ValidationRuleResult<T, D_2, J>;
+    password: <T = unknown, D_3 = unknown>(params?: ValidationRuleParams<"password", {
+        length?: number;
+        specialChars?: boolean | number;
+        numbers?: boolean | number;
+        lowerUpperCasePattern?: boolean;
+    }>) => ValidationRuleResult<T, D_3>;
+    notSameAs: <T = unknown, D_4 = unknown>(params: ValidationRuleParams<"sameAs", {
+        key: keyof T | string;
+    }>) => ValidationRuleResult<T, D_4>;
+    sameAs: <T = unknown, D_5 = unknown>(params: ValidationRuleParams<"sameAs", {
+        key: keyof T | string;
+    }>) => ValidationRuleResult<T, D_5>;
+    array: <T = unknown>(params?: ValidationRuleParams<"array", ArrayParams<T>>) => ValidationRuleResult<T>;
+    boolean: <T = unknown, D_6 = unknown>(params?: ValidationRuleParams<"boolean", {
+        expected?: boolean;
+    }>) => ValidationRuleResult<T, D_6>;
+    email: <T = unknown, D_7 = unknown>(params?: ValidationRuleParams<"email">) => ValidationRuleResult<T, D_7>;
+    finite: <T = unknown, D_8 = unknown>(params?: ValidationRuleParams<"finite", RangeParams & {
+        maxDigitsAfterDot?: number;
+    }>) => ValidationRuleResult<T, D_8>;
+    lettersOnly: <T = unknown, D_9 = unknown>(params?: ValidationRuleParams<"lettersOnly", {
+        whiteSpaces?: boolean;
+    }>) => ValidationRuleResult<T, D_9>;
+    phone: <T = unknown, D_10 = unknown>(params?: ValidationRuleParams<"phone", {
+        country: CountryCode;
+    }>) => ValidationRuleResult<T, D_10>;
+    allowedOnly: <T = unknown, D_11 = unknown>(params?: ValidationRuleParams<"allowedOnly", {
+        allowed?: unknown[];
+    }>) => ValidationRuleResult<T, D_11>;
+};
+export {};

package/dist/core/delivery/schema/rules/Rules.js

@@ -0,0 +1,285 @@
+import { isValidNumber } from 'libphonenumber-js';
+export const createRules = (validationMessages) => {
+    const checkVal = (val) => {
+        return val !== undefined && val !== null;
+    };
+    const string = (params) => {
+        const { message, length } = { ...params, message: { ...validationMessages.string, ...params?.message } };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                if (typeof val !== 'string') {
+                    return message.base();
+                }
+                switch (true) {
+                    case length && checkVal(length.min) && val.length < length.min:
+                        return message.min(length.min);
+                    case length && checkVal(length.max) && val.length > length.max:
+                        return message.max(length.max);
+                    default:
+                        return undefined;
+                }
+            }
+            return undefined;
+        };
+    };
+    const number = (params) => {
+        const { message, range } = { ...params, message: { ...validationMessages.number, ...params?.message } };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                const numberVal = Number(val);
+                if (!Number.isInteger(numberVal) || Number.isNaN(numberVal)) {
+                    return message.base();
+                }
+                switch (true) {
+                    case range && checkVal(range?.min) && numberVal < range.min:
+                        return message.min(range.min);
+                    case range && checkVal(range?.max) && numberVal > range.max:
+                        return message.max(range.max);
+                    default:
+                        return undefined;
+                }
+            }
+            return undefined;
+        };
+    };
+    const finite = (params) => {
+        const { message, maxDigitsAfterDot, range } = { ...params, message: { ...validationMessages.finite, ...params?.message } };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                const numVal = Number(val);
+                if (!Number.isFinite(numVal) || String(val)[0] === '.') {
+                    return message.base();
+                }
+                if (typeof maxDigitsAfterDot === 'number') {
+                    const digitsAfterDot = val.toString().split('.')[1]?.length ?? 0;
+                    if (digitsAfterDot > maxDigitsAfterDot) {
+                        return message.maxDigitsAfterDot(maxDigitsAfterDot);
+                    }
+                }
+                if (range?.min !== undefined && numVal < range.min)
+                    return message.min(range.min);
+                if (range?.max !== undefined && numVal > range.max)
+                    return message.max(range.max);
+                return undefined;
+            }
+            return undefined;
+        };
+    };
+    const boolean = (params) => {
+        const { message, expected } = { ...params, message: { ...validationMessages.boolean, ...params?.message } };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                if (typeof val !== 'boolean')
+                    return message.base();
+                if (expected !== undefined && val !== expected)
+                    return message.expected(String(expected));
+                return undefined;
+            }
+            return undefined;
+        };
+    };
+    const array = (params) => {
+        const { message, length = {}, schema } = { ...params, message: { ...validationMessages.array, ...params?.message } };
+        return ({ val, listValues, key }) => {
+            if (checkVal(val)) {
+                if (!Array.isArray(val))
+                    return message.base();
+                if (length.min && val.length < length.min)
+                    return message.min(length.min);
+                if (length.max && val.length > length.max)
+                    return message.max(length.max);
+                if (schema) {
+                    const nestedErrors = [];
+                    for (let index = 0; index < val.length; index++) {
+                        const element = val[index];
+                        const itemErrors = {};
+                        if (Array.isArray(schema)) {
+                            for (const rule of schema) {
+                                const fail = rule({
+                                    val: element,
+                                    listValues,
+                                    key: `${key}[${index}]`
+                                });
+                                if (fail) {
+                                    itemErrors['_error'] = fail;
+                                    break;
+                                }
+                            }
+                        }
+                        else if (typeof schema === 'object' && schema !== null) {
+                            if (typeof element !== 'object' || element === null) {
+                                itemErrors['_error'] = message.base();
+                            }
+                            else {
+                                for (const fieldKey in schema) {
+                                    const fieldRules = schema[fieldKey] ?? [];
+                                    const fieldValue = element?.[fieldKey];
+                                    for (const rule of fieldRules) {
+                                        const fail = rule({
+                                            val: fieldValue,
+                                            listValues,
+                                            key: `${key}[${index}].${fieldKey}`
+                                        });
+                                        if (fail) {
+                                            itemErrors[fieldKey] = fail;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        nestedErrors[index] = itemErrors;
+                    }
+                    if (nestedErrors.some((e) => Object.keys(e).length > 0)) {
+                        return nestedErrors;
+                    }
+                }
+            }
+            return undefined;
+        };
+    };
+    const phone = (params) => {
+        const { message, country = 'RU' } = { ...params, message: params?.message ?? validationMessages.phone };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                return isValidNumber(String(val), country) ? undefined : message();
+            }
+            return undefined;
+        };
+    };
+    const email = (params) => {
+        const { message } = { message: params?.message ?? validationMessages.email };
+        const emailRegExp = 
+        // eslint-disable-next-line no-control-regex
+        /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21\x23-\x5B\x5D-\x7F]|[\x01-\x09\x0B\x0C\x0E-\x7F])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0B\x0C\x0E-\x1F\x21-\x5A\x53-\x7F]|\\[\x01-\x09\x0B\x0C\x0E-\x7F])+)])$/i;
+        return ({ val }) => {
+            if (checkVal(val)) {
+                const stringedVal = typeof val === 'string' ? String(val) : undefined;
+                return stringedVal && emailRegExp.test(stringedVal) ? undefined : message();
+            }
+            return undefined;
+        };
+    };
+    const lettersOnly = (params) => {
+        const { message, whiteSpaces = false } = { ...params, message: params?.message ?? validationMessages.lettersOnly };
+        const lettersRegex = whiteSpaces ? /^[а-яА-Яa-zA-Z\s]+$/ : /^[а-яА-Яa-zA-Z]+$/;
+        return ({ val }) => {
+            if (checkVal(val)) {
+                const stringedVal = typeof val === 'string' ? String(val) : undefined;
+                return stringedVal && lettersRegex.test(stringedVal) ? undefined : message(whiteSpaces);
+            }
+            return undefined;
+        };
+    };
+    const allowedOnly = (params) => {
+        const { message, allowed } = { ...params, message: params?.message ?? validationMessages.allowedOnly };
+        return ({ val }) => {
+            if (checkVal(val)) {
+                switch (true) {
+                    case !!allowed && Array.isArray(allowed):
+                        if (!allowed?.length) {
+                            return message('');
+                        }
+                        return allowed.includes(val) ? undefined : message(allowed.join(', '));
+                    default:
+                        return undefined;
+                }
+            }
+            return undefined;
+        };
+    };
+    const sameAs = (params) => {
+        const { message, key } = { ...params, message: params?.message ?? validationMessages.sameAs };
+        return ({ val, listValues }) => {
+            if (checkVal(val)) {
+                switch (true) {
+                    case typeof val === 'object':
+                        if (!listValues?.[key] || typeof listValues[key] !== 'object') {
+                            return message(String(key));
+                        }
+                        try {
+                            return JSON.stringify(val) === JSON.stringify(listValues[key]) ? undefined : message(String(key));
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    default:
+                        return String(val ?? '') === String(listValues?.[key] ?? '') ? undefined : message(String(key));
+                }
+            }
+            return undefined;
+        };
+    };
+    const notSameAs = (params) => {
+        const { message, key } = { ...params, message: params?.message ?? validationMessages.notSameAs };
+        return ({ val, listValues }) => {
+            if (checkVal(val)) {
+                switch (true) {
+                    case typeof val === 'object':
+                        if (!listValues?.[key] || typeof listValues[key] !== 'object') {
+                            return message(String(key));
+                        }
+                        try {
+                            return JSON.stringify(val) !== JSON.stringify(listValues[key]) ? undefined : message(String(key));
+                        }
+                        catch {
+                            return undefined;
+                        }
+                    default:
+                        return String(val) === String(listValues?.[key]) ? undefined : message(String(key));
+                }
+            }
+            return undefined;
+        };
+    };
+    const required = (params) => {
+        const { message, byCondition } = { ...params, message: params?.message ?? validationMessages.required };
+        return ({ val, listValues, key }) => {
+            if (!checkVal(val))
+                return message();
+            if (byCondition && !byCondition({ val, listValues, key }))
+                return undefined;
+            if (typeof val === 'string' && !val.length)
+                return message();
+            if (val instanceof File && val.size < 1)
+                return message();
+            if (typeof val === 'number' && !String(val).length)
+                return message();
+            return undefined;
+        };
+    };
+    const password = (params) => {
+        const { message, length = 8, specialChars, numbers, lowerUpperCasePattern } = { ...params, message: { ...validationMessages.password, ...params?.message } };
+        return ({ val }) => {
+            if (!checkVal(val))
+                return undefined;
+            const str = String(val);
+            if (str.length < length) {
+                return message.length(length);
+            }
+            if (specialChars) {
+                const minCount = typeof specialChars === 'number' ? specialChars : 1;
+                const count = (str.match(/[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/g) || []).length;
+                if (count < minCount) {
+                    return message.specialChars(minCount);
+                }
+            }
+            if (numbers) {
+                const minCount = typeof numbers === 'number' ? numbers : 1;
+                const count = (str.match(/[0-9]/g) || []).length;
+                if (count < minCount) {
+                    return message.numbers(minCount);
+                }
+            }
+            if (lowerUpperCasePattern) {
+                const hasLower = /[a-z]/.test(str);
+                const hasUpper = /[A-Z]/.test(str);
+                if (!hasLower || !hasUpper) {
+                    return message.lowerUpperCasePattern();
+                }
+            }
+            return undefined;
+        };
+    };
+    return { string, number, required, password, notSameAs, sameAs, array, boolean, email, finite, lettersOnly, phone, allowedOnly };
+};

package/dist/core/delivery/schema/rules/messages/En.d.ts

@@ -0,0 +1,2 @@
+import type { BaseValidationMessages } from './types.js';
+export declare const validationMessagesEn: BaseValidationMessages;

package/dist/core/delivery/schema/rules/messages/En.js

@@ -0,0 +1,40 @@
+export const validationMessagesEn = {
+    phone: () => 'Invalid phone number format',
+    email: () => 'Invalid email address',
+    required: () => 'This field is required',
+    lettersOnly: (whiteSpaces) => `This field may contain letters only${whiteSpaces ? '' : ' and must not contain spaces'}`,
+    allowedOnly: (value) => value && value.length ? `This field may contain only one of the following values: ${value}` : 'This field has no allowed values',
+    sameAs: (value) => `This field must match the ${value} field`,
+    notSameAs: (value) => `This field must not match the ${value} field`,
+    boolean: {
+        base: () => 'This field must be a boolean value',
+        expected: (value) => `Expected value: ${value}`
+    },
+    finite: {
+        base: () => 'This field must be a number',
+        min: (value) => `The number must be at least ${value}`,
+        max: (value) => `The number must be at most ${value}`,
+        maxDigitsAfterDot: (value) => `Number of digits after the decimal point must not exceed ${value}`
+    },
+    number: {
+        base: () => 'This field must be an integer',
+        min: (value) => `The number must be at least ${value}`,
+        max: (value) => `The number must be at most ${value}`
+    },
+    string: {
+        base: () => 'This field must be a string',
+        min: (value) => `Minimum string length is ${value}`,
+        max: (value) => `Maximum string length is ${value}`
+    },
+    array: {
+        base: () => 'This field must be an array',
+        min: (value) => `Minimum array length is ${value}`,
+        max: (value) => `Maximum array length is ${value}`
+    },
+    password: {
+        length: (value) => `Minimum password length is ${value}`,
+        specialChars: (value) => `Password must contain at least ${value} special character(s)`,
+        lowerUpperCasePattern: () => 'Password must contain both uppercase and lowercase letters',
+        numbers: (value) => `Password must contain at least ${value} number(s)`
+    }
+};

package/dist/core/delivery/schema/rules/messages/Ru.d.ts

@@ -0,0 +1,2 @@
+import type { BaseValidationMessages } from './types.js';
+export declare const validationMessagesRu: BaseValidationMessages;

package/dist/core/delivery/schema/rules/messages/Ru.js

@@ -0,0 +1,40 @@
+export const validationMessagesRu = {
+    phone: () => 'Неверный формат номера телефона',
+    email: () => 'Невалидный email',
+    required: () => 'Поле обязательно к заполнению',
+    lettersOnly: (whiteSpaces) => `Поле может содержать только буквы ${whiteSpaces ? '' : 'и не должно содержать пробелы'}`,
+    allowedOnly: (value) => value && value.length ? `Поле может содержать только одно из следующих значений:: ${value}` : 'Поле не имеет допустимых значений',
+    sameAs: (value) => `Поле должно совпадать с полем ${value}`,
+    notSameAs: (value) => `Поле не должно совпадать с полем ${value}`,
+    boolean: {
+        base: () => 'Поле должно содержать значение типа boolean',
+        expected: (value) => `Ожидаемое значение поля - ${value}`
+    },
+    finite: {
+        base: () => 'Поле должно быть числом',
+        min: (value) => `Число должно быть не менее ${value}`,
+        max: (value) => `Число должно быть не более ${value}`,
+        maxDigitsAfterDot: (value) => `Количество символов после точки не более ${value}`
+    },
+    number: {
+        base: () => 'Поле должно быть целым числом',
+        min: (value) => `Число должно быть не менее ${value}`,
+        max: (value) => `Число должно быть не более ${value}`
+    },
+    string: {
+        base: () => 'Поле должно быть строкой',
+        min: (value) => `Минимальная длина строки - ${value}`,
+        max: (value) => `Максимальная длина строки - ${value}`
+    },
+    array: {
+        base: () => 'Поле должно быть массивом',
+        min: (value) => `Минимальная длина массива - ${value}`,
+        max: (value) => `Максимальная длина массива - ${value}`
+    },
+    password: {
+        length: (value) => `Минимальная длина пароля - ${value}`,
+        specialChars: (value) => `В пароле должно быть спецсимволы в количестве не менее ${value}`,
+        lowerUpperCasePattern: () => 'В пароле должны быть буквы верхнего и нижнего регистра',
+        numbers: (value) => `В пароле должно быть цифры в количестве не менее ${value}`
+    }
+};

package/dist/core/delivery/schema/rules/messages/WithI18n.d.ts

@@ -0,0 +1,2 @@
+import type { BaseValidationMessages } from './types.js';
+export declare const validationMessagesI18n: BaseValidationMessages;

package/dist/core/delivery/schema/rules/messages/WithI18n.js

@@ -0,0 +1,40 @@
+export const validationMessagesI18n = {
+    phone: () => 'validation.phone',
+    email: () => 'validation.email',
+    required: () => 'validation.required',
+    lettersOnly: (whiteSpaces) => (whiteSpaces ? 'validation.lettersOnlyWithWhiteSpaces' : 'validation.lettersOnly'),
+    allowedOnly: (value) => ({ key: value && value.length ? 'validation.allowedOnly.base' : 'validation.allowedOnly.nothing', vars: { value } }),
+    sameAs: (value) => ({ key: 'validation.sameAs', vars: { value } }),
+    notSameAs: (value) => ({ key: 'validation.notSameAs', vars: { value } }),
+    boolean: {
+        base: () => 'validation.boolean.base',
+        expected: (value) => ({ key: 'validation.boolean.expected', vars: { value } })
+    },
+    finite: {
+        base: () => 'validation.finite.base',
+        min: (value) => ({ key: 'validation.finite.minLength', vars: { value } }),
+        max: (value) => ({ key: 'validation.finite.maxLength', vars: { value } }),
+        maxDigitsAfterDot: (value) => ({ key: 'validation.finite.maxDigitsAfterDot', vars: { value } })
+    },
+    number: {
+        base: () => 'validation.number.base',
+        min: (value) => ({ key: 'validation.number.minLength', vars: { value } }),
+        max: (value) => ({ key: 'validation.number.maxLength', vars: { value } })
+    },
+    string: {
+        base: () => 'validation.string.base',
+        min: (value) => ({ key: 'validation.string.minLength', vars: { value } }),
+        max: (value) => ({ key: 'validation.string.maxLength', vars: { value } })
+    },
+    array: {
+        base: () => 'validation.array.base',
+        min: (value) => ({ key: 'validation.array.minLength', vars: { value } }),
+        max: (value) => ({ key: 'validation.array.maxLength', vars: { value } })
+    },
+    password: {
+        length: (value) => ({ key: 'validation.password.length', vars: { value } }),
+        specialChars: (value) => ({ key: 'validation.password.specialChars', vars: { value } }),
+        lowerUpperCasePattern: () => ({ key: 'validation.password.lowerUpperCasePattern' }),
+        numbers: (value) => ({ key: 'validation.password.numbers', vars: { value } })
+    }
+};

package/dist/core/delivery/schema/rules/messages/index.d.ts

@@ -0,0 +1,3 @@
+export * from './Ru.js';
+export * from './En.js';
+export * from './WithI18n.js';

package/dist/core/delivery/schema/rules/messages/index.js

@@ -0,0 +1,3 @@
+export * from './Ru.js';
+export * from './En.js';
+export * from './WithI18n.js';

package/dist/core/delivery/schema/rules/messages/types.d.ts

@@ -0,0 +1,41 @@
+import type { ValidationMessage } from '../../index.js';
+export type BaseValidationMessages = {
+    phone: () => ValidationMessage;
+    email: () => ValidationMessage;
+    required: () => ValidationMessage;
+    lettersOnly: (whiteSpaces: boolean) => ValidationMessage;
+    allowedOnly: (allowed: string) => ValidationMessage;
+    sameAs: (value: string) => ValidationMessage;
+    notSameAs: (value: string) => ValidationMessage;
+    boolean: {
+        base: () => ValidationMessage;
+        expected: (value: string) => ValidationMessage;
+    };
+    finite: {
+        base: () => ValidationMessage;
+        min: (value: number) => ValidationMessage;
+        max: (value: number) => ValidationMessage;
+        maxDigitsAfterDot: (value: number) => ValidationMessage;
+    };
+    number: {
+        base: () => ValidationMessage;
+        min: (value: number) => ValidationMessage;
+        max: (value: number) => ValidationMessage;
+    };
+    string: {
+        base: () => ValidationMessage;
+        min: (value: number) => ValidationMessage;
+        max: (value: number) => ValidationMessage;
+    };
+    array: {
+        base: () => ValidationMessage;
+        min: (value: number) => ValidationMessage;
+        max: (value: number) => ValidationMessage;
+    };
+    password: {
+        length: (value: number) => ValidationMessage;
+        specialChars: (value: number) => ValidationMessage;
+        lowerUpperCasePattern: () => ValidationMessage;
+        numbers: (value: number) => ValidationMessage;
+    };
+};

package/dist/core/delivery/schema/rules/messages/types.js

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

package/dist/core/delivery/serverAction/CreateServerAction.d.ts

@@ -1,7 +1,7 @@
 import { RequestContext } from '../../../edges/context/index.js';
 import { error, fail, redirect } from '@sveltejs/kit';
 type Deps = {
-    context: Required<ReturnType<typeof RequestContext.current>>;
+    context: Required<ReturnType<typeof RequestContext.current>['event']>;
     utils: {
         fail: typeof fail;
         redirect: typeof redirect;