@verdeect/kit 0.0.0-stage → 1.0.0-rc.1

package/dist/observability/sentry.js

@@ -0,0 +1,233 @@
+// initSentry, скраббер событий, captureError и captureThrottled (prd.md §3.2, AC-2.4, AC-2.5, AC-2.6, AC-2.12, NFR-4).
+// Эталоны: O instrument.ts (NO_PERSONAL_DATA, условие включения, tracesSampleRate 0), O sentry-scrubber.ts (scrubValue,
+// глубина 8 → [Truncated], заголовки, user → {id}, хвост params: и Key (…)=(…), запасной путь при исключении), троттлинг —
+// O pool-timeout-reporter.ts (окно 60 с, performance.now()). По PRD: имена — sensitiveNames(redaction) без доменных ключей
+// O; query удаляется целиком (и из request.url); путь — через maskPath; envSentry разбирается без исключения.
+// envSentry — из fragments.js, не из config/index.js: индекс тянет @nestjs/*, а instrument.ts грузится до Nest (LE-5).
+import * as Sentry from '@sentry/nestjs';
+import { z } from 'zod';
+import { envSentry } from '../config/fragments.js';
+import { maskPathOf, sensitiveNames } from './redaction.js';
+import { sanitizeError } from './sanitize-error.js';
+/** Sentry 11: вместо sendDefaultPii — ничего из ПДн, заголовков, тел, query и данных БД не собирается. */
+export const NO_PERSONAL_DATA = {
+    userInfo: false,
+    cookies: false,
+    httpHeaders: false,
+    httpBodies: [],
+    urlQueryParams: false,
+    databaseQueryData: false,
+    queues: false,
+    stackFrameVariables: false,
+    genAI: { inputs: false, outputs: false },
+};
+const FILTERED = '[Filtered]';
+const TRUNCATED = '[Truncated]';
+const MAX_DEPTH = 8;
+const DROPPED_HEADERS = new Set(['authorization', 'cookie', 'set-cookie', 'x-forwarded-for']);
+const DEFAULT_WINDOW_MS = 60_000;
+// То же выражение, что DSN_REGEX @sentry/core utils/dsn.js: неверный DSN SDK печатает через console.error со значением.
+const DSN_REGEX = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)((?:\[[:.%\w]+\]|[\w.-]+))(?::(\d+))?\/(.+)/;
+// Хвост сообщения DrizzleQueryError («\nparams: …») и detail pg «Key (sub)=(…)».
+const PARAMS_TAIL = /\nparams:[\s\S]*$/;
+const KEY_VALUE = /Key \([^)]*\)=\([^)]*\)/g;
+const URL_PARTS = /^([a-z][a-z\d+.-]*:\/\/[^/]*)?(.*)$/i;
+function scrubNames(redaction) {
+    const names = sensitiveNames(redaction).map((name) => name.toLowerCase());
+    return {
+        plain: new Set(names.filter((name) => !name.includes('.'))),
+        dotted: new Set(names.filter((name) => name.includes('.'))),
+    };
+}
+function isSensitive(names, key, parent) {
+    const lower = key.toLowerCase();
+    if (names.plain.has(lower)) {
+        return true;
+    }
+    return parent !== undefined && names.dotted.has(`${parent.toLowerCase()}.${lower}`);
+}
+function scrubValue(value, names, depth = 0, parent) {
+    if (typeof value !== 'object' || value === null) {
+        return value;
+    }
+    if (depth >= MAX_DEPTH) {
+        return TRUNCATED;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => scrubValue(item, names, depth + 1, parent));
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        isSensitive(names, key, parent) ? FILTERED : scrubValue(item, names, depth + 1, key),
+    ]));
+}
+/** Адрес без query и фрагмента, путь — через maskPath. */
+function scrubUrl(url, maskPath) {
+    const base = url.split(/[?#]/, 1)[0] ?? '';
+    const [, origin = '', path = ''] = URL_PARTS.exec(base) ?? [];
+    return `${origin}${maskPath(path)}`;
+}
+function scrubExceptionText(value) {
+    return value.replace(PARAMS_TAIL, '').replace(KEY_VALUE, 'Key [Filtered]');
+}
+/**
+ * Текст исключений: ошибка, которую изменил sanitizeError (БД, ioredis, ветка сервиса), — его сообщение во всех values
+ * (linkedErrors добавляет цепочку cause отдельными values; текст ioredis повторяет ключи Redis); прочие — без хвоста
+ * params: и «Key (…)=(…)».
+ */
+function scrubException(event, originalException) {
+    const values = event.exception?.values;
+    if (!values) {
+        return;
+    }
+    const sanitized = sanitizeError(originalException);
+    const safeMessage = sanitized instanceof Error && sanitized !== originalException ? sanitized.message : null;
+    for (const value of values) {
+        if (safeMessage !== null) {
+            value.value = scrubExceptionText(safeMessage);
+        }
+        else if (value.value !== undefined) {
+            value.value = scrubExceptionText(value.value);
+        }
+    }
+}
+function scrubRequest(request, names, maskPath) {
+    if (typeof request.url === 'string') {
+        request.url = scrubUrl(request.url, maskPath);
+    }
+    delete request.query_string;
+    delete request.cookies;
+    delete request.data;
+    if (request.headers) {
+        const headers = Object.fromEntries(Object.entries(request.headers).filter(([name]) => !DROPPED_HEADERS.has(name.toLowerCase())));
+        request.headers = scrubValue(headers, names);
+    }
+}
+/** Хлебная крошка без чувствительных данных; адрес — без query и через maskPath. Внутренняя функция. */
+export function scrubBreadcrumb(crumb, redaction) {
+    if (!crumb.data) {
+        return crumb;
+    }
+    const data = scrubValue(crumb.data, scrubNames(redaction));
+    if (typeof data.url === 'string') {
+        data.url = scrubUrl(data.url, maskPathOf(redaction));
+    }
+    return { ...crumb, data };
+}
+/**
+ * Событие без query, `request.data`, cookie, ПДн пользователя (кроме `id`) и значений чувствительных имён в
+ * extra, contexts, tags и breadcrumbs (§3.2, AC-2.5). Внутренняя функция. При исключении отбрасываются
+ * request, extra, breadcrumbs и exception.
+ */
+export function scrubEvent(event, originalException, redaction) {
+    try {
+        const names = scrubNames(redaction);
+        scrubException(event, originalException);
+        if (event.request) {
+            scrubRequest(event.request, names, maskPathOf(redaction));
+        }
+        if (event.user) {
+            event.user = event.user.id === undefined ? {} : { id: event.user.id };
+        }
+        if (event.extra) {
+            event.extra = scrubValue(event.extra, names);
+        }
+        if (event.contexts) {
+            event.contexts = scrubValue(event.contexts, names);
+        }
+        if (event.tags) {
+            event.tags = scrubValue(event.tags, names);
+        }
+        if (event.breadcrumbs) {
+            event.breadcrumbs = event.breadcrumbs.map((crumb) => scrubBreadcrumb(crumb, redaction));
+        }
+        return event;
+    }
+    catch {
+        delete event.request;
+        delete event.extra;
+        delete event.breadcrumbs;
+        delete event.exception;
+        return event;
+    }
+}
+/**
+ * DSN в форме, которую принимает SDK: иначе он сам печатает значение в console.error (NFR-4). Внутренняя функция: её же
+ * использует bootstrapService для SENTRY_NOT_PRELOADED.
+ */
+export function isValidDsn(dsn) {
+    const match = DSN_REGEX.exec(dsn);
+    if (!match) {
+        return false;
+    }
+    const [, protocol, , , , , path = ''] = match;
+    const projectId = path.split('/').pop() ?? '';
+    return (protocol === 'http' || protocol === 'https') && /^\d+$/.test(projectId);
+}
+/**
+ * Включает GlitchTip (§3.2): вызывается в `instrument.ts` сервиса, подключённом через `node --import` до загрузки
+ * приложения. Включается только при непустом и верном `SENTRY_DSN` и `NODE_ENV = production` (не задан — production);
+ * неверное окружение — Sentry выключен, без исключения и лога. `dataCollection: NO_PERSONAL_DATA`,
+ * `tracesSampleRate: 0`, тег `service`. Возвращает, включён ли SDK.
+ */
+export function initSentry(options) {
+    const parsed = z.object(envSentry).safeParse(process.env);
+    if (!parsed.success) {
+        return false;
+    }
+    const env = parsed.data;
+    if (env.SENTRY_DSN === null || env.NODE_ENV !== 'production' || !isValidDsn(env.SENTRY_DSN)) {
+        return false;
+    }
+    Sentry.init({
+        dsn: env.SENTRY_DSN,
+        environment: env.SENTRY_ENVIRONMENT ?? 'production',
+        ...(env.SENTRY_RELEASE === null ? {} : { release: env.SENTRY_RELEASE }),
+        dataCollection: NO_PERSONAL_DATA,
+        tracesSampleRate: 0,
+        initialScope: { tags: { service: options.service } },
+        beforeSend: (event, hint) => scrubEvent(event, hint.originalException, options.redaction),
+        beforeBreadcrumb: (crumb) => scrubBreadcrumb(crumb, options.redaction),
+    });
+    return true;
+}
+/** Ошибки, уже отправленные в GlitchTip. */
+const sentErrors = new WeakSet();
+/** Время последней отправки по ключу `captureThrottled` (performance.now()). */
+const lastSentAt = new Map();
+function wasSent(error) {
+    return typeof error === 'object' && error !== null && sentErrors.has(error);
+}
+/**
+ * Отправляет ошибку в GlitchTip через `sanitizeError` — ровно одно событие на ошибку (§3.2): объект ошибки
+ * помечается отправленным, повторный вызов ничего не шлёт.
+ */
+export function captureError(error, context) {
+    if (wasSent(error)) {
+        return;
+    }
+    Sentry.captureException(sanitizeError(error), {
+        ...(context?.tags === undefined ? {} : { tags: { ...context.tags } }),
+        ...(context?.extra === undefined ? {} : { extra: { ...context.extra } }),
+    });
+    if (typeof error === 'object' && error !== null) {
+        sentErrors.add(error);
+    }
+}
+/**
+ * Одно событие за окно `windowMs` (умолч. 60 000) на ключ в процессе (§3.2, AC-2.6). Уже отправленная ошибка
+ * (например, границей через `captureError`) повторно не шлётся. Возвращает, отправлено ли событие.
+ */
+export function captureThrottled(key, error, options) {
+    if (wasSent(error)) {
+        return false;
+    }
+    const now = performance.now();
+    const windowMs = options?.windowMs ?? DEFAULT_WINDOW_MS;
+    if (now - (lastSentAt.get(key) ?? -Infinity) < windowMs) {
+        return false;
+    }
+    lastSentAt.set(key, now);
+    captureError(error);
+    return true;
+}

package/dist/redis/channels.d.ts

@@ -0,0 +1,34 @@
+import type { Redis } from 'ioredis';
+import { type RedisLog } from './client.js';
+/** Обработчик сообщения канала: строка сообщения (JSON — забота сервиса). */
+type ChannelHandler = (message: string) => void | Promise<void>;
+/**
+ * Каналы Redis сервиса с префиксом `<svc>:` (§3.7): `publish('x')` публикует в `<svc>:x`, `subscribe('x')` слушает
+ * `<svc>:x` и отдаёт обработчику сообщение. Подписки требуют `KitRedisModule.forRoot({subscriber: true})`.
+ */
+export declare class KitRedisChannels {
+    private readonly redis;
+    private readonly prefix;
+    private readonly log;
+    private readonly subscriber?;
+    private readonly channels;
+    constructor(redis: Redis, prefix: string, log: RedisLog, subscriber?: Redis | undefined);
+    /**
+     * Публикует сообщение в канал `<svc>:<channel>` основным соединением; число получателей. Ошибка Redis — исключение
+     * вызывающему.
+     */
+    publish(channel: string, message: string): Promise<number>;
+    /**
+     * Подписывает обработчик на канал `<svc>:<channel>`; одна подписка Redis на канал. Разрешается после подтверждения
+     * `SUBSCRIBE` (одновременные вызовы ждут одного подтверждения); отказ `SUBSCRIBE` отклоняет все ожидающие вызовы, и
+     * следующий `subscribe` шлёт `SUBSCRIBE` заново. Возвращает функцию отписки: уход последнего обработчика —
+     * `UNSUBSCRIBE`. Ошибка обработчика — `error` + GlitchTip, остальные обработчики получают сообщение. Без
+     * `subscriber: true` — `Error`.
+     */
+    subscribe(channel: string, handler: ChannelHandler): Promise<() => Promise<void>>;
+    /** Новая запись канала и SUBSCRIBE; отказ снимает запись, если её ещё не заменили. */
+    private open;
+    private release;
+    private dispatch;
+}
+export {};

package/dist/redis/channels.js

@@ -0,0 +1,128 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+// KitRedisChannels (prd.md §3.7 «префикс к каналам ставит обёртка», AC-8.1, AC-8.6): keyPrefix ioredis не действует на
+// каналы. Механика Set обработчиков — O RedisBus, без JSON и повторов SUBSCRIBE (повторная подписка после
+// переподключения — autoResubscribe ioredis). KT-31: одно обещание SUBSCRIBE на канал — одновременные subscribe ждут его,
+// отказ SUBSCRIBE снимает запись канала (повторный subscribe шлёт SUBSCRIBE заново).
+import { Inject, Injectable, Optional } from '@nestjs/common';
+import { KIT_REDIS_LOG, KIT_REDIS_PREFIX, KIT_REDIS_SUBSCRIBER } from '../internal/tokens.js';
+import { sanitizeError } from '../observability/sanitize-error.js';
+import { captureError } from '../observability/sentry.js';
+import { KIT_REDIS } from './client.js';
+/**
+ * Каналы Redis сервиса с префиксом `<svc>:` (§3.7): `publish('x')` публикует в `<svc>:x`, `subscribe('x')` слушает
+ * `<svc>:x` и отдаёт обработчику сообщение. Подписки требуют `KitRedisModule.forRoot({subscriber: true})`.
+ */
+let KitRedisChannels = class KitRedisChannels {
+    redis;
+    prefix;
+    log;
+    subscriber;
+    channels = new Map();
+    constructor(redis, prefix, log, subscriber) {
+        this.redis = redis;
+        this.prefix = prefix;
+        this.log = log;
+        this.subscriber = subscriber;
+        this.subscriber?.on('message', (channel, message) => {
+            this.dispatch(channel, message);
+        });
+    }
+    /**
+     * Публикует сообщение в канал `<svc>:<channel>` основным соединением; число получателей. Ошибка Redis — исключение
+     * вызывающему.
+     */
+    publish(channel, message) {
+        return this.redis.publish(`${this.prefix}${channel}`, message);
+    }
+    /**
+     * Подписывает обработчик на канал `<svc>:<channel>`; одна подписка Redis на канал. Разрешается после подтверждения
+     * `SUBSCRIBE` (одновременные вызовы ждут одного подтверждения); отказ `SUBSCRIBE` отклоняет все ожидающие вызовы, и
+     * следующий `subscribe` шлёт `SUBSCRIBE` заново. Возвращает функцию отписки: уход последнего обработчика —
+     * `UNSUBSCRIBE`. Ошибка обработчика — `error` + GlitchTip, остальные обработчики получают сообщение. Без
+     * `subscriber: true` — `Error`.
+     */
+    async subscribe(channel, handler) {
+        const subscriber = this.subscriber;
+        if (subscriber === undefined) {
+            throw new Error('KitRedisChannels.subscribe: подписки требуют KitRedisModule.forRoot({subscriber: true})');
+        }
+        const full = `${this.prefix}${channel}`;
+        const state = this.channels.get(full) ?? this.open(subscriber, channel, full);
+        state.handlers.add(handler);
+        try {
+            await state.ready;
+        }
+        catch (error) {
+            state.handlers.delete(handler);
+            throw error;
+        }
+        let active = true;
+        return async () => {
+            if (!active) {
+                return;
+            }
+            active = false;
+            await this.release(subscriber, channel, full, state, handler);
+        };
+    }
+    /** Новая запись канала и SUBSCRIBE; отказ снимает запись, если её ещё не заменили. */
+    open(subscriber, channel, full) {
+        const state = { handlers: new Set(), ready: Promise.resolve() };
+        state.ready = subscriber.subscribe(full).then(() => {
+            this.log.debug({ channel }, 'redis: подписка на канал');
+        }, (error) => {
+            if (this.channels.get(full) === state) {
+                this.channels.delete(full);
+            }
+            this.log.debug({ channel, err: sanitizeError(error) }, 'redis: подписка на канал не удалась');
+            throw error;
+        });
+        this.channels.set(full, state);
+        return state;
+    }
+    async release(subscriber, channel, full, state, handler) {
+        state.handlers.delete(handler);
+        if (state.handlers.size > 0 || this.channels.get(full) !== state) {
+            return;
+        }
+        this.channels.delete(full);
+        await subscriber.unsubscribe(full);
+        this.log.debug({ channel }, 'redis: отписка от канала');
+    }
+    dispatch(full, message) {
+        const state = this.channels.get(full);
+        if (state === undefined || !full.startsWith(this.prefix)) {
+            return;
+        }
+        const channel = full.slice(this.prefix.length);
+        for (const handler of state.handlers) {
+            void Promise.resolve()
+                .then(() => handler(message))
+                .catch((error) => {
+                this.log.error({ channel, err: sanitizeError(error) }, 'redis: ошибка обработчика сообщения канала');
+                captureError(error);
+            });
+        }
+    }
+};
+KitRedisChannels = __decorate([
+    Injectable(),
+    __param(0, Inject(KIT_REDIS)),
+    __param(1, Inject(KIT_REDIS_PREFIX)),
+    __param(2, Inject(KIT_REDIS_LOG)),
+    __param(3, Optional()),
+    __param(3, Inject(KIT_REDIS_SUBSCRIBER)),
+    __metadata("design:paramtypes", [Function, String, Object, Function])
+], KitRedisChannels);
+export { KitRedisChannels };

package/dist/redis/client.d.ts

@@ -0,0 +1,42 @@
+import type { Redis } from 'ioredis';
+/** Токен основного соединения Redis: `Redis` ioredis с `keyPrefix <svc>:` (§3.7). */
+export declare const KIT_REDIS: unique symbol;
+/** Срок команды основного соединения, мс (§3.7, AC-8.2). */
+export declare const MAIN_COMMAND_TIMEOUT_MS = 500;
+/** Срок команды подписочного соединения, мс (§3.7, AC-8.6). */
+export declare const SUBSCRIBER_COMMAND_TIMEOUT_MS = 5000;
+/** Роль соединения в логах. */
+export type RedisConnectionRole = 'main' | 'subscriber';
+/** Логгер фоновых операций /redis: pino экземпляра (`service`, `replica` в `base`) или адаптер логгера Nest. */
+export interface RedisLog {
+    /** Уровень debug. */
+    debug(fields: object, message: string): void;
+    /** Уровень info. */
+    info(fields: object, message: string): void;
+    /** Уровень warn. */
+    warn(fields: object, message: string): void;
+    /** Уровень error. */
+    error(fields: object, message: string): void;
+}
+/** Адаптер логгера Nest (приложение без KIT_LOGGER); копия nestLog /messaging — импорт оттуда запрещён. */
+export declare function redisNestLog(context: string): RedisLog;
+/** Параметры соединения. */
+export interface RedisConnectionParams {
+    /** REDIS_URL (содержит пароль — в лог не пишется). */
+    readonly url: string;
+    /** Роль соединения. */
+    readonly connection: RedisConnectionRole;
+    /** Имя сервиса — имя клиента в `CLIENT LIST`. */
+    readonly service: string;
+    /** Префикс ключей; только у основного соединения. */
+    readonly keyPrefix?: string;
+    /** Логгер. */
+    readonly log: RedisLog;
+}
+/**
+ * Создаёт ленивое соединение (подключается при первой команде). Первая ошибка соединения после `ready` — `warn`, повторы
+ * до следующего `ready` — `debug` (переподключения не заливают лог). URL, ключи и аргументы команд в лог не попадают.
+ */
+export declare function createRedisConnection(params: RedisConnectionParams): Promise<Redis>;
+/** Закрывает соединение (D11): не подключено — `disconnect()`, иначе `quit()`; ошибка `quit` — `disconnect()`. */
+export declare function closeRedisConnection(redis: Redis, connection: RedisConnectionRole, log: RedisLog): Promise<void>;

package/dist/redis/client.js

@@ -0,0 +1,85 @@
+// Соединение ioredis /redis (prd.md §3.7, AC-8.2, AC-8.6, NFR-3). Эталон — O shared/redis/redis.provider.ts: lazyConnect,
+// maxRetriesPerRequest 1, commandTimeout 500 / 5000 для подписки, закрытие quit() → disconnect(), ошибки соединения без
+// URL. По PRD: keyPrefix <svc>: у основного соединения, enableReadyCheck: false (INFO запрещён ACL -@dangerous),
+// ioredis — динамический import() при создании (без top-level await, П15), логгер — pino экземпляра или адаптер Nest.
+import { Logger } from '@nestjs/common';
+import { sanitizeError } from '../observability/sanitize-error.js';
+/** Токен основного соединения Redis: `Redis` ioredis с `keyPrefix <svc>:` (§3.7). */
+export const KIT_REDIS = Symbol('KIT_REDIS');
+/** Срок команды основного соединения, мс (§3.7, AC-8.2). */
+export const MAIN_COMMAND_TIMEOUT_MS = 500;
+/** Срок команды подписочного соединения, мс (§3.7, AC-8.6). */
+export const SUBSCRIBER_COMMAND_TIMEOUT_MS = 5000;
+/** Адаптер логгера Nest (приложение без KIT_LOGGER); копия nestLog /messaging — импорт оттуда запрещён. */
+export function redisNestLog(context) {
+    const logger = new Logger(context);
+    return {
+        debug: (fields, message) => logger.debug(fields, message),
+        info: (fields, message) => logger.log(fields, message),
+        warn: (fields, message) => logger.warn(fields, message),
+        error: (fields, message) => logger.error(fields, message),
+    };
+}
+let ioredisPromise;
+/**
+ * Класс `Redis` ioredis, загружается один раз. Именованный `Redis`, а не `default`: ioredis — CommonJS, и при NodeNext
+ * ESM-`default` типизируется как весь `module.exports`.
+ */
+function loadIoredis() {
+    ioredisPromise ??= import('ioredis').then((module) => module.Redis);
+    return ioredisPromise;
+}
+/** Опции ioredis соединения (D9). */
+function optionsOf(params) {
+    const main = params.connection === 'main';
+    return {
+        lazyConnect: true,
+        maxRetriesPerRequest: 1,
+        // Проверка готовности шлёт INFO (@dangerous, запрещён ACL §3.7); при отказе ioredis пишет console.warn.
+        enableReadyCheck: false,
+        commandTimeout: main ? MAIN_COMMAND_TIMEOUT_MS : SUBSCRIBER_COMMAND_TIMEOUT_MS,
+        connectionName: main ? params.service : `${params.service}-subscriber`,
+        ...(main && params.keyPrefix !== undefined ? { keyPrefix: params.keyPrefix } : {}),
+    };
+}
+/**
+ * Создаёт ленивое соединение (подключается при первой команде). Первая ошибка соединения после `ready` — `warn`, повторы
+ * до следующего `ready` — `debug` (переподключения не заливают лог). URL, ключи и аргументы команд в лог не попадают.
+ */
+export async function createRedisConnection(params) {
+    const RedisClient = await loadIoredis();
+    const redis = new RedisClient(params.url, optionsOf(params));
+    const { connection, log } = params;
+    let failing = false;
+    redis.on('ready', () => {
+        failing = false;
+        log.debug({ connection }, 'redis: соединение готово');
+    });
+    redis.on('error', (error) => {
+        const fields = { connection, err: sanitizeError(error) };
+        if (failing) {
+            log.debug(fields, 'redis: ошибка соединения (повтор)');
+            return;
+        }
+        failing = true;
+        log.warn(fields, 'redis: ошибка соединения');
+    });
+    log.debug({ connection }, 'redis: соединение создано');
+    return redis;
+}
+/** Закрывает соединение (D11): не подключено — `disconnect()`, иначе `quit()`; ошибка `quit` — `disconnect()`. */
+export async function closeRedisConnection(redis, connection, log) {
+    if (redis.status === 'wait' || redis.status === 'end') {
+        redis.disconnect();
+        log.debug({ connection }, 'redis: соединение закрыто');
+        return;
+    }
+    try {
+        await redis.quit();
+    }
+    catch (error) {
+        log.debug({ connection, err: error instanceof Error ? error.name : 'unknown' }, 'redis: quit не удался, disconnect');
+        redis.disconnect();
+    }
+    log.debug({ connection }, 'redis: соединение закрыто');
+}

package/dist/redis/index.d.ts

@@ -0,0 +1,7 @@
+import './peer.js';
+export { KIT_REDIS } from './client.js';
+export { KitRedisChannels } from './channels.js';
+export { KitRedisModule } from './kit-redis.module.js';
+export type { KitRedisModuleOptions } from './kit-redis.module.js';
+export { RateLimiter, throwRateLimited } from './rate-limiter.js';
+export type { RateLimitOptions, RateLimitResult } from './rate-limiter.js';

package/dist/redis/index.js

@@ -0,0 +1,7 @@
+// Подпуть @verdeect/kit/redis (prd.md §3.7, D1): KitRedisModule, KIT_REDIS, KitRedisChannels, RateLimiter,
+// throwRateLimited. Первый импорт — проверка peer ioredis (AC-1.2).
+import './peer.js';
+export { KIT_REDIS } from './client.js';
+export { KitRedisChannels } from './channels.js';
+export { KitRedisModule } from './kit-redis.module.js';
+export { RateLimiter, throwRateLimited } from './rate-limiter.js';

package/dist/redis/kit-redis.module.d.ts

@@ -0,0 +1,18 @@
+import { type DynamicModule } from '@nestjs/common';
+/** Опции `KitRedisModule.forRoot`. */
+export interface KitRedisModuleOptions {
+    /** Имя сервиса (`^[a-z][a-z0-9-]{1,31}$`): префикс `<svc>:` ключей и каналов, имя клиента Redis. */
+    readonly service: string;
+    /** Второе соединение для подписок (`KitRedisChannels.subscribe`); без него подписки недоступны. */
+    readonly subscriber?: true;
+}
+/**
+ * Redis сервиса (§3.7): основное соединение `KIT_REDIS` с `keyPrefix <svc>:` (срок команды 500 мс), `KitRedisChannels`,
+ * `RateLimiter`, проба `/health` `redis` (некритичная), закрытие на шаге 4. `subscriber: true` — второе соединение для
+ * подписок (срок 5 с); без него второго соединения нет. `keyPrefix` не действует на шаблоны `KEYS`/`SCAN` — префикс в
+ * шаблон ставит сервис. `REDIS_URL` — из `KitConfigModule` (`envRedis`).
+ */
+export declare class KitRedisModule {
+    /** Модуль Redis сервиса; глобальный. */
+    static forRoot(options: KitRedisModuleOptions): DynamicModule;
+}