openWa / src /common /cache /cache.service.ts
harsh
Deploy: Initial commit without binaries
525d39f
Raw History Blame Contribute Delete
8.48 kB
import { Injectable, OnModuleDestroy } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import Redis from 'ioredis';
import { createLogger } from '../services/logger.service';
export interface SessionInfo {
id: string;
name: string;
status: string;
phone?: string;
pushName?: string;
connectedAt?: string;
}
export interface SessionStats {
active: number;
total: number;
byStatus: Record<string, number>;
}
// TTL constants in seconds
const TTL = {
SESSION_STATUS: 300, // 5 min
SESSION_INFO: 600, // 10 min
SESSION_QR: 60, // 1 min
SESSIONS_LIST: 30, // 30 sec
SESSIONS_STATS: 15, // 15 sec
};
@Injectable()
export class CacheService implements OnModuleDestroy {
private readonly logger = createLogger('CacheService');
private redis: Redis | null = null;
private readonly enabled: boolean;
private connecting = false;
private connectionAttempts = 0;
private readonly maxConnectionAttempts = 5;
constructor(private readonly configService: ConfigService) {
// Check REDIS_ENABLED env var directly (from saved .env.generated)
// Fallback to config 'cache.enabled' for backward compatibility
this.enabled = process.env.REDIS_ENABLED === 'true' || configService.get<boolean>('cache.enabled', false);
this.logger.log(`CacheService: enabled=${this.enabled}, REDIS_ENABLED=${process.env.REDIS_ENABLED}`);
// Don't connect immediately - wait for Redis container to be ready
// Connection will be established on first use via isAvailable()
}
/**
* Try to (re)connect to Redis
* Returns true if connection succeeded
*/
async tryConnect(): Promise<boolean> {
if (!this.enabled) return false;
if (this.connecting) return false;
if (this.redis && (await this.ping())) return true;
this.connecting = true;
this.connectionAttempts++;
try {
const host = process.env.REDIS_HOST || this.configService.get<string>('REDIS_HOST', 'localhost');
const port = parseInt(process.env.REDIS_PORT || '', 10) || this.configService.get<number>('REDIS_PORT', 6379);
this.logger.log(`Connecting to Redis at ${host}:${port} (attempt ${this.connectionAttempts})`);
this.redis = new Redis({
host,
port,
password: this.configService.get<string>('REDIS_PASSWORD'),
db: this.configService.get<number>('REDIS_CACHE_DB', 1),
lazyConnect: true,
maxRetriesPerRequest: 3,
connectTimeout: 5000,
retryStrategy: times => {
if (times > 3) return null;
return Math.min(times * 500, 3000);
},
});
this.redis.on('error', err => {
this.logger.warn(`Redis error: ${err.message}`);
});
this.redis.on('connect', () => {
this.logger.log('Redis cache connected');
this.connectionAttempts = 0; // Reset on success
});
await this.redis.connect();
this.connecting = false;
return true;
} catch (error) {
this.logger.warn(`Redis connection failed (attempt ${this.connectionAttempts}): ${String(error)}`);
this.redis = null;
this.connecting = false;
return false;
}
}
private async ping(): Promise<boolean> {
if (!this.redis) return false;
try {
await this.redis.ping();
return true;
} catch (error) {
this.logger.debug(`Redis ping failed: ${String(error)}`);
return false;
}
}
async onModuleDestroy(): Promise<void> {
if (this.redis) {
await this.redis.quit();
}
}
async isAvailable(): Promise<boolean> {
if (!this.enabled) return false;
// If not connected, try to connect (with rate limiting)
if (!this.redis && this.connectionAttempts < this.maxConnectionAttempts) {
await this.tryConnect();
}
return this.ping();
}
// ========== Session Status ==========
async getSessionStatus(id: string): Promise<string | null> {
if (!(await this.isAvailable())) return null;
try {
return await this.redis!.get(`session:${id}:status`);
} catch (error) {
this.logger.warn(`Cache read failed (session:status): ${String(error)}`);
return null;
}
}
async setSessionStatus(id: string, status: string): Promise<void> {
if (!(await this.isAvailable())) return;
try {
await this.redis!.setex(`session:${id}:status`, TTL.SESSION_STATUS, status);
} catch (error) {
this.logger.warn(`Cache write failed (session:status): ${String(error)}`);
}
}
// ========== Session Info ==========
async getSessionInfo(id: string): Promise<SessionInfo | null> {
if (!(await this.isAvailable())) return null;
try {
const data = await this.redis!.get(`session:${id}:info`);
return data ? (JSON.parse(data) as SessionInfo) : null;
} catch (error) {
this.logger.warn(`Cache read failed (session:info): ${String(error)}`);
return null;
}
}
async setSessionInfo(id: string, info: SessionInfo): Promise<void> {
if (!(await this.isAvailable())) return;
try {
await this.redis!.setex(`session:${id}:info`, TTL.SESSION_INFO, JSON.stringify(info));
} catch (error) {
this.logger.warn(`Cache write failed (session:info): ${String(error)}`);
}
}
// ========== Session QR ==========
async getSessionQR(id: string): Promise<string | null> {
if (!(await this.isAvailable())) return null;
try {
return await this.redis!.get(`session:${id}:qr`);
} catch (error) {
this.logger.warn(`Cache read failed (session:qr): ${String(error)}`);
return null;
}
}
async setSessionQR(id: string, qr: string): Promise<void> {
if (!(await this.isAvailable())) return;
try {
await this.redis!.setex(`session:${id}:qr`, TTL.SESSION_QR, qr);
} catch (error) {
this.logger.warn(`Cache write failed (session:qr): ${String(error)}`);
}
}
// ========== Sessions List ==========
async getSessionsList(): Promise<string[] | null> {
if (!(await this.isAvailable())) return null;
try {
const data = await this.redis!.get('sessions:list');
return data ? (JSON.parse(data) as string[]) : null;
} catch (error) {
this.logger.warn(`Cache read failed (sessions:list): ${String(error)}`);
return null;
}
}
async setSessionsList(ids: string[]): Promise<void> {
if (!(await this.isAvailable())) return;
try {
await this.redis!.setex('sessions:list', TTL.SESSIONS_LIST, JSON.stringify(ids));
} catch (error) {
this.logger.warn(`Cache write failed (sessions:list): ${String(error)}`);
}
}
// ========== Sessions Stats ==========
async getSessionsStats(): Promise<SessionStats | null> {
if (!(await this.isAvailable())) return null;
try {
const data = await this.redis!.get('sessions:stats');
return data ? (JSON.parse(data) as SessionStats) : null;
} catch (error) {
this.logger.warn(`Cache read failed (sessions:stats): ${String(error)}`);
return null;
}
}
async setSessionsStats(stats: SessionStats): Promise<void> {
if (!(await this.isAvailable())) return;
try {
await this.redis!.setex('sessions:stats', TTL.SESSIONS_STATS, JSON.stringify(stats));
} catch (error) {
this.logger.warn(`Cache write failed (sessions:stats): ${String(error)}`);
}
}
// ========== Invalidation ==========
async invalidateSession(id: string): Promise<void> {
if (!(await this.isAvailable())) return;
try {
await this.redis!.del(`session:${id}:status`, `session:${id}:info`, `session:${id}:qr`);
// Also invalidate list since a session changed
await this.redis!.del('sessions:list', 'sessions:stats');
} catch (error) {
this.logger.warn(`Cache invalidation failed: ${String(error)}`);
}
}
async invalidateSessionsList(): Promise<void> {
if (!(await this.isAvailable())) return;
try {
await this.redis!.del('sessions:list', 'sessions:stats');
} catch (error) {
this.logger.warn(`Cache invalidation failed: ${String(error)}`);
}
}
async invalidateAll(): Promise<void> {
if (!(await this.isAvailable())) return;
try {
const keys = await this.redis!.keys('session:*');
keys.push('sessions:list', 'sessions:stats');
if (keys.length > 0) {
await this.redis!.del(...keys);
}
} catch (error) {
this.logger.warn(`Cache invalidation failed: ${String(error)}`);
}
}
}