ts-packages 2.0.0 → 3.0.0

package/packages/cache/dist/cjs/session/SessionStore.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionStore = void 0;
 const errors_1 = require("../errors");
+const cacheErrorCodes_1 = require("src/errors/cacheErrorCodes");
 /**
  * Session store wrapper around cache adapters
  * Provides session management functionality
@@ -23,8 +24,13 @@ class SessionStore {
             const ttlValue = ttl ?? this.options.ttl;
             await this.cache.set(sessionId, data, ttlValue);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to create session "${sessionId}"`, 'SESSION_CREATE_ERROR', 'session', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_CREATE_ERROR, {
+                adapter: 'session',
+                operation: 'create',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -34,8 +40,13 @@ class SessionStore {
         try {
             return await this.cache.get(sessionId);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to get session "${sessionId}"`, 'SESSION_GET_ERROR', 'session', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_GET_ERROR, {
+                adapter: 'session',
+                operation: 'get',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -45,16 +56,25 @@ class SessionStore {
         try {
             const current = await this.cache.get(sessionId);
             if (!current) {
-                throw new errors_1.CacheError(`Session "${sessionId}" not found`, 'SESSION_NOT_FOUND');
+                throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_NOT_FOUND, {
+                    adapter: 'session',
+                    operation: 'update',
+                    details: { sessionId },
+                });
             }
             const merged = { ...current, ...data };
             await this.cache.set(sessionId, merged, this.options.ttl);
         }
-        catch (err) {
-            if (err instanceof errors_1.CacheError) {
-                throw err;
+        catch (error) {
+            if (error instanceof errors_1.CacheError) {
+                throw error;
             }
-            throw new errors_1.CacheError(`Failed to update session "${sessionId}"`, 'SESSION_UPDATE_ERROR', 'session', err);
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_UPDATE_ERROR, {
+                adapter: 'session',
+                operation: 'update',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -64,8 +84,13 @@ class SessionStore {
         try {
             return await this.cache.delete(sessionId);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to delete session "${sessionId}"`, 'SESSION_DELETE_ERROR', 'session', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_DELETE_ERROR, {
+                adapter: 'session',
+                operation: 'delete',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -75,8 +100,13 @@ class SessionStore {
         try {
             return await this.cache.exists(sessionId);
         }
-        catch (err) {
-            throw new errors_1.CacheError(`Failed to check session "${sessionId}" existence`, 'SESSION_EXISTS_ERROR', 'session', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_EXISTS_ERROR, {
+                adapter: 'session',
+                operation: 'exists',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -86,8 +116,12 @@ class SessionStore {
         try {
             await this.cache.clear();
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to clear sessions', 'SESSION_CLEAR_ERROR', 'session', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_CLEAR_ERROR, {
+                adapter: 'session',
+                operation: 'clear',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -97,8 +131,12 @@ class SessionStore {
         try {
             return await this.cache.getMultiple(sessionIds);
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to get multiple sessions', 'SESSION_GET_MULTIPLE_ERROR', 'session', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_GET_MULTIPLE_ERROR, {
+                adapter: 'session',
+                operation: 'getMultiple',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -108,8 +146,12 @@ class SessionStore {
         try {
             return await this.cache.deleteMultiple(sessionIds);
         }
-        catch (err) {
-            throw new errors_1.CacheError('Failed to delete multiple sessions', 'SESSION_DELETE_MULTIPLE_ERROR', 'session', err);
+        catch (error) {
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_DELETE_MULTIPLE_ERROR, {
+                adapter: 'session',
+                operation: 'deleteMultiple',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -119,16 +161,25 @@ class SessionStore {
         try {
             const current = await this.cache.get(sessionId);
             if (!current) {
-                throw new errors_1.CacheError(`Session "${sessionId}" not found`, 'SESSION_NOT_FOUND');
+                throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_NOT_FOUND, {
+                    adapter: 'session',
+                    operation: 'extend',
+                    details: { sessionId },
+                });
             }
             const ttlValue = ttl ?? this.options.ttl;
             await this.cache.set(sessionId, current, ttlValue);
         }
-        catch (err) {
-            if (err instanceof errors_1.CacheError) {
-                throw err;
+        catch (error) {
+            if (error instanceof errors_1.CacheError) {
+                throw error;
             }
-            throw new errors_1.CacheError(`Failed to extend session "${sessionId}"`, 'SESSION_EXTEND_ERROR', 'session', err);
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_EXTEND_ERROR, {
+                adapter: 'session',
+                operation: 'extend',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -142,11 +193,16 @@ class SessionStore {
             }
             return data;
         }
-        catch (err) {
-            if (err instanceof errors_1.CacheError) {
-                throw err;
+        catch (error) {
+            if (error instanceof errors_1.CacheError) {
+                throw error;
             }
-            throw new errors_1.CacheError(`Failed to get and extend session "${sessionId}"`, 'SESSION_GET_EXTEND_ERROR', 'session', err);
+            throw new errors_1.CacheError(cacheErrorCodes_1.CACHE_ERROR_CODES.SESSION_GET_EXTEND_ERROR, {
+                adapter: 'session',
+                operation: 'getAndExtend',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**

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

@@ -1,71 +1,18 @@
 import { BaseCache } from '../../core/BaseCache';
 import type { HealthCheckResponse, MemcacheCacheConfig } from '../../types';
-/**
- * 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
-     */
+    exists(key: string): Promise<boolean>;
     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>;
 }