@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/core/sdd/coordination/redis-runtime.d.ts

@@ -0,0 +1,131 @@
+import type { GlobalConfig } from '../../global-config.js';
+import type { CoordinationCacheAdapter, CoordinationEvent, CoordinationEventBusAdapter, CoordinationLockAdapter, CoordinationQueueAdapter } from './coordination-adapters.js';
+import { type AcquireOptions } from '../state-lock.js';
+export type RedisRuntimeStatus = 'disabled' | 'requested-unavailable' | 'ready' | 'degraded' | 'blocked';
+export type RedisFallbackMode = 'filesystem' | 'none';
+export interface RedisRuntimeConfig {
+    requested: boolean;
+    enabled: boolean;
+    namespace: string;
+    url?: string;
+    redactedUrl?: string;
+    tls: boolean;
+    connectTimeoutMs: number;
+    commandTimeoutMs: number;
+    maxRetries: number;
+    fallback: RedisFallbackMode;
+    cacheDefaultTtlMs: number;
+    lockTtlMs: number;
+    streamMaxLen: number;
+    validationErrors: string[];
+    warnings: string[];
+}
+export interface RedisOperationalReport {
+    requested: boolean;
+    namespace: string;
+    status: RedisRuntimeStatus;
+    fallback: RedisFallbackMode;
+    redacted_url?: string;
+    latency_ms?: number;
+    reason: string;
+    validation_errors: string[];
+    warnings: string[];
+}
+export interface RedisCommandClient {
+    isReady?: boolean;
+    isOpen?: boolean;
+    connect(): Promise<RedisCommandClient>;
+    ping(): Promise<string>;
+    sendCommand<T = unknown>(args: ReadonlyArray<string>): Promise<T>;
+    close?(): Promise<void>;
+    destroy?(): void;
+    on?(event: 'error', listener: (error: Error) => void): RedisCommandClient;
+}
+export type RedisClientCreator = (config: RedisRuntimeConfig) => RedisCommandClient;
+export declare function redactRedisUrl(url: string | undefined): string | undefined;
+export declare function sanitizeRedisError(error: unknown, config?: Pick<RedisRuntimeConfig, 'url'>): string;
+export declare function hashRedisKey(input: string): string;
+export declare function buildRedisKey(config: RedisRuntimeConfig, projectFingerprint: string, domain: string, key: string): string;
+export declare function resolveRedisRuntimeConfig(env?: NodeJS.ProcessEnv, globalConfig?: Partial<GlobalConfig>): RedisRuntimeConfig;
+export declare function resolveRedisBoundaryConfig(env?: NodeJS.ProcessEnv, globalConfig?: Partial<GlobalConfig>): RedisRuntimeConfig;
+export declare class RedisClientFactory {
+    readonly config: RedisRuntimeConfig;
+    private readonly createClientImpl;
+    private client?;
+    private lastError?;
+    constructor(config: RedisRuntimeConfig, createClientImpl?: RedisClientCreator);
+    getClient(): Promise<RedisCommandClient>;
+    ping(): Promise<{
+        ok: boolean;
+        latencyMs?: number;
+        message: string;
+    }>;
+    command<T = unknown>(args: ReadonlyArray<string>): Promise<T>;
+    close(): Promise<void>;
+    getLastError(): string | undefined;
+}
+export declare function buildRedisOperationalReport(options?: {
+    env?: NodeJS.ProcessEnv;
+    globalConfig?: Partial<GlobalConfig>;
+    createClient?: RedisClientCreator;
+}): Promise<RedisOperationalReport>;
+export declare class RedisCoordinationCache implements CoordinationCacheAdapter {
+    private readonly redis;
+    private readonly fallback;
+    private readonly projectFingerprint;
+    private readonly domain;
+    constructor(redis: RedisClientFactory, fallback: CoordinationCacheAdapter, projectFingerprint: string, domain?: string);
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, options?: {
+        ttlMs?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class RedisLockAdapter implements CoordinationLockAdapter {
+    private readonly redis;
+    private readonly fallback;
+    private readonly projectFingerprint;
+    constructor(redis: RedisClientFactory, fallback: CoordinationLockAdapter, projectFingerprint: string);
+    withLock<T>(scope: string, fn: () => Promise<T>, options?: AcquireOptions): Promise<T>;
+    extend(scope: string, ownerToken: string, ttlMs?: number): Promise<boolean>;
+    private release;
+}
+export declare class RedisQueueAdapter<T = unknown> implements CoordinationQueueAdapter<T> {
+    private readonly redis;
+    private readonly fallback;
+    private readonly projectFingerprint;
+    constructor(redis: RedisClientFactory, fallback: CoordinationQueueAdapter<T>, projectFingerprint: string);
+    enqueue(topic: string, item: T): Promise<void>;
+    dequeue(topic: string): Promise<T | undefined>;
+    size(topic: string): Promise<number>;
+}
+export declare class RedisEventBusAdapter implements CoordinationEventBusAdapter {
+    private readonly redis;
+    private readonly fallback;
+    private readonly projectFingerprint;
+    constructor(redis: RedisClientFactory, fallback: CoordinationEventBusAdapter, projectFingerprint: string);
+    publish(event: CoordinationEvent): Promise<void>;
+    drain(): Promise<CoordinationEvent[]>;
+}
+export declare class RedisWorkDeduper {
+    private readonly redis;
+    private readonly projectFingerprint;
+    constructor(redis: RedisClientFactory, projectFingerprint: string);
+    claim(key: string, ttlMs?: number): Promise<boolean>;
+}
+export declare function deleteKeysByPrefix(redis: RedisClientFactory, prefix: string): Promise<number>;
+export declare function runRedisBenchmark(options: {
+    env?: NodeJS.ProcessEnv;
+    globalConfig?: Partial<GlobalConfig>;
+    createClient?: RedisClientCreator;
+    iterations?: number;
+}): Promise<{
+    status: RedisRuntimeStatus;
+    namespace: string;
+    iterations: number;
+    p50_ms?: number;
+    p95_ms?: number;
+    reason: string;
+}>;
+//# sourceMappingURL=redis-runtime.d.ts.map