Steigern Sie die Leistung Ihrer Node.js-App mit einem vielseitigen, benutzerfreundlichen Cache-Manager, der auf ioredis basiert. Vereinfachen Sie das Caching, optimieren Sie die Effizienz und rationalisieren Sie Abläufe.

Ich habe für meine eigenen Bedürfnisse eine Klasse entwickelt, die auf ioredis aufbaut und sich auf Benutzerfreundlichkeit und Leistung konzentriert. Es beinhaltet TypeScript-Unterstützung und zielt auf eine einfache Nutzung und einen effizienten Betrieb ab. Es kann noch weiter verbessert und optimiert werden, mit Möglichkeiten zur dynamischen Datenbanknutzung und detaillierterer Fehlerbehandlung. Ich würde es gerne mit Ihnen teilen und würde mich über Feedback oder Verbesserungsvorschläge freuen.

import Redis, { type RedisOptions } from 'ioredis';

interface CacheConfig {
    defaultTTL?: number;
}

export class cacheManager {
    private static instance: cacheManager;
    private static redisClient: Redis;
    private currentKey: string | null;
    private defaultTTL: number;

    private static readonly DEFAULT_TTL = 3600;

    private constructor(config?: CacheConfig) {
        const redisConfig: RedisOptions = {
            db: 2,
            retryStrategy: (times: number) => {
                const delay = Math.min(times * 50, 2000);
                return delay;
            },
            lazyConnect: true,
            maxRetriesPerRequest: 3,
            enableReadyCheck: true,
            autoResubscribe: true,
            autoResendUnfulfilledCommands: true,
            reconnectOnError: (err: Error) => {
                const targetError = 'READONLY';
                return err.message.includes(targetError);
            },
        };

        if (!cacheManager.redisClient) {
            cacheManager.redisClient = new Redis(redisConfig);

            cacheManager.redisClient.on('error', (error: Error) => {
                console.error('Redis Client Error:', error);
            });

            cacheManager.redisClient.on('connect', () => {
                console.debug('Redis Client Connected');
            });

            cacheManager.redisClient.on('ready', () => {
                console.debug('Redis Client Ready');
            });
        }

        this.currentKey = null;
        this.defaultTTL = config?.defaultTTL ?? cacheManager.DEFAULT_TTL;
    }

    public static getInstance(config?: CacheConfig): cacheManager {
        if (!cacheManager.instance) {
            cacheManager.instance = new cacheManager(config);
        }
        return cacheManager.instance;
    }

    public key(key: string): cacheManager {
        this.validateKey(key);
        this.currentKey = key;
        return this;
    }

    private validateKey(key: string): void {
        if (key.length > 100) throw new Error('Key too long');
        if (!/^[\w:-] $/.test(key)) throw new Error('Invalid key format');
    }

    public async getValue(): Promise {
        try {
            if (!this.currentKey) {
                throw new Error('Key is required');
            }
            const value = await cacheManager.redisClient.get(this.currentKey);
            return value ? JSON.parse(value) : null;
        } catch (error) {
            console.error('getValue Error:', error);
            return null;
        }
    }

    public async getMultiple(keys: string[]): Promise> {
        try {
            const pipeline = cacheManager.redisClient.pipeline();
            for (const key of keys) {
                pipeline.get(key);
            }

            type PipelineResult = [Error | null, string | null][] | null;
            const results = (await pipeline.exec()) as PipelineResult;
            const output: Record = {};

            if (!results) {
                return output;
            }

            keys.forEach((key, index) => {
                const result = results[index];
                if (result) {
                    const [err, value] = result;
                    if (!err && value) {
                        try {
                            output[key] = JSON.parse(value);
                        } catch {
                            output[key] = null;
                        }
                    } else {
                        output[key] = null;
                    }
                } else {
                    output[key] = null;
                }
            });

            return output;
        } catch (error) {
            console.error('getMultiple Error:', error);
            return {};
        }
    }

    public async setValue(value: T, ttl: number = this.defaultTTL): Promise {
        try {
            if (!this.currentKey) {
                throw new Error('Key is required');
            }
            const stringValue = JSON.stringify(value);

            if (ttl) {
                await cacheManager.redisClient.setex(this.currentKey, ttl, stringValue);
            } else {
                await cacheManager.redisClient.set(this.currentKey, stringValue);
            }

            return true;
        } catch (error) {
            console.error('setValue Error:', error);
            return false;
        }
    }

    public async setBulkValue(keyValuePairs: Record, ttl: number = this.defaultTTL, batchSize = 1000): Promise {
        try {
            const entries = Object.entries(keyValuePairs);
            for (let i = 0; i (fallbackFn: () => Promise, ttl: number = this.defaultTTL): Promise {
        try {
            if (!this.currentKey) {
                throw new Error('Key is required');
            }

            const cachedValue = await this.getValue();

            if (cachedValue !== null) {
                return cachedValue;
            }

            const value = await fallbackFn();
            await this.setValue(value, ttl);
            return value;
        } catch (error) {
            console.error('getOrSetValue Error:', error);
            return null;
        }
    }

    public async delete(): Promise {
        try {
            if (!this.currentKey) {
                throw new Error('Key is required');
            }
            await cacheManager.redisClient.del(this.currentKey);
            return true;
        } catch (error) {
            console.error('delete Error:', error);
            return false;
        }
    }

    public async exists(): Promise {
        try {
            if (!this.currentKey) {
                throw new Error('Key is required');
            }
            return (await cacheManager.redisClient.exists(this.currentKey)) === 1;
        } catch (error) {
            console.error('exists Error:', error);
            return false;
        }
    }

    public async getTTL(): Promise {
        try {
            if (!this.currentKey) {
                throw new Error('Key is required');
            }
            return await cacheManager.redisClient.ttl(this.currentKey);
        } catch (error) {
            console.error('getTTL Error:', error);
            return -1;
        }
    }

    public static async disconnect(): Promise {
        if (cacheManager.redisClient) {
            await cacheManager.redisClient.quit();
        }
    }
}