@naman_deep_singh/cache 1.1.0

package/dist/esm/adapters/memcache/MemcacheCache.d.ts

@@ -0,0 +1,71 @@
+import type { MemcacheCacheConfig, HealthCheckResponse } from '../../types';
+import { BaseCache } from '../../core/BaseCache';
+/**
+ * Memcache adapter
+ */
+export declare class MemcacheCache<T = unknown> extends BaseCache<T> {
+    private memcacheConfig;
+    private client;
+    private isConnected;
+    constructor(memcacheConfig: MemcacheCacheConfig);
+    /**
+     * Connect to Memcache
+     */
+    connect(): Promise<void>;
+    /**
+     * Ensure client is connected
+     */
+    private ensureConnected;
+    /**
+     * Ping memcache
+     */
+    private ping;
+    /**
+     * Get a value from Memcache
+     */
+    get(key: string): Promise<T | null>;
+    /**
+     * Set a value in Memcache
+     */
+    set(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Delete a key from Memcache
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Check if key exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Clear all keys (Memcache limitation: flushes entire cache)
+     */
+    clear(): Promise<void>;
+    /**
+     * Get multiple values at once
+     */
+    getMultiple(keys: string[]): Promise<Record<string, T | null>>;
+    /**
+     * Set multiple values at once
+     */
+    setMultiple(data: Record<string, T>, ttl?: number): Promise<void>;
+    /**
+     * Delete multiple keys at once
+     */
+    deleteMultiple(keys: string[]): Promise<number>;
+    /**
+     * Increment a numeric value (not natively supported by Memcache in this library)
+     */
+    increment(key: string, amount?: number): Promise<number>;
+    /**
+     * Decrement a numeric value
+     */
+    decrement(key: string, amount?: number): Promise<number>;
+    /**
+     * Check if Memcache is alive
+     */
+    isAlive(): Promise<HealthCheckResponse>;
+    /**
+     * Close Memcache connection
+     */
+    close(): Promise<void>;
+}

package/dist/esm/adapters/memcache/MemcacheCache.js

@@ -0,0 +1,340 @@
+import Memcached from 'memcached';
+import { BaseCache } from '../../core/BaseCache';
+import { CacheError } from '../../errors';
+/**
+ * Memcache adapter
+ */
+export class MemcacheCache extends BaseCache {
+    constructor(memcacheConfig) {
+        super(memcacheConfig);
+        this.memcacheConfig = memcacheConfig;
+        this.client = null;
+        this.isConnected = false;
+    }
+    /**
+     * Connect to Memcache
+     */
+    async connect() {
+        try {
+            const servers = Array.isArray(this.memcacheConfig.servers)
+                ? this.memcacheConfig.servers
+                : [this.memcacheConfig.servers];
+            const options = {
+                retries: 2,
+                retry: 30000,
+                remove: true,
+                failOverServers: [],
+                maxValue: 1048576, // 1MB default
+                idle: 30000
+            };
+            if (this.memcacheConfig.username) {
+                options.username = this.memcacheConfig.username;
+            }
+            if (this.memcacheConfig.password) {
+                options.password = this.memcacheConfig.password;
+            }
+            this.client = new Memcached(servers, options);
+            this.isConnected = true;
+            // Test connection
+            await this.ping();
+        }
+        catch (err) {
+            throw new CacheError('Failed to connect to Memcache', 'MEMCACHE_CONNECTION_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Ensure client is connected
+     */
+    async ensureConnected() {
+        if (!this.client) {
+            await this.connect();
+        }
+    }
+    /**
+     * Ping memcache
+     */
+    async ping() {
+        return new Promise((resolve, reject) => {
+            if (!this.client) {
+                reject(new Error('Memcache client not initialized'));
+                return;
+            }
+            this.client.touch('__ping', 1, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+    /**
+     * Get a value from Memcache
+     */
+    async get(key) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            return new Promise((resolve, reject) => {
+                this.client.get(fullKey, (err, data) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    if (data === undefined) {
+                        this.recordMiss();
+                        resolve(null);
+                    }
+                    else {
+                        this.recordHit();
+                        try {
+                            resolve(this.deserialize(data));
+                        }
+                        catch (parseErr) {
+                            reject(parseErr);
+                        }
+                    }
+                });
+            });
+        }
+        catch (err) {
+            throw new CacheError(`Failed to get key "${key}" from Memcache`, 'MEMCACHE_GET_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Set a value in Memcache
+     */
+    async set(key, value, ttl) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            const serialized = this.serialize(value);
+            const expiry = ttl ?? this.ttl;
+            return new Promise((resolve, reject) => {
+                this.client.set(fullKey, serialized, expiry, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        this.recordSet();
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (err) {
+            throw new CacheError(`Failed to set key "${key}" in Memcache`, 'MEMCACHE_SET_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Delete a key from Memcache
+     */
+    async delete(key) {
+        try {
+            await this.ensureConnected();
+            const fullKey = this.buildKey(key);
+            return new Promise((resolve, reject) => {
+                this.client.del(fullKey, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        this.recordDelete();
+                        resolve(true);
+                    }
+                });
+            });
+        }
+        catch (err) {
+            throw new CacheError(`Failed to delete key "${key}" from Memcache`, 'MEMCACHE_DELETE_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Check if key exists
+     */
+    async exists(key) {
+        try {
+            const value = await this.get(key);
+            return value !== null;
+        }
+        catch (err) {
+            throw new CacheError(`Failed to check existence of key "${key}" in Memcache`, 'MEMCACHE_EXISTS_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Clear all keys (Memcache limitation: flushes entire cache)
+     */
+    async clear() {
+        try {
+            await this.ensureConnected();
+            return new Promise((resolve, reject) => {
+                this.client.flush((err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        }
+        catch (err) {
+            throw new CacheError('Failed to clear Memcache', 'MEMCACHE_CLEAR_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Get multiple values at once
+     */
+    async getMultiple(keys) {
+        try {
+            await this.ensureConnected();
+            const fullKeys = keys.map(k => this.buildKey(k));
+            return new Promise((resolve, reject) => {
+                this.client.getMulti(fullKeys, (err, data) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    const result = {};
+                    keys.forEach((key) => {
+                        const fullKey = this.buildKey(key);
+                        if (fullKey in data) {
+                            this.recordHit();
+                            try {
+                                result[key] = this.deserialize(data[fullKey]);
+                            }
+                            catch (parseErr) {
+                                reject(parseErr);
+                            }
+                        }
+                        else {
+                            this.recordMiss();
+                            result[key] = null;
+                        }
+                    });
+                    resolve(result);
+                });
+            });
+        }
+        catch (err) {
+            throw new CacheError('Failed to get multiple keys from Memcache', 'MEMCACHE_GET_MULTIPLE_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Set multiple values at once
+     */
+    async setMultiple(data, ttl) {
+        try {
+            await this.ensureConnected();
+            const expiry = ttl ?? this.ttl;
+            const promises = [];
+            for (const [key, value] of Object.entries(data)) {
+                const fullKey = this.buildKey(key);
+                const serialized = this.serialize(value);
+                promises.push(new Promise((resolve, reject) => {
+                    this.client.set(fullKey, serialized, expiry, (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                }));
+            }
+            return Promise.all(promises).then(() => {
+                this.stats.sets += Object.keys(data).length;
+            });
+        }
+        catch (err) {
+            throw new CacheError('Failed to set multiple keys in Memcache', 'MEMCACHE_SET_MULTIPLE_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Delete multiple keys at once
+     */
+    async deleteMultiple(keys) {
+        try {
+            await this.ensureConnected();
+            const fullKeys = keys.map(k => this.buildKey(k));
+            let deletedCount = 0;
+            await Promise.all(fullKeys.map(key => new Promise((resolve, reject) => {
+                this.client.del(key, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        deletedCount++;
+                        resolve();
+                    }
+                });
+            })));
+            this.stats.deletes += deletedCount;
+            return deletedCount;
+        }
+        catch (err) {
+            throw new CacheError('Failed to delete multiple keys from Memcache', 'MEMCACHE_DELETE_MULTIPLE_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Increment a numeric value (not natively supported by Memcache in this library)
+     */
+    async increment(key, amount = 1) {
+        try {
+            const current = await this.get(key);
+            const value = (typeof current === 'number' ? current : 0) + amount;
+            await this.set(key, value);
+            return value;
+        }
+        catch (err) {
+            throw new CacheError(`Failed to increment key "${key}" in Memcache`, 'MEMCACHE_INCREMENT_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Decrement a numeric value
+     */
+    async decrement(key, amount = 1) {
+        try {
+            const current = await this.get(key);
+            const value = (typeof current === 'number' ? current : 0) - amount;
+            await this.set(key, value);
+            return value;
+        }
+        catch (err) {
+            throw new CacheError(`Failed to decrement key "${key}" in Memcache`, 'MEMCACHE_DECREMENT_ERROR', 'memcache', err);
+        }
+    }
+    /**
+     * Check if Memcache is alive
+     */
+    async isAlive() {
+        try {
+            await this.ping();
+            return {
+                isAlive: true,
+                adapter: 'memcache',
+                timestamp: new Date()
+            };
+        }
+        catch (err) {
+            return {
+                isAlive: false,
+                adapter: 'memcache',
+                timestamp: new Date(),
+                error: err.message
+            };
+        }
+    }
+    /**
+     * Close Memcache connection
+     */
+    async close() {
+        try {
+            if (this.client && this.isConnected) {
+                this.client.end();
+                this.isConnected = false;
+                this.client = null;
+            }
+        }
+        catch (err) {
+            throw new CacheError('Failed to close Memcache connection', 'MEMCACHE_CLOSE_ERROR', 'memcache', err);
+        }
+    }
+}

package/dist/esm/adapters/memcache/index.d.ts

@@ -0,0 +1 @@
+export { MemcacheCache } from './MemcacheCache';

package/dist/esm/adapters/memcache/index.js

@@ -0,0 +1 @@
+export { MemcacheCache } from './MemcacheCache';

package/dist/esm/adapters/memory/MemoryCache.d.ts

@@ -0,0 +1,63 @@
+import type { MemoryCacheConfig, HealthCheckResponse } from '../../types';
+import { BaseCache } from '../../core/BaseCache';
+/**
+ * In-memory cache adapter for development and testing
+ */
+export declare class MemoryCache<T = unknown> extends BaseCache<T> {
+    private memoryCacheConfig;
+    private store;
+    private cleanupInterval;
+    constructor(memoryCacheConfig: MemoryCacheConfig);
+    /**
+     * Start periodic cleanup of expired items
+     */
+    private startCleanup;
+    /**
+     * Get a value from memory
+     */
+    get(key: string): Promise<T | null>;
+    /**
+     * Set a value in memory
+     */
+    set(key: string, value: T, ttl?: number): Promise<void>;
+    /**
+     * Delete a key from memory
+     */
+    delete(key: string): Promise<boolean>;
+    /**
+     * Check if key exists
+     */
+    exists(key: string): Promise<boolean>;
+    /**
+     * Clear all keys with current namespace
+     */
+    clear(): Promise<void>;
+    /**
+     * Get multiple values at once
+     */
+    getMultiple(keys: string[]): Promise<Record<string, T | null>>;
+    /**
+     * Set multiple values at once
+     */
+    setMultiple(data: Record<string, T>, ttl?: number): Promise<void>;
+    /**
+     * Delete multiple keys at once
+     */
+    deleteMultiple(keys: string[]): Promise<number>;
+    /**
+     * Increment a numeric value
+     */
+    increment(key: string, amount?: number): Promise<number>;
+    /**
+     * Decrement a numeric value
+     */
+    decrement(key: string, amount?: number): Promise<number>;
+    /**
+     * Check if memory cache is alive
+     */
+    isAlive(): Promise<HealthCheckResponse>;
+    /**
+     * Close memory cache
+     */
+    close(): Promise<void>;
+}