@azure-net/node-kit 0.0.0-stage → 0.1.0

package/dist/validation/messages/Ru.js

@@ -0,0 +1,118 @@
+/** Flat, dependency-free Russian catalog keyed by validation code. */
+export const validationMessagesRu = Object.freeze({
+    "type.object": "Значение должно быть объектом.",
+    "type.array": "Значение должно быть массивом.",
+    "type.tuple": "Значение должно соответствовать структуре кортежа.",
+    "type.record": "Значение должно быть словарём.",
+    "type.map": "Значение должно быть Map.",
+    "type.set": "Значение должно быть Set.",
+    "type.union": "Значение должно соответствовать одному из допустимых вариантов.",
+    "type.intersection": "Значение должно соответствовать всем правилам пересечения.",
+    "type.lazy": "Значение должно соответствовать вычисленным правилам проверки.",
+    "type.validator": "Значение должно соответствовать правилам вложенного валидатора.",
+    "object.unknownKeys": "Объект содержит неизвестные поля.",
+    "object.accessor": "Свойства с геттерами или сеттерами не поддерживаются.",
+    "validation.depth": "Превышена максимальная глубина проверки.",
+    "validation.nodes": "Превышено максимальное количество узлов проверки.",
+    "validation.cycle": "Циклические ссылки не поддерживаются.",
+    "custom.invalid": "Недопустимое значение.",
+    "array.unique": "Элементы массива должны быть уникальными.",
+    "array.length": ({ params }) => `Количество элементов массива должно быть равно ${String(params.length)}.`,
+    "array.contains": "Массив должен содержать указанное значение.",
+    "array.some": "Хотя бы один элемент массива должен удовлетворять условию.",
+    "array.every": "Каждый элемент массива должен удовлетворять условию.",
+    "comparison.sameAs": "Значение должно совпадать со значением указанного поля.",
+    "comparison.notSameAs": "Значение должно отличаться от значения указанного поля.",
+    string: "Значение должно быть строкой.",
+    number: "Значение должно быть конечным числом.",
+    finite: "Значение должно быть конечным числом.",
+    bigint: "Значение должно иметь тип bigint.",
+    boolean: "Значение должно быть логическим.",
+    date: "Значение должно быть корректным объектом Date.",
+    symbol: "Значение должно иметь тип symbol.",
+    literal: "Значение должно совпадать с заданным литералом.",
+    enum: "Значение должно входить в перечисление.",
+    enumName: "Значение должно быть допустимым именем элемента перечисления.",
+    integer: "Значение должно быть целым числом.",
+    safeInteger: "Значение должно быть целым числом в безопасном диапазоне.",
+    int32: "Значение должно быть знаковым 32-битным целым числом.",
+    uint32: "Значение должно быть беззнаковым 32-битным целым числом.",
+    float32: "Значение должно быть конечным числом в диапазоне 32-битного числа с плавающей точкой.",
+    int64: "Значение должно быть знаковым 64-битным bigint.",
+    uint64: "Значение должно быть беззнаковым 64-битным bigint.",
+    lessThan: ({ params }) => `Значение должно быть ${params.inclusive === true ? "не больше" : "меньше"} ${String(params.max)}.`,
+    greaterThan: ({ params }) => `Значение должно быть ${params.inclusive === true ? "не меньше" : "больше"} ${String(params.min)}.`,
+    lessThanOrEqual: ({ params }) => `Значение должно быть не больше ${String(params.max)}.`,
+    greaterThanOrEqual: ({ params }) => `Значение должно быть не меньше ${String(params.min)}.`,
+    positive: "Значение должно быть положительным.",
+    negative: "Значение должно быть отрицательным.",
+    nonNegative: "Значение должно быть неотрицательным.",
+    nonPositive: "Значение должно быть неположительным.",
+    min: ({ params }) => `Значение должно быть ${params.inclusive === false ? "больше" : "не меньше"} ${String(params.min)}.`,
+    max: ({ params }) => `Значение должно быть ${params.inclusive === false ? "меньше" : "не больше"} ${String(params.max)}.`,
+    between: ({ params }) => `Значение должно быть ${params.minInclusive === false ? "больше" : "не меньше"} ${String(params.min)} и ${params.maxInclusive === false ? "меньше" : "не больше"} ${String(params.max)}.`,
+    multipleOf: ({ params }) => `Значение должно быть кратно ${String(params.divisor)}.`,
+    decimal: "Значение должно быть десятичным числом с допустимым количеством знаков после запятой.",
+    precisionScale: "Значение должно соответствовать заданной точности и масштабу.",
+    equal: "Значение должно совпадать с ожидаемым.",
+    notEqual: "Значение должно отличаться от запрещённого.",
+    notNull: "Значение не должно быть null.",
+    required: "Обязательное значение.",
+    notEmpty: "Значение не должно быть пустым.",
+    empty: "Значение должно быть пустым.",
+    unknown: "Недопустимое значение.",
+    never: "Никакое значение не допускается.",
+    null: "Значение должно быть null.",
+    undefined: "Значение должно быть undefined.",
+    nan: "Значение должно быть NaN.",
+    instanceOf: "Значение должно быть экземпляром указанного класса.",
+    file: "Файл должен соответствовать требованиям к размеру, типу и расширению.",
+    blob: "Значение должно быть Blob или File и соответствовать заданным требованиям.",
+    before: "Дата должна предшествовать указанной дате.",
+    after: "Дата должна следовать за указанной датой.",
+    same: "Дата должна совпадать с указанной датой.",
+    isPast: "Дата должна быть в прошлом.",
+    isFuture: "Дата должна быть в будущем.",
+    length: ({ params }) => `Длина должна быть равна ${String(params.length)}.`,
+    minLength: ({ params }) => `Длина должна быть не меньше ${String(params.minLength)}.`,
+    maxLength: ({ params }) => `Длина должна быть не больше ${String(params.maxLength)}.`,
+    matches: "Значение должно соответствовать заданному шаблону.",
+    includes: "Строка должна содержать указанную подстроку.",
+    startsWith: "Строка должна начинаться с указанного префикса.",
+    endsWith: "Строка должна заканчиваться указанным суффиксом.",
+    lowercase: "Строка должна быть в нижнем регистре.",
+    uppercase: "Строка должна быть в верхнем регистре.",
+    email: "Некорректный адрес электронной почты.",
+    uuid: "Некорректный UUID.",
+    guid: "Некорректный GUID.",
+    url: "Некорректный абсолютный URL.",
+    httpUrl: "Некорректный HTTP или HTTPS URL.",
+    hostname: "Некорректное имя хоста.",
+    e164: "Номер телефона должен соответствовать формату E.164.",
+    emoji: "Строка должна содержать корректные последовательности эмодзи.",
+    base64: "Некорректная строка Base64.",
+    base64url: "Некорректная строка Base64url.",
+    hex: "Строка должна быть шестнадцатеричной.",
+    jwt: "Некорректный синтаксис JWT.",
+    nanoid: "Некорректный Nano ID.",
+    cuid: "Некорректный CUID.",
+    cuid2: "Некорректный CUID2.",
+    ulid: "Некорректный ULID.",
+    xid: "Некорректный XID.",
+    ksuid: "Некорректный KSUID.",
+    ip: "Некорректный IP-адрес.",
+    ipv4: "Некорректный IPv4-адрес.",
+    ipv6: "Некорректный IPv6-адрес.",
+    cidr: "Некорректная запись CIDR.",
+    cidrv4: "Некорректная запись IPv4 CIDR.",
+    cidrv6: "Некорректная запись IPv6 CIDR.",
+    mac: "Некорректный MAC-адрес.",
+    creditCard: "Некорректный номер карты.",
+    iban: "Некорректный IBAN.",
+    currencyCode: "Неподдерживаемый код валюты.",
+    hash: "Хеш должен соответствовать заданному формату.",
+    isoDate: "Некорректная дата ISO.",
+    isoTime: "Некорректное время ISO.",
+    isoDateTime: "Некорректные дата и время ISO.",
+    isoDuration: "Некорректная длительность ISO.",
+});

package/dist/validation/messages/index.d.ts

@@ -0,0 +1,7 @@
+import { validationMessagesEn } from "./En.js";
+import { validationMessagesRu } from "./Ru.js";
+export { validationMessagesEn, validationMessagesRu };
+export declare const validationMessagesI18n: Readonly<{
+    en: Readonly<Record<string, import("../Types.js").ValidationMessage>>;
+    ru: Readonly<Record<string, import("../Types.js").ValidationMessage>>;
+}>;

package/dist/validation/messages/index.js

@@ -0,0 +1,7 @@
+import { validationMessagesEn } from "./En.js";
+import { validationMessagesRu } from "./Ru.js";
+export { validationMessagesEn, validationMessagesRu };
+export const validationMessagesI18n = Object.freeze({
+    en: validationMessagesEn,
+    ru: validationMessagesRu,
+});

package/dist/validation/rules/CustomRules.d.ts

@@ -0,0 +1,8 @@
+import type { BuiltinRule, FieldRule, RuleContext, RuleOptions, ValidationRule } from "../Types.js";
+export declare const customRules: {
+    /** Conditional value checks only. Declare structural type rules outside this group. */
+    when<T, D = unknown, R = D, C = unknown>(condition: (context: RuleContext<T, D, R, C>) => boolean, checks: readonly FieldRule<T, D, R, C>[]): ValidationRule<T, D, R, C>;
+    contains(expected: unknown, options?: RuleOptions): BuiltinRule<never>;
+    some<T>(predicate: (value: T, index: number) => boolean, options?: RuleOptions): ValidationRule<T[]>;
+    every<T>(predicate: (value: T, index: number) => boolean, options?: RuleOptions): ValidationRule<T[]>;
+};

package/dist/validation/rules/CustomRules.js

@@ -0,0 +1,64 @@
+import { isDeepStrictEqual } from "node:util";
+import { testRule } from "./Factory.js";
+function isAsync(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        "then" in value &&
+        typeof value.then === "function");
+}
+function failure(result, rule) {
+    if (result === true)
+        return true;
+    const base = {
+        code: rule.code,
+        params: rule.params,
+        ...rule.options,
+    };
+    if (result === false)
+        return base;
+    if (Array.isArray(result))
+        return result.map((item) => ({ ...base, ...item }));
+    return { ...base, ...result };
+}
+export const customRules = {
+    /** Conditional value checks only. Declare structural type rules outside this group. */
+    when(condition, checks) {
+        const snapshot = [...checks];
+        for (const rule of snapshot) {
+            if (typeof rule !== "function" &&
+                (rule.kind !== "test" || rule.structural)) {
+                throw new TypeError("when() accepts value constraints and callbacks; declare structural rules outside it.");
+            }
+        }
+        return (context) => {
+            if (!condition(context))
+                return true;
+            const run = (start) => {
+                for (let index = start; index < snapshot.length; index++) {
+                    const rule = snapshot[index];
+                    const output = typeof rule === "function"
+                        ? rule(context)
+                        : failure(rule.test(context.value, context), rule);
+                    if (isAsync(output))
+                        return Promise.resolve(output).then((result) => result === true || (Array.isArray(result) && !result.length)
+                            ? run(index + 1)
+                            : result);
+                    if (output !== true && !(Array.isArray(output) && !output.length))
+                        return output;
+                }
+                return true;
+            };
+            return run(0);
+        };
+    },
+    contains(expected, options = {}) {
+        return testRule("array.contains", (value) => Array.isArray(value) &&
+            value.some((item) => isDeepStrictEqual(item, expected)), options);
+    },
+    some(predicate, options = {}) {
+        return ({ value }) => value.some(predicate) || { code: "array.some", ...options };
+    },
+    every(predicate, options = {}) {
+        return ({ value }) => value.every(predicate) || { code: "array.every", ...options };
+    },
+};

package/dist/validation/rules/Factory.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinRule, RuleContext, RuleOptions, RuleResult, ValidationParams } from "../Types.js";
+export declare function testRule<T = never>(code: string, test: (value: unknown, context: RuleContext<unknown>) => RuleResult, options?: RuleOptions, params?: ValidationParams, structural?: boolean): BuiltinRule<T>;
+export declare function descriptor<T>(rule: Omit<BuiltinRule<T>, "output">): BuiltinRule<T>;
+export declare function sizeOption(value: number, name: string): void;

package/dist/validation/rules/Factory.js

@@ -0,0 +1,21 @@
+export function testRule(code, test, options = {}, params = {}, structural = false) {
+    return Object.freeze({
+        kind: "test",
+        code,
+        test,
+        structural,
+        options: Object.freeze({ ...options }),
+        params: Object.freeze({ ...params }),
+    });
+}
+export function descriptor(rule) {
+    return Object.freeze({
+        ...rule,
+        options: Object.freeze({ ...rule.options }),
+        params: Object.freeze({ ...rule.params }),
+    });
+}
+export function sizeOption(value, name) {
+    if (!Number.isSafeInteger(value) || value < 0)
+        throw new RangeError(`${name} must be a non-negative safe integer.`);
+}

package/dist/validation/rules/StringRules.d.ts

@@ -0,0 +1,105 @@
+import type { BuiltinRule, RuleOptions } from "../Types.js";
+export interface LengthOptions extends RuleOptions {
+    readonly unit?: "codePoints" | "codeUnits";
+}
+export interface UuidOptions extends RuleOptions {
+    readonly version?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+}
+/** Caller-supplied patterns must be trusted: JavaScript RegExp has no execution timeout. */
+export interface UrlOptions extends RuleOptions {
+    readonly protocol?: RegExp;
+    readonly hostname?: RegExp;
+}
+export interface NanoidOptions extends RuleOptions {
+    readonly length?: number;
+}
+export interface JwtOptions extends RuleOptions {
+    readonly algorithm?: string;
+}
+export interface MacOptions extends RuleOptions {
+    readonly delimiter?: ":" | "-" | "";
+}
+export interface HashOptions extends RuleOptions {
+    readonly encoding?: "hex" | "base64" | "base64url";
+}
+export interface IsoTimeOptions extends RuleOptions {
+    readonly precision?: number | null;
+}
+export interface IsoDateTimeOptions extends IsoTimeOptions {
+    readonly offset?: boolean;
+    readonly local?: boolean;
+}
+export type HashAlgorithm = "md5" | "sha1" | "sha256" | "sha384" | "sha512";
+/**
+ * Noncoercive format checks. Format scope was reviewed against Zod 4.6.7's
+ * src/v4/core/{regexes,schemas}.ts (MIT, Colin McDonnell and contributors).
+ * Implementations below are independent; no Zod runtime dependency is required.
+ */
+export declare const stringRules: {
+    string(options?: RuleOptions): BuiltinRule<string>;
+    /** Strings count Unicode code points by default, arrays count elements, maps/sets count entries. */
+    length(length: number, options?: LengthOptions): BuiltinRule<never>;
+    minLength(minLength: number, options?: LengthOptions): BuiltinRule<never>;
+    maxLength(maxLength: number, options?: LengthOptions): BuiltinRule<never>;
+    /** State-safe, not ReDoS-safe: callers are responsible for their pattern's complexity. */
+    matches(regex: RegExp, options?: RuleOptions): BuiltinRule<string>;
+    includes(substring: string, options?: RuleOptions): BuiltinRule<string>;
+    startsWith(prefix: string, options?: RuleOptions): BuiltinRule<string>;
+    endsWith(suffix: string, options?: RuleOptions): BuiltinRule<string>;
+    lowercase(options?: RuleOptions): BuiltinRule<string>;
+    uppercase(options?: RuleOptions): BuiltinRule<string>;
+    /** ASCII dot-atom mailbox with a dotted DNS domain; not all RFC 5322 mailboxes. */
+    email(options?: RuleOptions): BuiltinRule<string>;
+    /** RFC 9562 versions 1-8 and, without a version filter, Nil/Max UUIDs. */
+    uuid(options?: UuidOptions): BuiltinRule<string>;
+    guid(options?: RuleOptions): BuiltinRule<string>;
+    /** Absolute WHATWG URLs, including non-HTTP schemes; not a safe-URL/security policy. */
+    url(options?: UrlOptions): BuiltinRule<string>;
+    httpUrl(options?: UrlOptions): BuiltinRule<string>;
+    /** ASCII DNS labels, optionally terminated by a root dot; use punycode for IDNs. */
+    hostname(options?: RuleOptions): BuiltinRule<string>;
+    /** International '+' notation with 2-15 digits; does not verify allocation or reachability. */
+    e164(options?: RuleOptions): BuiltinRule<string>;
+    /** Common emoji sequences, not a versioned Unicode RGI membership check. */
+    emoji(options?: RuleOptions): BuiltinRule<string>;
+    /** Canonical padded RFC 4648 encoding (empty input is valid). */
+    base64(options?: RuleOptions): BuiltinRule<string>;
+    /** Canonical unpadded RFC 4648 URL encoding (empty input is valid). */
+    base64url(options?: RuleOptions): BuiltinRule<string>;
+    hex(options?: RuleOptions): BuiltinRule<string>;
+    /** Compact signed JWT syntax only: no signature, claim, expiry, or algorithm-security verification. */
+    jwt(options?: JwtOptions): BuiltinRule<string>;
+    nanoid(options?: NanoidOptions): BuiltinRule<string>;
+    /** Canonical 25-character CUID v1 shape, not proof of provenance. */
+    cuid(options?: RuleOptions): BuiltinRule<string>;
+    /** CUID2 allows custom lengths: lowercase leading letter followed by lowercase alphanumerics. */
+    cuid2(options?: RuleOptions): BuiltinRule<string>;
+    ulid(options?: RuleOptions): BuiltinRule<string>;
+    /** Zod-compatible 20-character base32hex shape, case-insensitive; no padding-bit or provenance check. */
+    xid(options?: RuleOptions): BuiltinRule<string>;
+    /** Zod-compatible 27-character base62 shape; no decoded 160-bit range or timestamp check. */
+    ksuid(options?: RuleOptions): BuiltinRule<string>;
+    ip(options?: RuleOptions): BuiltinRule<string>;
+    ipv4(options?: RuleOptions): BuiltinRule<string>;
+    ipv6(options?: RuleOptions): BuiltinRule<string>;
+    /** CIDR address/prefix notation; host bits need not be zero. */
+    cidr(options?: RuleOptions): BuiltinRule<string>;
+    cidrv4(options?: RuleOptions): BuiltinRule<string>;
+    cidrv6(options?: RuleOptions): BuiltinRule<string>;
+    mac(options?: MacOptions): BuiltinRule<string>;
+    /** 12-19 digit PAN with optional single space/hyphen separators and Luhn checksum, not issuer verification. */
+    creditCard(options?: RuleOptions): BuiltinRule<string>;
+    /** Electronic IBAN shape and MOD-97 checksum; no country-specific BBAN or bank registry validation. */
+    iban(options?: RuleOptions): BuiltinRule<string>;
+    /** Uppercase currencies supported by the host's ICU data, not a live ISO 4217 registry. */
+    currencyCode(options?: RuleOptions): BuiltinRule<string>;
+    hash(algorithm: HashAlgorithm, options?: HashOptions): BuiltinRule<string>;
+    /** Gregorian calendar YYYY-MM-DD, including astronomical year 0000. */
+    isoDate(options?: RuleOptions): BuiltinRule<string>;
+    /** Local HH:mm[:ss[.fraction]]; no leap seconds or 24:00. precision -1 means minutes. */
+    isoTime(options?: IsoTimeOptions): BuiltinRule<string>;
+    /** UTC by default; explicit opt-ins for offsets and local time. Zoned forms require seconds unless precision=-1. */
+    isoDateTime(options?: IsoDateTimeOptions): BuiltinRule<string>;
+    /** ISO 8601-1 subset: weeks alone, or ordered Y/M/D and H/M/S; fractions only on seconds. */
+    isoDuration(options?: RuleOptions): BuiltinRule<string>;
+};