ts-packages 2.0.0 → 3.0.0

package/packages/cache/dist/esm/adapters/redis/RedisCache.js

@@ -1,4 +1,5 @@
 import { createClient, createCluster } from 'redis';
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes';
 import { BaseCache } from '../../core/BaseCache';
 import { CacheError } from '../../errors';
 /**
@@ -66,8 +67,12 @@ export class RedisCache extends BaseCache {
                 this.isConnected = true;
             }
         }
-        catch (err) {
-            throw new CacheError('Failed to connect to Redis', 'REDIS_CONNECTION_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_CONNECTION_FAILED, {
+                adapter: 'redis',
+                operation: 'connect',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -93,8 +98,13 @@ export class RedisCache extends BaseCache {
             this.recordHit();
             return this.deserialize(value);
         }
-        catch (err) {
-            throw new CacheError(`Failed to get key "${key}" from Redis`, 'REDIS_GET_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'get',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -114,8 +124,13 @@ export class RedisCache extends BaseCache {
             }
             this.recordSet();
         }
-        catch (err) {
-            throw new CacheError(`Failed to set key "${key}" in Redis`, 'REDIS_SET_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'set',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -129,8 +144,13 @@ export class RedisCache extends BaseCache {
             this.recordDelete();
             return result > 0;
         }
-        catch (err) {
-            throw new CacheError(`Failed to delete key "${key}" from Redis`, 'REDIS_DELETE_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'delete',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -143,8 +163,13 @@ export class RedisCache extends BaseCache {
             const result = await this.client.exists(fullKey);
             return result > 0;
         }
-        catch (err) {
-            throw new CacheError(`Failed to check existence of key "${key}" in Redis`, 'REDIS_EXISTS_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'exists',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -169,8 +194,12 @@ export class RedisCache extends BaseCache {
                 }
             }
         }
-        catch (err) {
-            throw new CacheError('Failed to clear Redis cache', 'REDIS_CLEAR_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_OPERATION_TIMEOUT, {
+                adapter: 'redis',
+                operation: 'clear',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -195,8 +224,13 @@ export class RedisCache extends BaseCache {
             });
             return result;
         }
-        catch (err) {
-            throw new CacheError('Failed to get multiple keys from Redis', 'REDIS_GET_MULTIPLE_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'getMultiple',
+                details: { keys },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -227,8 +261,13 @@ export class RedisCache extends BaseCache {
             }
             this.stats.sets += Object.keys(data).length;
         }
-        catch (err) {
-            throw new CacheError('Failed to set multiple keys in Redis', 'REDIS_SET_MULTIPLE_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'setMultiple',
+                details: { keys: Object.keys(data) },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -242,8 +281,13 @@ export class RedisCache extends BaseCache {
             this.stats.deletes += result;
             return result;
         }
-        catch (err) {
-            throw new CacheError('Failed to delete multiple keys from Redis', 'REDIS_DELETE_MULTIPLE_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'deleteMultiple',
+                details: { keys },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -255,8 +299,13 @@ export class RedisCache extends BaseCache {
             const fullKey = this.buildKey(key);
             return await this.client.incrBy(fullKey, amount);
         }
-        catch (err) {
-            throw new CacheError(`Failed to increment key "${key}" in Redis`, 'REDIS_INCREMENT_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'increment',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -268,8 +317,13 @@ export class RedisCache extends BaseCache {
             const fullKey = this.buildKey(key);
             return await this.client.decrBy(fullKey, amount);
         }
-        catch (err) {
-            throw new CacheError(`Failed to decrement key "${key}" in Redis`, 'REDIS_DECREMENT_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'decrement',
+                details: { key },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -294,12 +348,12 @@ export class RedisCache extends BaseCache {
                 timestamp: new Date(),
             };
         }
-        catch (err) {
+        catch (error) {
             return {
                 isAlive: false,
                 adapter: 'redis',
                 timestamp: new Date(),
-                error: err.message,
+                error: error.message,
             };
         }
     }
@@ -314,8 +368,12 @@ export class RedisCache extends BaseCache {
                 this.client = null;
             }
         }
-        catch (err) {
-            throw new CacheError('Failed to close Redis connection', 'REDIS_CLOSE_ERROR', 'redis', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_ERROR, {
+                adapter: 'redis',
+                operation: 'close',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
 }

package/packages/cache/dist/esm/core/BaseCache.js

@@ -1,3 +1,4 @@
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes';
 import { CacheError } from '../errors';
 /**
  * Abstract base class for all cache adapters
@@ -27,8 +28,12 @@ export class BaseCache {
         try {
             return JSON.parse(data);
         }
-        catch (err) {
-            throw new CacheError(`Failed to deserialize cache value for key`, 'DESERIALIZE_ERROR', this.config.adapter, err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_DESERIALIZE_ERROR, {
+                adapter: this.config.adapter,
+                operation: 'deserialize',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -38,8 +43,12 @@ export class BaseCache {
         try {
             return JSON.stringify(value);
         }
-        catch (err) {
-            throw new CacheError(`Failed to serialize cache value`, 'SERIALIZE_ERROR', this.config.adapter, err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.CACHE_SERIALIZE_ERROR, {
+                adapter: this.config.adapter,
+                operation: 'serialize',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**

package/packages/cache/dist/esm/core/factory.js

@@ -1,3 +1,4 @@
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes';
 import { MemcacheCache } from '../adapters/memcache';
 import { MemoryCache } from '../adapters/memory';
 import { RedisCache } from '../adapters/redis';
@@ -15,11 +16,23 @@ export class CacheFactory {
                 const redisConfig = config;
                 // Validate: can't use both single + cluster
                 if (redisConfig.host && redisConfig.cluster) {
-                    throw new CacheError('Cannot specify both host and cluster config', 'INVALID_CONFIG');
+                    throw new CacheError(CACHE_ERROR_CODES.CACHE_INVALID_CONFIG, {
+                        adapter: 'redis',
+                        operation: 'create',
+                        details: {
+                            reason: 'Redis config cannot have both "host" and "cluster" defined',
+                        },
+                    });
                 }
                 // Require either single or cluster
                 if (!redisConfig.host && !redisConfig.cluster) {
-                    throw new CacheError('Redis requires either host or cluster config', 'INVALID_CONFIG');
+                    throw new CacheError(CACHE_ERROR_CODES.CACHE_INVALID_CONFIG, {
+                        adapter: 'redis',
+                        operation: 'create',
+                        details: {
+                            reason: 'Redis requires either host or cluster config',
+                        },
+                    });
                 }
                 return new RedisCache(redisConfig);
             case 'memcache':
@@ -27,7 +40,10 @@ export class CacheFactory {
             case 'memory':
                 return new MemoryCache(config);
             default:
-                throw new CacheError(`Unknown cache adapter: ${config.adapter}`, 'UNKNOWN_ADAPTER');
+                throw new CacheError(CACHE_ERROR_CODES.CACHE_UNSUPPORTED_ADAPTER, {
+                    adapter: config.adapter,
+                    operation: 'create',
+                });
         }
     }
     /**
@@ -51,6 +67,12 @@ export class CacheFactory {
             });
         }
         // No fallback, throw error
-        throw new CacheError(`Failed to initialize ${config.adapter} cache and fallback is disabled`, 'CACHE_INIT_ERROR');
+        throw new CacheError(CACHE_ERROR_CODES.CACHE_CONNECTION_FAILED, {
+            adapter: config.adapter,
+            operation: 'createWithFallback',
+            details: {
+                reason: `${config.adapter} cache is not alive and fallback is disabled`,
+            },
+        });
     }
 }

package/packages/cache/dist/esm/errors/CacheError.d.ts

@@ -1,9 +1,12 @@
-/**
- * Custom error class for cache operations
- */
-export declare class CacheError extends Error {
-    readonly code: string;
+import { AppError } from '@naman_deep_singh/errors-utils';
+import type { CacheErrorCode } from './cacheErrorCodes';
+export declare class CacheError extends AppError {
     readonly adapter?: string;
-    readonly originalError?: Error;
-    constructor(message: string, code?: string, adapter?: string, originalError?: Error);
+    readonly operation?: string;
+    constructor(code: CacheErrorCode, options?: {
+        adapter?: string;
+        operation?: string;
+        details?: unknown;
+        cause?: Error;
+    });
 }

package/packages/cache/dist/esm/errors/CacheError.js

@@ -1,13 +1,8 @@
-/**
- * Custom error class for cache operations
- */
-export class CacheError extends Error {
-    constructor(message, code = 'CACHE_ERROR', adapter, originalError) {
-        super(message);
-        this.name = 'CacheError';
-        this.code = code;
-        this.adapter = adapter;
-        this.originalError = originalError;
-        Object.setPrototypeOf(this, CacheError.prototype);
+import { AppError } from '@naman_deep_singh/errors-utils';
+export class CacheError extends AppError {
+    constructor(code, options) {
+        super(code, undefined, options?.details, options?.cause);
+        this.adapter = options?.adapter;
+        this.operation = options?.operation;
     }
 }

package/packages/cache/dist/esm/errors/cacheErrorCodes.d.ts

@@ -0,0 +1,22 @@
+export declare const CACHE_ERROR_CODES: {
+    readonly CACHE_ERROR: "Temporary caching issue, please retry";
+    readonly CACHE_CONNECTION_FAILED: "Failed to connect to the cache server";
+    readonly CACHE_UNSUPPORTED_ADAPTER: "The specified cache adapter is not supported";
+    readonly CACHE_INVALID_CONFIG: "The provided cache configuration is invalid";
+    readonly CACHE_KEY_NOT_FOUND: "The requested cache key was not found";
+    readonly CACHE_OPERATION_TIMEOUT: "The cache operation timed out";
+    readonly CACHE_SERIALIZE_ERROR: "Failed to serialize cached data";
+    readonly CACHE_DESERIALIZE_ERROR: "Failed to deserialize cached data";
+    readonly SESSION_CREATE_ERROR: "Failed to create a new session";
+    readonly SESSION_GET_ERROR: "Failed to get session data";
+    readonly SESSION_UPDATE_ERROR: "Failed to update session data";
+    readonly SESSION_DELETE_ERROR: "Failed to delete session data";
+    readonly SESSION_EXISTS_ERROR: "Failed to check session existence";
+    readonly SESSION_CLEAR_ERROR: "Failed to clear sessions";
+    readonly SESSION_GET_MULTIPLE_ERROR: "Failed to get multiple sessions";
+    readonly SESSION_DELETE_MULTIPLE_ERROR: "Failed to delete multiple sessions";
+    readonly SESSION_EXTEND_ERROR: "Failed to extend session expiry";
+    readonly SESSION_GET_EXTEND_ERROR: "Failed to get and extend session data";
+    readonly SESSION_NOT_FOUND: "Session not found";
+};
+export type CacheErrorCode = (typeof CACHE_ERROR_CODES)[keyof typeof CACHE_ERROR_CODES];

package/packages/cache/dist/esm/errors/cacheErrorCodes.js

@@ -0,0 +1,21 @@
+export const CACHE_ERROR_CODES = {
+    CACHE_ERROR: 'Temporary caching issue, please retry',
+    CACHE_CONNECTION_FAILED: 'Failed to connect to the cache server',
+    CACHE_UNSUPPORTED_ADAPTER: 'The specified cache adapter is not supported',
+    CACHE_INVALID_CONFIG: 'The provided cache configuration is invalid',
+    CACHE_KEY_NOT_FOUND: 'The requested cache key was not found',
+    CACHE_OPERATION_TIMEOUT: 'The cache operation timed out',
+    CACHE_SERIALIZE_ERROR: 'Failed to serialize cached data',
+    CACHE_DESERIALIZE_ERROR: 'Failed to deserialize cached data',
+    SESSION_CREATE_ERROR: 'Failed to create a new session',
+    SESSION_GET_ERROR: 'Failed to get session data',
+    SESSION_UPDATE_ERROR: 'Failed to update session data',
+    SESSION_DELETE_ERROR: 'Failed to delete session data',
+    SESSION_EXISTS_ERROR: 'Failed to check session existence',
+    SESSION_CLEAR_ERROR: 'Failed to clear sessions',
+    SESSION_GET_MULTIPLE_ERROR: 'Failed to get multiple sessions',
+    SESSION_DELETE_MULTIPLE_ERROR: 'Failed to delete multiple sessions',
+    SESSION_EXTEND_ERROR: 'Failed to extend session expiry',
+    SESSION_GET_EXTEND_ERROR: 'Failed to get and extend session data',
+    SESSION_NOT_FOUND: 'Session not found',
+};

package/packages/cache/dist/esm/errors/index.js

@@ -1 +1,4 @@
+import { errorMessageRegistry } from '@naman_deep_singh/errors-utils';
+import { CACHE_ERROR_CODES } from './cacheErrorCodes';
+errorMessageRegistry.register(CACHE_ERROR_CODES);
 export { CacheError } from './CacheError';

package/packages/cache/dist/esm/middleware/express/cacheMiddleware.js

@@ -18,8 +18,8 @@ export function cacheSessionMiddleware(sessionStore, options) {
             }
             next();
         }
-        catch (err) {
-            console.error('Session middleware error:', err);
+        catch (error) {
+            console.error('Session middleware error:', error);
             next();
         }
     };
@@ -35,12 +35,12 @@ export function cacheHealthCheckMiddleware(cache, endpoint = '/.health/cache') {
                 .then((health) => {
                 res.status(health.isAlive ? 200 : 503).json(health);
             })
-                .catch((err) => {
+                .catch((error) => {
                 res.status(503).json({
                     isAlive: false,
                     adapter: 'unknown',
                     timestamp: new Date(),
-                    error: err.message,
+                    error: error.message,
                 });
             });
             return;
@@ -93,8 +93,8 @@ export function cacheResponseMiddleware(cache, options) {
                         }
                     }
                     if (responseData !== null) {
-                        cache.set(cacheKey, responseData, ttl).catch((err) => {
-                            console.error('Failed to cache response:', err);
+                        cache.set(cacheKey, responseData, ttl).catch((error) => {
+                            console.error('Failed to cache response:', error);
                         });
                     }
                 }
@@ -103,8 +103,8 @@ export function cacheResponseMiddleware(cache, options) {
             };
             next();
         })
-            .catch((err) => {
-            console.error('Cache middleware error:', err);
+            .catch((error) => {
+            console.error('Cache middleware error:', error);
             next();
         });
     };

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

@@ -1,4 +1,5 @@
 import { CacheError } from '../errors';
+import { CACHE_ERROR_CODES } from 'src/errors/cacheErrorCodes';
 /**
  * Session store wrapper around cache adapters
  * Provides session management functionality
@@ -20,8 +21,13 @@ export class SessionStore {
             const ttlValue = ttl ?? this.options.ttl;
             await this.cache.set(sessionId, data, ttlValue);
         }
-        catch (err) {
-            throw new CacheError(`Failed to create session "${sessionId}"`, 'SESSION_CREATE_ERROR', 'session', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_CREATE_ERROR, {
+                adapter: 'session',
+                operation: 'create',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -31,8 +37,13 @@ export class SessionStore {
         try {
             return await this.cache.get(sessionId);
         }
-        catch (err) {
-            throw new CacheError(`Failed to get session "${sessionId}"`, 'SESSION_GET_ERROR', 'session', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_GET_ERROR, {
+                adapter: 'session',
+                operation: 'get',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -42,16 +53,25 @@ export class SessionStore {
         try {
             const current = await this.cache.get(sessionId);
             if (!current) {
-                throw new CacheError(`Session "${sessionId}" not found`, 'SESSION_NOT_FOUND');
+                throw new CacheError(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 CacheError) {
-                throw err;
+        catch (error) {
+            if (error instanceof CacheError) {
+                throw error;
             }
-            throw new CacheError(`Failed to update session "${sessionId}"`, 'SESSION_UPDATE_ERROR', 'session', err);
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_UPDATE_ERROR, {
+                adapter: 'session',
+                operation: 'update',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -61,8 +81,13 @@ export class SessionStore {
         try {
             return await this.cache.delete(sessionId);
         }
-        catch (err) {
-            throw new CacheError(`Failed to delete session "${sessionId}"`, 'SESSION_DELETE_ERROR', 'session', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_DELETE_ERROR, {
+                adapter: 'session',
+                operation: 'delete',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -72,8 +97,13 @@ export class SessionStore {
         try {
             return await this.cache.exists(sessionId);
         }
-        catch (err) {
-            throw new CacheError(`Failed to check session "${sessionId}" existence`, 'SESSION_EXISTS_ERROR', 'session', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_EXISTS_ERROR, {
+                adapter: 'session',
+                operation: 'exists',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -83,8 +113,12 @@ export class SessionStore {
         try {
             await this.cache.clear();
         }
-        catch (err) {
-            throw new CacheError('Failed to clear sessions', 'SESSION_CLEAR_ERROR', 'session', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_CLEAR_ERROR, {
+                adapter: 'session',
+                operation: 'clear',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -94,8 +128,12 @@ export class SessionStore {
         try {
             return await this.cache.getMultiple(sessionIds);
         }
-        catch (err) {
-            throw new CacheError('Failed to get multiple sessions', 'SESSION_GET_MULTIPLE_ERROR', 'session', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_GET_MULTIPLE_ERROR, {
+                adapter: 'session',
+                operation: 'getMultiple',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -105,8 +143,12 @@ export class SessionStore {
         try {
             return await this.cache.deleteMultiple(sessionIds);
         }
-        catch (err) {
-            throw new CacheError('Failed to delete multiple sessions', 'SESSION_DELETE_MULTIPLE_ERROR', 'session', err);
+        catch (error) {
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_DELETE_MULTIPLE_ERROR, {
+                adapter: 'session',
+                operation: 'deleteMultiple',
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -116,16 +158,25 @@ export class SessionStore {
         try {
             const current = await this.cache.get(sessionId);
             if (!current) {
-                throw new CacheError(`Session "${sessionId}" not found`, 'SESSION_NOT_FOUND');
+                throw new CacheError(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 CacheError) {
-                throw err;
+        catch (error) {
+            if (error instanceof CacheError) {
+                throw error;
             }
-            throw new CacheError(`Failed to extend session "${sessionId}"`, 'SESSION_EXTEND_ERROR', 'session', err);
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_EXTEND_ERROR, {
+                adapter: 'session',
+                operation: 'extend',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**
@@ -139,11 +190,16 @@ export class SessionStore {
             }
             return data;
         }
-        catch (err) {
-            if (err instanceof CacheError) {
-                throw err;
+        catch (error) {
+            if (error instanceof CacheError) {
+                throw error;
             }
-            throw new CacheError(`Failed to get and extend session "${sessionId}"`, 'SESSION_GET_EXTEND_ERROR', 'session', err);
+            throw new CacheError(CACHE_ERROR_CODES.SESSION_GET_EXTEND_ERROR, {
+                adapter: 'session',
+                operation: 'getAndExtend',
+                details: { sessionId },
+                cause: error instanceof Error ? error : undefined,
+            });
         }
     }
     /**