@vorionsys/platform-core 0.1.0

package/dist/common/redis-resilience.js

@@ -0,0 +1,586 @@
+/**
+ * Redis Circuit Breaker and Resilience
+ *
+ * Provides circuit breaker protection and graceful fallbacks for Redis operations
+ * to prevent cascading failures when Redis is unavailable or degraded.
+ *
+ * Features:
+ * - Circuit breaker with CLOSED -> OPEN -> HALF_OPEN states
+ * - Graceful fallbacks when Redis is unavailable:
+ *   - Rate limiting: allow requests with warning
+ *   - Locks: in-memory mutex (single instance only)
+ *   - Cache: bypass cache, query DB directly
+ * - 5 second timeout for all Redis operations
+ * - Metrics export for monitoring
+ *
+ * @packageDocumentation
+ */
+import { getCircuitBreaker, CircuitBreakerOpenError, withCircuitBreaker, withCircuitBreakerResult, } from './circuit-breaker.js';
+import { createLogger } from './logger.js';
+import { getRedis } from './redis.js';
+import { withTimeout } from './timeout.js';
+const logger = createLogger({ component: 'redis-resilience' });
+// Re-export useful types
+export { CircuitBreakerOpenError };
+/**
+ * Redis operation timeout in milliseconds (5 seconds)
+ */
+export const REDIS_OPERATION_TIMEOUT_MS = 5000;
+/**
+ * Redis circuit breaker service name
+ */
+export const REDIS_SERVICE_NAME = 'redis';
+/**
+ * In-memory mutex for fallback locking when Redis is unavailable.
+ * WARNING: Only works within a single Node.js instance!
+ */
+class InMemoryMutex {
+    locks = new Map();
+    cleanupInterval = null;
+    constructor() {
+        // Cleanup expired locks every 10 seconds
+        this.cleanupInterval = setInterval(() => this.cleanup(), 10000);
+        this.cleanupInterval.unref();
+    }
+    async acquire(key, ownerId, ttlMs, waitTimeoutMs = 0) {
+        const now = Date.now();
+        const existing = this.locks.get(key);
+        // Check if lock is held and not expired
+        if (existing && existing.expiresAt > now && existing.owner !== ownerId) {
+            // Lock is held by someone else
+            if (waitTimeoutMs <= 0) {
+                return false;
+            }
+            // Wait for lock to be released
+            return new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    // Remove from waiters and resolve false
+                    const lock = this.locks.get(key);
+                    if (lock) {
+                        lock.waiters = lock.waiters.filter(w => w.resolve !== resolve);
+                    }
+                    resolve(false);
+                }, waitTimeoutMs);
+                if (existing.waiters) {
+                    existing.waiters.push({ resolve, timeout });
+                }
+            });
+        }
+        // Acquire the lock
+        this.locks.set(key, {
+            owner: ownerId,
+            expiresAt: now + ttlMs,
+            waiters: existing?.waiters ?? [],
+        });
+        logger.debug({ key, ownerId, ttlMs }, 'In-memory lock acquired (fallback mode)');
+        return true;
+    }
+    release(key, ownerId) {
+        const existing = this.locks.get(key);
+        if (!existing || existing.owner !== ownerId) {
+            return false;
+        }
+        // Notify waiters
+        const waiters = existing.waiters;
+        this.locks.delete(key);
+        // Give lock to first waiter
+        if (waiters.length > 0) {
+            const first = waiters.shift();
+            clearTimeout(first.timeout);
+            // Create new lock for the waiter
+            this.locks.set(key, {
+                owner: 'waiter', // Will be updated by the waiter
+                expiresAt: Date.now() + 30000, // Default 30s TTL
+                waiters,
+            });
+            first.resolve(true);
+        }
+        logger.debug({ key, ownerId }, 'In-memory lock released (fallback mode)');
+        return true;
+    }
+    isLocked(key) {
+        const existing = this.locks.get(key);
+        return existing !== undefined && existing.expiresAt > Date.now();
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, lock] of this.locks.entries()) {
+            if (lock.expiresAt <= now) {
+                this.locks.delete(key);
+                // Notify waiters that lock expired
+                for (const waiter of lock.waiters) {
+                    clearTimeout(waiter.timeout);
+                    waiter.resolve(false);
+                }
+            }
+        }
+    }
+    stop() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.locks.clear();
+    }
+}
+// Singleton in-memory mutex for fallback locking
+const inMemoryMutex = new InMemoryMutex();
+/**
+ * Get the Redis circuit breaker instance
+ */
+export function getRedisCircuitBreaker() {
+    return getCircuitBreaker(REDIS_SERVICE_NAME, (from, to, _breaker) => {
+        logger.info({ service: REDIS_SERVICE_NAME, fromState: from, toState: to }, `Redis circuit breaker state transition: ${from} -> ${to}`);
+    });
+}
+/**
+ * Check if the Redis circuit is currently open
+ */
+export async function isRedisCircuitOpen() {
+    const breaker = getRedisCircuitBreaker();
+    return await breaker.isOpen();
+}
+/**
+ * Get Redis circuit breaker status for monitoring
+ */
+export async function getRedisCircuitStatus() {
+    const breaker = getRedisCircuitBreaker();
+    return await breaker.getStatus();
+}
+/**
+ * Execute a Redis operation with circuit breaker protection and timeout.
+ *
+ * @param fn - The Redis operation to execute
+ * @param options - Optional configuration
+ * @returns The result of the Redis operation
+ * @throws CircuitBreakerOpenError when circuit is open
+ * @throws TimeoutError when operation exceeds timeout
+ *
+ * @example
+ * ```typescript
+ * const value = await withRedisCircuitBreaker(
+ *   async () => redis.get('mykey'),
+ *   { operationName: 'getKey' }
+ * );
+ * ```
+ */
+export function withRedisCircuitBreaker(fn, options = {}) {
+    const operationName = options.operationName ?? 'unknown';
+    const timeoutMs = options.timeoutMs ?? REDIS_OPERATION_TIMEOUT_MS;
+    return withCircuitBreaker(REDIS_SERVICE_NAME, () => {
+        return withTimeout(fn(), timeoutMs, `Redis operation '${operationName}' timed out after ${timeoutMs}ms`);
+    });
+}
+/**
+ * Execute a Redis operation with circuit breaker protection,
+ * returning a result object instead of throwing on circuit open.
+ *
+ * @param fn - The Redis operation to execute
+ * @param options - Optional configuration
+ * @returns Result object with success flag and result/error
+ */
+export async function withRedisCircuitBreakerResult(fn, options = {}) {
+    const operationName = options.operationName ?? 'unknown';
+    const timeoutMs = options.timeoutMs ?? REDIS_OPERATION_TIMEOUT_MS;
+    return withCircuitBreakerResult(REDIS_SERVICE_NAME, async () => {
+        return withTimeout(fn(), timeoutMs, `Redis operation '${operationName}' timed out after ${timeoutMs}ms`);
+    });
+}
+// =============================================================================
+// Graceful Fallback Functions
+// =============================================================================
+/**
+ * Rate limiting with graceful Redis fallback.
+ *
+ * When Redis is down:
+ * - Logs a warning
+ * - Allows the request to proceed (fail-open for availability)
+ * - Returns a result indicating fallback mode
+ *
+ * @param key - Rate limit key (e.g., 'ratelimit:tenant:123:minute')
+ * @param limit - Maximum requests allowed in the window
+ * @param windowSeconds - Window duration in seconds
+ * @returns Rate limit result with remaining requests and fallback status
+ *
+ * @example
+ * ```typescript
+ * const result = await rateLimitWithFallback(
+ *   `ratelimit:${tenantId}:minute`,
+ *   100,
+ *   60
+ * );
+ *
+ * if (!result.allowed) {
+ *   return reply.status(429).send({ error: 'Rate limit exceeded' });
+ * }
+ *
+ * if (result.fallbackMode) {
+ *   // Log that we're operating without rate limit protection
+ *   logger.warn({ tenantId }, 'Rate limiting in fallback mode');
+ * }
+ * ```
+ */
+export async function rateLimitWithFallback(key, limit, windowSeconds) {
+    const redis = getRedis();
+    const now = Date.now();
+    const windowMs = windowSeconds * 1000;
+    const resetAt = Math.ceil((now + windowMs) / 1000);
+    const result = await withRedisCircuitBreakerResult(async () => {
+        // Use Redis INCR with EXPIRE for rate limiting
+        const currentCount = await redis.incr(key);
+        // Set expiry on first request in window
+        if (currentCount === 1) {
+            await redis.expire(key, windowSeconds);
+        }
+        return currentCount;
+    }, { operationName: 'rateLimit' });
+    if (result.circuitOpen || !result.success) {
+        // Redis unavailable - allow request but log warning
+        logger.warn({ key, limit, windowSeconds, reason: result.circuitOpen ? 'circuit_open' : 'redis_error' }, 'Rate limiting unavailable - allowing request in fallback mode');
+        return {
+            allowed: true,
+            remaining: limit, // Assume full limit available
+            resetAt,
+            fallbackMode: true,
+        };
+    }
+    const currentCount = result.result;
+    const allowed = currentCount <= limit;
+    const remaining = Math.max(0, limit - currentCount);
+    return {
+        allowed,
+        remaining,
+        resetAt,
+        fallbackMode: false,
+    };
+}
+/**
+ * Distributed lock with graceful Redis fallback.
+ *
+ * When Redis is down:
+ * - Falls back to in-memory mutex (single instance only!)
+ * - Logs a warning about single-instance limitation
+ * - Still provides mutual exclusion within the current process
+ *
+ * @param key - Lock key
+ * @param ownerId - Unique identifier for the lock owner
+ * @param ttlMs - Lock time-to-live in milliseconds
+ * @param options - Optional configuration
+ * @returns Lock result with fallback status
+ *
+ * @example
+ * ```typescript
+ * const lock = await acquireLockWithFallback(
+ *   `lock:order:${orderId}`,
+ *   `worker:${workerId}`,
+ *   30000 // 30 seconds
+ * );
+ *
+ * if (!lock.acquired) {
+ *   return { error: 'Could not acquire lock' };
+ * }
+ *
+ * try {
+ *   if (lock.fallbackMode) {
+ *     logger.warn({ orderId }, 'Using in-memory lock - not distributed!');
+ *   }
+ *   // Process order...
+ * } finally {
+ *   await releaseLockWithFallback(lock.key, lock.ownerId);
+ * }
+ * ```
+ */
+export async function acquireLockWithFallback(key, ownerId, ttlMs, options = {}) {
+    const redis = getRedis();
+    const ttlSeconds = Math.ceil(ttlMs / 1000);
+    const result = await withRedisCircuitBreakerResult(async () => {
+        // Try to acquire lock with NX (only if not exists) and EX (expiry)
+        const acquired = await redis.set(key, ownerId, 'EX', ttlSeconds, 'NX');
+        return acquired === 'OK';
+    }, { operationName: 'acquireLock' });
+    if (result.circuitOpen || !result.success) {
+        // Redis unavailable - fall back to in-memory mutex
+        logger.warn({ key, ownerId, ttlMs, reason: result.circuitOpen ? 'circuit_open' : 'redis_error' }, 'Distributed lock unavailable - using in-memory mutex (single instance only!)');
+        const acquired = await inMemoryMutex.acquire(key, ownerId, ttlMs, options.waitTimeoutMs ?? 0);
+        return {
+            acquired,
+            key,
+            ownerId,
+            fallbackMode: true,
+            release: () => Promise.resolve(inMemoryMutex.release(key, ownerId)),
+        };
+    }
+    const acquired = result.result;
+    return {
+        acquired,
+        key,
+        ownerId,
+        fallbackMode: false,
+        release: async () => {
+            const releaseResult = await withRedisCircuitBreakerResult(async () => {
+                // Use Lua script for atomic check-and-delete
+                const script = `
+            if redis.call("get", KEYS[1]) == ARGV[1] then
+              return redis.call("del", KEYS[1])
+            else
+              return 0
+            end
+          `;
+                const released = await redis.eval(script, 1, key, ownerId);
+                return released === 1;
+            }, { operationName: 'releaseLock' });
+            if (releaseResult.circuitOpen || !releaseResult.success) {
+                logger.warn({ key, ownerId }, 'Could not release Redis lock - circuit open or error');
+                return false;
+            }
+            return releaseResult.result;
+        },
+    };
+}
+/**
+ * Release a distributed lock with fallback support.
+ *
+ * @param key - Lock key
+ * @param ownerId - Lock owner identifier
+ * @returns Whether the lock was successfully released
+ */
+export async function releaseLockWithFallback(key, ownerId) {
+    const redis = getRedis();
+    const result = await withRedisCircuitBreakerResult(async () => {
+        const script = `
+        if redis.call("get", KEYS[1]) == ARGV[1] then
+          return redis.call("del", KEYS[1])
+        else
+          return 0
+        end
+      `;
+        const released = await redis.eval(script, 1, key, ownerId);
+        return released === 1;
+    }, { operationName: 'releaseLock' });
+    if (result.circuitOpen || !result.success) {
+        // Try in-memory mutex as fallback
+        return inMemoryMutex.release(key, ownerId);
+    }
+    return result.result;
+}
+/**
+ * Cache get with graceful Redis fallback.
+ *
+ * When Redis is down:
+ * - Returns null/undefined (cache miss)
+ * - Caller should then query the database directly
+ * - Logs a warning about cache bypass
+ *
+ * @param key - Cache key
+ * @param options - Optional configuration
+ * @returns Cached value or null if not found or Redis unavailable
+ *
+ * @example
+ * ```typescript
+ * const cached = await cacheGetWithFallback<UserData>(`user:${userId}`);
+ *
+ * if (cached.value) {
+ *   return cached.value;
+ * }
+ *
+ * if (cached.fallbackMode) {
+ *   logger.debug({ userId }, 'Cache bypassed - querying database');
+ * }
+ *
+ * // Query database and optionally cache the result
+ * const user = await db.select().from(users).where(eq(users.id, userId));
+ * await cacheSetWithFallback(`user:${userId}`, user, 300);
+ * return user;
+ * ```
+ */
+export async function cacheGetWithFallback(key, options = {}) {
+    const redis = getRedis();
+    const parse = options.parse ?? true;
+    const result = await withRedisCircuitBreakerResult(async () => redis.get(key), { operationName: 'cacheGet' });
+    if (result.circuitOpen || !result.success) {
+        logger.debug({ key, reason: result.circuitOpen ? 'circuit_open' : 'redis_error' }, 'Cache unavailable - treating as cache miss');
+        return {
+            value: null,
+            fallbackMode: true,
+        };
+    }
+    const rawValue = result.result;
+    if (rawValue === null || rawValue === undefined) {
+        return {
+            value: null,
+            fallbackMode: false,
+        };
+    }
+    try {
+        const value = parse ? JSON.parse(rawValue) : rawValue;
+        return {
+            value,
+            fallbackMode: false,
+        };
+    }
+    catch (error) {
+        logger.warn({ key, error }, 'Failed to parse cached value');
+        return {
+            value: null,
+            fallbackMode: false,
+        };
+    }
+}
+/**
+ * Cache set with graceful Redis fallback.
+ *
+ * When Redis is down:
+ * - Logs a warning about cache write failure
+ * - Returns false to indicate the value was not cached
+ * - Does not throw an error
+ *
+ * @param key - Cache key
+ * @param value - Value to cache
+ * @param ttlSeconds - Time-to-live in seconds
+ * @returns Whether the value was successfully cached
+ */
+export async function cacheSetWithFallback(key, value, ttlSeconds) {
+    const redis = getRedis();
+    const serialized = JSON.stringify(value);
+    const result = await withRedisCircuitBreakerResult(async () => {
+        await redis.setex(key, ttlSeconds, serialized);
+        return true;
+    }, { operationName: 'cacheSet' });
+    if (result.circuitOpen || !result.success) {
+        logger.debug({ key, ttlSeconds, reason: result.circuitOpen ? 'circuit_open' : 'redis_error' }, 'Cache unavailable - value not cached');
+        return {
+            success: false,
+            fallbackMode: true,
+        };
+    }
+    return {
+        success: true,
+        fallbackMode: false,
+    };
+}
+/**
+ * Cache delete with graceful Redis fallback.
+ *
+ * @param key - Cache key to delete
+ * @returns Whether the key was successfully deleted
+ */
+export async function cacheDeleteWithFallback(key) {
+    const redis = getRedis();
+    const result = await withRedisCircuitBreakerResult(async () => {
+        const deleted = await redis.del(key);
+        return deleted > 0;
+    }, { operationName: 'cacheDelete' });
+    if (result.circuitOpen || !result.success) {
+        logger.debug({ key, reason: result.circuitOpen ? 'circuit_open' : 'redis_error' }, 'Cache unavailable - delete skipped');
+        return {
+            success: false,
+            fallbackMode: true,
+        };
+    }
+    return {
+        success: result.result,
+        fallbackMode: false,
+    };
+}
+// =============================================================================
+// Circuit Breaker Management
+// =============================================================================
+/**
+ * Force the Redis circuit breaker to open state.
+ */
+export async function forceRedisCircuitOpen() {
+    const breaker = getRedisCircuitBreaker();
+    await breaker.forceOpen();
+    logger.warn({}, 'Redis circuit breaker manually opened');
+}
+/**
+ * Force the Redis circuit breaker to closed state.
+ */
+export async function forceRedisCircuitClose() {
+    const breaker = getRedisCircuitBreaker();
+    await breaker.forceClose();
+    logger.info({}, 'Redis circuit breaker manually closed');
+}
+/**
+ * Reset the Redis circuit breaker.
+ */
+export async function resetRedisCircuit() {
+    const breaker = getRedisCircuitBreaker();
+    await breaker.reset();
+    logger.info({}, 'Redis circuit breaker reset');
+}
+/**
+ * Redis health check with circuit breaker status.
+ */
+export async function checkRedisHealthWithCircuit() {
+    const breaker = getRedisCircuitBreaker();
+    const status = await breaker.getStatus();
+    // If circuit is open, don't even try to check Redis
+    if (status.state === 'OPEN') {
+        return {
+            healthy: false,
+            error: 'Circuit breaker is OPEN - Redis marked as unavailable',
+            circuit: {
+                state: status.state,
+                failureCount: status.failureCount,
+                failureThreshold: status.failureThreshold,
+                timeUntilReset: status.timeUntilReset,
+            },
+        };
+    }
+    const redis = getRedis();
+    const start = performance.now();
+    try {
+        const result = await withRedisCircuitBreakerResult(async () => redis.ping(), { operationName: 'healthCheck', timeoutMs: 5000 });
+        const latencyMs = Math.round(performance.now() - start);
+        const updatedStatus = await breaker.getStatus();
+        if (result.circuitOpen) {
+            return {
+                healthy: false,
+                latencyMs,
+                error: 'Circuit breaker is OPEN',
+                circuit: {
+                    state: updatedStatus.state,
+                    failureCount: updatedStatus.failureCount,
+                    failureThreshold: updatedStatus.failureThreshold,
+                    timeUntilReset: updatedStatus.timeUntilReset,
+                },
+            };
+        }
+        const isHealthy = result.success && result.result === 'PONG';
+        return {
+            healthy: isHealthy,
+            latencyMs,
+            error: result.success ? undefined : result.error?.message,
+            circuit: {
+                state: updatedStatus.state,
+                failureCount: updatedStatus.failureCount,
+                failureThreshold: updatedStatus.failureThreshold,
+                timeUntilReset: updatedStatus.timeUntilReset,
+            },
+        };
+    }
+    catch (error) {
+        const latencyMs = Math.round(performance.now() - start);
+        const updatedStatus = await breaker.getStatus();
+        return {
+            healthy: false,
+            latencyMs,
+            error: error instanceof Error ? error.message : 'Unknown error',
+            circuit: {
+                state: updatedStatus.state,
+                failureCount: updatedStatus.failureCount,
+                failureThreshold: updatedStatus.failureThreshold,
+                timeUntilReset: updatedStatus.timeUntilReset,
+            },
+        };
+    }
+}
+/**
+ * Stop the in-memory mutex fallback.
+ * Call this during graceful shutdown.
+ */
+export function stopInMemoryMutex() {
+    inMemoryMutex.stop();
+}
+//# sourceMappingURL=redis-resilience.js.map

package/dist/common/redis-resilience.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis-resilience.js","sourceRoot":"","sources":["../../src/common/redis-resilience.ts"],"names":[],"mappings":"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"}

package/dist/common/redis.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Redis connection management
+ */
+import { Redis } from 'ioredis';
+export declare function getRedis(): Redis;
+export declare function closeRedis(): Promise<void>;
+/**
+ * Check Redis health by running a PING command.
+ * Returns true if Redis is healthy, false otherwise.
+ *
+ * @param timeoutMs - Optional timeout in milliseconds (defaults to config value)
+ */
+export declare function checkRedisHealth(timeoutMs?: number): Promise<{
+    healthy: boolean;
+    latencyMs?: number;
+    error?: string;
+    timedOut?: boolean;
+}>;
+//# sourceMappingURL=redis.d.ts.map

package/dist/common/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../src/common/redis.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,EAAqB,MAAM,SAAS,CAAC;AASnD,wBAAgB,QAAQ,IAAI,KAAK,CA2BhC;AAED,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAKhD;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAClE,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC,CAkCD"}