cds-caching 1.0.0 → 1.2.0

package/lib/operations/AsyncOperations.js

@@ -7,6 +7,36 @@ class AsyncOperations {
         this.keyManager = keyManager;
         this.statistics = statistics;
         this.runtimeConfigManager = runtimeConfigManager;
+        this.log = console; // Default logger
+    }
+
+    /**
+     * Safely execute cache operations with error handling
+     * @param {Function} operation - The cache operation to execute
+     * @param {string} operationName - Name of the operation for logging
+     * @param {object} context - Context information for logging
+     * @returns {Promise<object>} - The result with error information
+     */
+    async safeCacheOperation(operation, operationName, context = {}) {
+        try {
+            const result = await operation();
+            return { success: true, result, error: null };
+        } catch (error) {
+            this.log.warn(`Cache ${operationName} failed:`, {
+                error: error.message,
+                stack: error.stack,
+                context: context
+            });
+            return { 
+                success: false, 
+                result: null, 
+                error: {
+                    message: error.message,
+                    operation: operationName,
+                    context: context
+                }
+            };
+        }
     }
 
     /**
@@ -85,25 +115,91 @@ class AsyncOperations {
                 cacheOptions: JSON.stringify(options)
             };
 
-            if (await this.cache.has(cacheKey)) {
+            // Safely check if key exists in cache
+            const hasKeyResult = await this.safeCacheOperation(
+                () => this.cache.has(cacheKey),
+                'has',
+                { key: cacheKey, functionName: asyncFunction.name || 'anonymous' }
+            );
+
+            const hasKey = hasKeyResult.success && hasKeyResult.result;
+            const cacheErrors = [];
+
+            if (hasKey) {
                 const latency = this.getElapsedMs(startTime);
-                this.statistics.recordHit(latency, cacheKey, metadata);
+                
+                // Safely record hit statistics
+                const hitStatsResult = await this.safeCacheOperation(
+                    () => this.statistics.recordHit(latency, cacheKey, metadata),
+                    'recordHit',
+                    { key: cacheKey, latency }
+                );
+                if (!hitStatsResult.success) {
+                    cacheErrors.push(hitStatsResult.error);
+                }
+
+                // Safely get value from cache
+                const getResult = await this.safeCacheOperation(
+                    () => this.cache.send("GET", { key: cacheKey }),
+                    'get',
+                    { key: cacheKey }
+                );
+
+                if (getResult.success && getResult.result?.value !== undefined) {
+                    return { 
+                        result: getResult.result.value, 
+                        cacheKey, 
+                        metadata: { hit: true, latency },
+                        cacheErrors: cacheErrors
+                    };
+                }
+            }
 
-                const result = await this.cache.send("GET", { key: cacheKey });
-                return { result: result?.value || result, cacheKey, metadata: { hit: true, latency } };
-            } else {
+            // Cache miss or cache error - delegate to underlying function
+            try {
                 const response = await asyncFunction(...args);
                 const latency = this.getElapsedMs(startTime);
-                this.statistics.recordMiss(latency, cacheKey, metadata);
+                
+                // Safely record miss statistics
+                const missStatsResult = await this.safeCacheOperation(
+                    () => this.statistics.recordMiss(latency, cacheKey, metadata),
+                    'recordMiss',
+                    { key: cacheKey, latency }
+                );
+                if (!missStatsResult.success) {
+                    cacheErrors.push(missStatsResult.error);
+                }
 
+                // Safely store in cache
                 const wrappedValue = {
                     value: response,
                     tags: options.tags || [],
                     timestamp: Date.now()
                 };
-                await this.cache.send("SET", { key: cacheKey, value: wrappedValue, ttl: options.ttl || 0 });
+                
+                const setResult = await this.safeCacheOperation(
+                    () => this.cache.send("SET", { key: cacheKey, value: wrappedValue, ttl: options.ttl || 0 }),
+                    'set',
+                    { key: cacheKey, ttl: options.ttl }
+                );
+                if (!setResult.success) {
+                    cacheErrors.push(setResult.error);
+                }
 
-                return { result: response, cacheKey, metadata: { hit: false, latency } };
+                return { 
+                    result: response, 
+                    cacheKey, 
+                    metadata: { hit: false, latency },
+                    cacheErrors: cacheErrors
+                };
+            } catch (functionError) {
+                // If the underlying function fails, throw the error
+                this.log.error('Function execution failed:', {
+                    error: functionError.message,
+                    functionName: asyncFunction.name || 'anonymous',
+                    key: cacheKey
+                });
+                throw functionError;
             }
         }
     }
@@ -137,24 +233,91 @@ class AsyncOperations {
             cacheOptions: JSON.stringify(options)
         };
 
-        if (await this.cache.has(cacheKey)) {
+        // Safely check if key exists in cache
+        const hasKeyResult = await this.safeCacheOperation(
+            () => this.cache.has(cacheKey),
+            'has',
+            { key: cacheKey, functionName: asyncFunction.name || 'anonymous' }
+        );
+
+        const hasKey = hasKeyResult.success && hasKeyResult.result;
+        const cacheErrors = [];
+
+        if (hasKey) {
             const latency = this.getElapsedMs(startTime);
-            this.statistics.recordHit(latency, cacheKey, metadata);
-            const result = await this.cache.send("GET", { key: cacheKey });
-            return { result: result?.value || result, cacheKey, metadata: { hit: true, latency } };
-        } else {
+            
+            // Safely record hit statistics
+            const hitStatsResult = await this.safeCacheOperation(
+                () => this.statistics.recordHit(latency, cacheKey, metadata),
+                'recordHit',
+                { key: cacheKey, latency }
+            );
+            if (!hitStatsResult.success) {
+                cacheErrors.push(hitStatsResult.error);
+            }
+
+            // Safely get value from cache
+            const getResult = await this.safeCacheOperation(
+                () => this.cache.send("GET", { key: cacheKey }),
+                'get',
+                { key: cacheKey }
+            );
+
+            if (getResult.success && getResult.result?.value !== undefined) {
+                return { 
+                    result: getResult.result.value, 
+                    cacheKey, 
+                    metadata: { hit: true, latency },
+                    cacheErrors: cacheErrors
+                };
+            }
+        }
+
+        // Cache miss or cache error - delegate to underlying function
+        try {
             const response = await asyncFunction(...args);
             const latency = this.getElapsedMs(startTime);
-            this.statistics.recordMiss(latency, cacheKey, metadata);
+            
+            // Safely record miss statistics
+            const missStatsResult = await this.safeCacheOperation(
+                () => this.statistics.recordMiss(latency, cacheKey, metadata),
+                'recordMiss',
+                { key: cacheKey, latency }
+            );
+            if (!missStatsResult.success) {
+                cacheErrors.push(missStatsResult.error);
+            }
 
+            // Safely store in cache
             const wrappedValue = {
                 value: response,
                 tags: options.tags || [],
                 timestamp: Date.now()
             };
-            await this.cache.send("SET", { key: cacheKey, value: wrappedValue, ttl: options.ttl || 0 });
+            
+            const setResult = await this.safeCacheOperation(
+                () => this.cache.send("SET", { key: cacheKey, value: wrappedValue, ttl: options.ttl || 0 }),
+                'set',
+                { key: cacheKey, ttl: options.ttl }
+            );
+            if (!setResult.success) {
+                cacheErrors.push(setResult.error);
+            }
 
-            return { result: response, cacheKey, metadata: { hit: false, latency } };
+            return { 
+                result: response, 
+                cacheKey, 
+                metadata: { hit: false, latency },
+                cacheErrors: cacheErrors
+            };
+        } catch (functionError) {
+            // If the underlying function fails, throw the error
+            this.log.error('Function execution failed:', {
+                error: functionError.message,
+                functionName: asyncFunction.name || 'anonymous',
+                key: cacheKey
+            });
+            throw functionError;
         }
     }
 

package/lib/operations/BasicOperations.js

@@ -9,6 +9,16 @@ class BasicOperations {
         this.statistics = statistics;
     }
 
+    _keyv() {
+        // The underlying Keyv instance is stored on the CachingService as `this.cache`
+        // (see `CachingService.init()` where `this.cache = new Keyv(...)`).
+        const keyv = this.cache?.cache;
+        if (!keyv) {
+            throw new Error('cds-caching: Keyv store not initialized on caching service');
+        }
+        return keyv;
+    }
+
     /**
      * Set a value in the cache
      * @param {string|object} key - the key to set
@@ -16,14 +26,17 @@ class BasicOperations {
      * @param {object} options - cache options
      * @returns {Promise<void>}
      */
-    async set(key, value, options = {}) {
+    async set(key, value, options = {}, tx = null) {
         const wrappedValue = {
             value,
             tags: this.tagResolver.resolveTags(options.tags, value, options.params) || [],
             timestamp: Date.now()
         };
         const createdKey = this.keyManager.createKey(key, {}, options.key);
-        await this.cache.send('SET', {
+        // If no key was created, the input should not be cached (e.g. non-SELECT CQN)
+        if (!createdKey) return;
+        const srv = tx || this.cache;
+        await srv.send('SET', {
             key: createdKey,
             value: wrappedValue,
             ttl: options.ttl || 0
@@ -44,9 +57,16 @@ class BasicOperations {
      * @param {string|object} key - the key to get
      * @returns {Promise<any>} - the cached value
      */
-    async get(key) {
+    async get(key, tx = null) {
         const createdKey = this.keyManager.createKey(key);
-        const wrappedValue = await this.cache.send('GET', {
+        
+        // If not key was created, return undefined
+        if(!createdKey) {
+            return undefined;
+        }
+
+        const srv = tx || this.cache;
+        const wrappedValue = await srv.send('GET', {
             key: createdKey
         });
 
@@ -68,9 +88,21 @@ class BasicOperations {
      * @param {string|object} key - the key to check
      * @returns {Promise<boolean>} - whether the key exists
      */
-    async has(key) {
+    async has(key, tx = null) {
         const createdKey = this.keyManager.createKey(key);
-        return this.cache.cache.has(createdKey);
+        if (!createdKey) return false;
+        try {
+            // Intentionally bypass CAP service/transaction handling here.
+            // This avoids coupling to the caller's request tx (which might already be rolled back)
+            // and makes `has()` safe to call even in concurrent BEFORE handlers.
+            return await this._keyv().has(createdKey);
+        } catch (error) {
+            if (this.cache.options.throwOnErrors) {
+                throw error;
+            } else {
+                return false; // We don't want to throw errors here
+            }
+        }
     }
 
     /**
@@ -78,9 +110,11 @@ class BasicOperations {
      * @param {string|object} key - the key to delete
      * @returns {Promise<boolean>} - whether the key was deleted
      */
-    async delete(key) {
+    async delete(key, tx = null) {
         const createdKey = this.keyManager.createKey(key);
-        const result = await this.cache.send('DELETE', {
+        if (!createdKey) return false;
+        const srv = tx || this.cache;
+        const result = await srv.send('DELETE', {
             key: createdKey
         });
 
@@ -100,8 +134,11 @@ class BasicOperations {
      * Clear all cache entries
      * @returns {Promise<void>}
      */
-    async clear() {
-        await this.cache.send('CLEAR');
+    async clear(tx = null) {
+        const srv = tx || this.cache;
+        await srv.send('CLEAR', {
+            deleteAll: true
+        });
 
         // Record the native clear operation
         const metadata = {
@@ -119,10 +156,11 @@ class BasicOperations {
      * @param {string} tag - the tag to match
      * @returns {Promise<void>}
      */
-    async deleteByTag(tag) {
+    async deleteByTag(tag, tx = null) {
+        // Iterate directly on the underlying store to avoid recursion via CachingService.iterator()
         for await (const [key, wrappedValue] of this.iterator()) {
             if (wrappedValue?.tags?.includes(tag)) {
-                await this.delete(key);
+                await this.delete(key, tx);
             }
         }
 
@@ -142,9 +180,11 @@ class BasicOperations {
      * @param {string|object} key - the key to get metadata for
      * @returns {Promise<object|null>} - the metadata or null if not found
      */
-    async metadata(key) {
+    async metadata(key, tx = null) {
         const createdKey = this.keyManager.createKey(key);
-        const wrappedValue = await this.cache.send('GET', {
+        if (!createdKey) return null;
+        const srv = tx || this.cache;
+        const wrappedValue = await srv.send('GET', {
             key: createdKey
         });
         if (!wrappedValue) return null;
@@ -158,9 +198,11 @@ class BasicOperations {
      * @param {string|object} key - the key to get tags for
      * @returns {Promise<string[]>} - the tags
      */
-    async tags(key) {
+    async tags(key, tx = null) {
         const createdKey = this.keyManager.createKey(key);
-        const wrappedValue = await this.cache.send('GET', {
+        if (!createdKey) return [];
+        const srv = tx || this.cache;
+        const wrappedValue = await srv.send('GET', {
             key: createdKey
         });
         return wrappedValue?.tags || [];
@@ -171,9 +213,11 @@ class BasicOperations {
      * @param {string|object} key - the key to get
      * @returns {Promise<any>} - the raw cached value
      */
-    async getRaw(key) {
+    async getRaw(key, tx = null) {
         const createdKey = this.keyManager.createKey(key);
-        const wrappedValue = await this.cache.send('GET', {
+        if (!createdKey) return undefined;
+        const srv = tx || this.cache;
+        const wrappedValue = await srv.send('GET', {
             key: createdKey
         });
         return wrappedValue?.value;
@@ -183,8 +227,9 @@ class BasicOperations {
      * Iterator for all cache entries
      * @returns {AsyncIterator} - iterator for cache entries
      */
-    async *iterator() {
-        for await (const [key, value] of this.cache.cache.iterator()) {
+    async *iterator(tx = null) {
+        // Iterate directly on Keyv to avoid recursion via CachingService.iterator()
+        for await (const [key, value] of this._keyv().iterator()) {
             if (typeof value === "string") {
                 try {
                     yield [key, JSON.parse(value)];
@@ -196,6 +241,107 @@ class BasicOperations {
             }
         }
     }
+
+    async setInTx(key, value, options = {}) {
+        const tx = await this.cache.tx();
+        try {
+            await this.set(key, value, options, tx);
+            await tx.commit();
+            return;
+        } catch (error) {
+            await tx.rollback();
+            throw error;
+        }
+    }
+
+    async getInTx(key) {
+        const tx = await this.cache.tx();
+        try {
+            const value = await this.get(key, tx);
+            await tx.commit();
+            return value;
+        } catch (error) {
+            await tx.rollback();
+            throw error;
+        }
+    }
+
+    async hasInTx(key) {
+        // `has()` bypasses CAP tx handling on purpose, so opening a new transaction is unnecessary.
+        return this.has(key);
+    }
+
+    async deleteInTx(key) {
+        const tx = await this.cache.tx();
+        try {
+            const value = await this.delete(key, tx);
+            await tx.commit();
+            return value;
+        } catch (error) {
+            await tx.rollback();
+            throw error;
+        }
+    }
+
+    async clearInTx() {
+        const tx = await this.cache.tx();
+        try {
+            await this.clear(tx);
+            await tx.commit();
+            return;
+        } catch (error) {
+            await tx.rollback();
+            throw error;
+        }
+    }
+
+    async deleteByTagInTx(tag) {
+        const tx = await this.cache.tx();
+        try {
+            await this.deleteByTag(tag, tx);
+            await tx.commit();
+            return;
+        } catch (error) {
+            await tx.rollback();
+            throw error;
+        }
+    }
+
+    async metadataInTx(key) {
+        const tx = await this.cache.tx();
+        try {
+            const value = await this.metadata(key, tx);
+            await tx.commit();
+            return value;
+        } catch (error) {
+            await tx.rollback();
+            throw error;
+        }
+    }
+
+    async tagsInTx(key) {
+        const tx = await this.cache.tx();
+        try {
+            const value = await this.tags(key, tx);
+            await tx.commit();
+            return value;
+        } catch (error) {
+            await tx.rollback();
+            throw error;
+        }
+    }
+
+    async getRawInTx(key) {
+        const tx = await this.cache.tx();
+        try {
+            const value = await this.getRaw(key, tx);
+            await tx.commit();
+            return value;
+        } catch (error) {
+            await tx.rollback();
+            throw error;
+        }
+    }
 }
 
 module.exports = BasicOperations;