ts-packages 2.0.0 → 3.0.0

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

@@ -1,9 +1,7 @@
 import Memcached from 'memcached';
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes';
 import { BaseCache } from '../../core/BaseCache';
 import { CacheError } from '../../errors';
-/**
- * Memcache adapter
- */
 export class MemcacheCache extends BaseCache {
     constructor(memcacheConfig) {
         super(memcacheConfig);
@@ -11,362 +9,158 @@ export class MemcacheCache extends BaseCache {
         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 = {
+            this.client = new Memcached(servers, {
                 retries: 2,
                 retry: 30000,
                 remove: true,
-                failOverServers: [],
-                maxValue: 1048576, // 1MB default
+                maxValue: 1048576,
                 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);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_CONNECTION_FAILED, {
+                adapter: 'memcache',
+                operation: 'connect',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
-    /**
-     * 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();
-            });
+            if (!this.client)
+                return reject(new Error('Client not initialized'));
+            this.client.touch('__ping', 1, (err) => (err ? reject(err) : resolve()));
         });
     }
-    /**
-     * Get a value from Memcache
-     */
+    async exists(key) {
+        try {
+            const value = await this.get(key);
+            return value !== null;
+        }
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memcache',
+                operation: 'exists',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+    }
     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 || data === null) {
-                        this.recordMiss();
-                        resolve(null);
-                        return;
-                    }
-                    this.recordHit();
+                    if (err)
+                        return reject(err);
+                    if (data == null)
+                        return resolve(null);
                     try {
-                        if (typeof data === 'string') {
-                            resolve(this.deserialize(data));
-                        }
-                        else if (Buffer.isBuffer(data)) {
-                            resolve(this.deserialize(data.toString()));
-                        }
-                        else {
-                            // Unknown shape from memcached client - treat as miss
-                            this.recordMiss();
-                            resolve(null);
-                        }
+                        resolve(this.deserialize(Buffer.isBuffer(data) ? data.toString() : data));
                     }
-                    catch (parseErr) {
-                        reject(parseErr);
+                    catch (e) {
+                        reject(e);
                     }
                 });
             });
         }
-        catch (err) {
-            throw new CacheError(`Failed to get key "${key}" from Memcache`, 'MEMCACHE_GET_ERROR', 'memcache', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_KEY_NOT_FOUND, {
+                adapter: 'memcache',
+                operation: 'get',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
-    /**
-     * 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();
-                    }
-                });
+                this.client.set(fullKey, this.serialize(value), ttl ?? this.ttl, (err) => (err ? reject(err) : resolve()));
             });
         }
-        catch (err) {
-            throw new CacheError(`Failed to set key "${key}" in Memcache`, 'MEMCACHE_SET_ERROR', 'memcache', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memcache',
+                operation: 'set',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
-    /**
-     * 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);
-                    }
-                });
+                this.client.del(fullKey, (err) => (err ? reject(err) : 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 (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memcache',
+                operation: 'delete',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
             });
         }
-        catch (err) {
-            throw new CacheError('Failed to clear Memcache', 'MEMCACHE_CLEAR_ERROR', 'memcache', err);
-        }
     }
-    /**
-     * Get multiple values at once
-     */
-    async getMultiple(keys) {
+    async clear() {
         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 = {};
-                    if (!data || typeof data !== 'object') {
-                        // Treat as all misses
-                        for (const key of keys) {
-                            this.recordMiss();
-                            result[key] = null;
-                        }
-                        resolve(result);
-                        return;
-                    }
-                    const map = data;
-                    keys.forEach((key) => {
-                        const fullKey = this.buildKey(key);
-                        const value = map[fullKey];
-                        if (value === undefined || value === null) {
-                            this.recordMiss();
-                            result[key] = null;
-                        }
-                        else {
-                            this.recordHit();
-                            try {
-                                if (typeof value === 'string') {
-                                    result[key] = this.deserialize(value);
-                                }
-                                else if (Buffer.isBuffer(value)) {
-                                    result[key] = this.deserialize(value.toString());
-                                }
-                                else {
-                                    // Unknown, treat as miss
-                                    this.recordMiss();
-                                    result[key] = null;
-                                }
-                            }
-                            catch (parseErr) {
-                                reject(parseErr);
-                            }
-                        }
-                    });
-                    resolve(result);
-                });
+                this.client.flush((err) => (err ? reject(err) : resolve()));
             });
         }
-        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 (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_OPERATION_TIMEOUT, {
+                adapter: 'memcache',
+                operation: 'clear',
+                cause: error instanceof Error ? error : undefined,
             });
         }
-        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(),
-            };
+            return { isAlive: true, adapter: 'memcache', timestamp: new Date() };
         }
-        catch (err) {
+        catch (error) {
             return {
                 isAlive: false,
                 adapter: 'memcache',
                 timestamp: new Date(),
-                error: err.message,
+                error: error instanceof Error ? error.message : 'Unknown error',
             };
         }
     }
-    /**
-     * Close Memcache connection
-     */
     async close() {
         try {
-            if (this.client && this.isConnected) {
-                this.client.end();
-                this.isConnected = false;
-                this.client = null;
-            }
+            this.client?.end();
+            this.client = null;
+            this.isConnected = false;
         }
-        catch (err) {
-            throw new CacheError('Failed to close Memcache connection', 'MEMCACHE_CLOSE_ERROR', 'memcache', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memcache',
+                operation: 'close',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
 }

package/packages/cache/dist/esm/adapters/memory/MemoryCache.js

@@ -1,3 +1,4 @@
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes';
 import { BaseCache } from '../../core/BaseCache';
 import { CacheError } from '../../errors';
 /**
@@ -46,8 +47,13 @@ export class MemoryCache extends BaseCache {
             this.recordHit();
             return entry.value;
         }
-        catch (err) {
-            throw new CacheError(`Failed to get key "${key}" from memory cache`, 'MEMORY_GET_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_KEY_NOT_FOUND, {
+                adapter: 'memory',
+                operation: 'get',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -70,8 +76,13 @@ export class MemoryCache extends BaseCache {
             this.store.set(fullKey, { value, expiresAt });
             this.recordSet();
         }
-        catch (err) {
-            throw new CacheError(`Failed to set key "${key}" in memory cache`, 'MEMORY_SET_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'set',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -86,8 +97,13 @@ export class MemoryCache extends BaseCache {
             }
             return deleted;
         }
-        catch (err) {
-            throw new CacheError(`Failed to delete key "${key}" from memory cache`, 'MEMORY_DELETE_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'delete',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -107,8 +123,13 @@ export class MemoryCache extends BaseCache {
             }
             return true;
         }
-        catch (err) {
-            throw new CacheError(`Failed to check existence of key "${key}" in memory cache`, 'MEMORY_EXISTS_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'exists',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -129,8 +150,12 @@ export class MemoryCache extends BaseCache {
                 this.store.clear();
             }
         }
-        catch (err) {
-            throw new CacheError('Failed to clear memory cache', 'MEMORY_CLEAR_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_OPERATION_TIMEOUT, {
+                adapter: 'memory',
+                operation: 'clear',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -161,8 +186,13 @@ export class MemoryCache extends BaseCache {
             }
             return result;
         }
-        catch (err) {
-            throw new CacheError('Failed to get multiple keys from memory cache', 'MEMORY_GET_MULTIPLE_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'getMultiple',
+                details: { keys },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -178,8 +208,13 @@ export class MemoryCache extends BaseCache {
             }
             this.stats.sets += Object.keys(data).length;
         }
-        catch (err) {
-            throw new CacheError('Failed to set multiple keys in memory cache', 'MEMORY_SET_MULTIPLE_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'setMultiple',
+                details: { keys: Object.keys(data) },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -197,8 +232,13 @@ export class MemoryCache extends BaseCache {
             this.stats.deletes += count;
             return count;
         }
-        catch (err) {
-            throw new CacheError('Failed to delete multiple keys from memory cache', 'MEMORY_DELETE_MULTIPLE_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'deleteMultiple',
+                details: { keys },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -219,8 +259,13 @@ export class MemoryCache extends BaseCache {
             this.store.set(fullKey, { value: value, expiresAt });
             return value;
         }
-        catch (err) {
-            throw new CacheError(`Failed to increment key "${key}" in memory cache`, 'MEMORY_INCREMENT_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'increment',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -241,8 +286,13 @@ export class MemoryCache extends BaseCache {
             this.store.set(fullKey, { value: value, expiresAt });
             return value;
         }
-        catch (err) {
-            throw new CacheError(`Failed to decrement key "${key}" in memory cache`, 'MEMORY_DECREMENT_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'decrement',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -266,8 +316,12 @@ export class MemoryCache extends BaseCache {
             }
             this.store.clear();
         }
-        catch (err) {
-            throw new CacheError('Failed to close memory cache', 'MEMORY_CLOSE_ERROR', 'memory', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'memory',
+                operation: 'close',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
 }