cds-caching 3.0.1 → 3.1.1

package/lib/operations/AsyncOperations.js

@@ -122,6 +122,22 @@ class AsyncOperations {
         };
     }
 
+    /** @private */
+    _resolveTags(options, value) {
+        const resolver = this.cache?.tagResolver;
+        if (resolver) {
+            return resolver.resolveTags(options?.tags, value, {
+                user: cds.context?.user?.id,
+                tenant: cds.context?.tenant,
+                locale: cds.context?.locale,
+            }) || [];
+        }
+        if (!Array.isArray(options?.tags)) return [];
+        return options.tags
+            .map((t) => (typeof t === 'string' ? t : t?.value))
+            .filter((t) => typeof t === 'string' && t);
+    }
+
     /** @private */
     async _wrap(key, asyncFunction, options, args) {
         // Create dynamic key based on function arguments
@@ -140,7 +156,8 @@ class AsyncOperations {
                 args: args,
                 cacheKey: cacheKey
             }),
-            cacheOptions: JSON.stringify(options)
+            cacheOptions: JSON.stringify(options),
+            tags: this._resolveTags(options, undefined),
         };
 
         // Safely check if key exists in cache
@@ -156,16 +173,6 @@ class AsyncOperations {
         if (hasKey) {
             const latency = this.getElapsedMs(startTime);
 
-            // 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 }),
@@ -174,6 +181,19 @@ class AsyncOperations {
             );
 
             if (getResult.success && getResult.result?.value !== undefined) {
+                if (Array.isArray(getResult.result.tags) && getResult.result.tags.length > 0) {
+                    metadata.tags = getResult.result.tags;
+                }
+
+                const hitStatsResult = await this.safeCacheOperation(
+                    () => this.statistics.recordHit(latency, cacheKey, metadata),
+                    'recordHit',
+                    { key: cacheKey, latency }
+                );
+                if (!hitStatsResult.success) {
+                    cacheErrors.push(hitStatsResult.error);
+                }
+
                 return {
                     result: getResult.result.value,
                     cacheKey,
@@ -187,6 +207,8 @@ class AsyncOperations {
         try {
             const response = await asyncFunction(...args);
             const latency = this.getElapsedMs(startTime);
+            const tags = this._resolveTags(options, response);
+            metadata.tags = tags;
 
             // Safely record miss statistics
             const missStatsResult = await this.safeCacheOperation(
@@ -201,7 +223,7 @@ class AsyncOperations {
             // Safely store in cache
             const wrappedValue = {
                 value: response,
-                tags: options.tags || [],
+                tags,
                 timestamp: Date.now()
             };
 
@@ -281,7 +303,8 @@ class AsyncOperations {
                 args: args,
                 cacheKey: cacheKey
             }),
-            cacheOptions: JSON.stringify(options)
+            cacheOptions: JSON.stringify(options),
+            tags: this._resolveTags(options, undefined),
         };
 
         // Safely check if key exists in cache
@@ -297,16 +320,6 @@ class AsyncOperations {
         if (hasKey) {
             const latency = this.getElapsedMs(startTime);
 
-            // 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 }),
@@ -315,6 +328,19 @@ class AsyncOperations {
             );
 
             if (getResult.success && getResult.result?.value !== undefined) {
+                if (Array.isArray(getResult.result.tags) && getResult.result.tags.length > 0) {
+                    metadata.tags = getResult.result.tags;
+                }
+
+                const hitStatsResult = await this.safeCacheOperation(
+                    () => this.statistics.recordHit(latency, cacheKey, metadata),
+                    'recordHit',
+                    { key: cacheKey, latency }
+                );
+                if (!hitStatsResult.success) {
+                    cacheErrors.push(hitStatsResult.error);
+                }
+
                 return {
                     result: getResult.result.value,
                     cacheKey,
@@ -328,6 +354,8 @@ class AsyncOperations {
         try {
             const response = await asyncFunction(...args);
             const latency = this.getElapsedMs(startTime);
+            const tags = this._resolveTags(options, response);
+            metadata.tags = tags;
 
             // Safely record miss statistics
             const missStatsResult = await this.safeCacheOperation(
@@ -342,7 +370,7 @@ class AsyncOperations {
             // Safely store in cache
             const wrappedValue = {
                 value: response,
-                tags: options.tags || [],
+                tags,
                 timestamp: Date.now()
             };
 

package/lib/operations/BasicOperations.js

@@ -28,9 +28,10 @@ class BasicOperations {
      * @returns {Promise<void>}
      */
     async set(key, value, options = {}, tx = null) {
+        const tags = this.tagResolver.resolveTags(options.tags, value, options.params) || [];
         const wrappedValue = {
             value,
-            tags: this.tagResolver.resolveTags(options.tags, value, options.params) || [],
+            tags,
             timestamp: Date.now()
         };
         const createdKey = this.keyManager.createKey(key, {}, options.key);
@@ -48,7 +49,8 @@ class BasicOperations {
             operation: 'SET',
             operationType: 'BASIC',
             metadata: JSON.stringify({ key: createdKey, ttl: options.ttl || 0 }),
-            cacheOptions: JSON.stringify(options)
+            cacheOptions: JSON.stringify(options),
+            tags,
         };
         this.statistics.recordNativeSet(createdKey, metadata);
 
@@ -84,7 +86,8 @@ class BasicOperations {
             dataType: 'Operation',
             operation: 'GET',
             operationType: 'BASIC',
-            metadata: JSON.stringify({ key: createdKey })
+            metadata: JSON.stringify({ key: createdKey }),
+            tags: wrappedValue?.tags || [],
         };
         const isHit = wrappedValue !== undefined && wrappedValue !== null;
         this.statistics.recordNativeGet(createdKey, isHit, metadata);

package/lib/operations/CapOperations.js

@@ -129,6 +129,13 @@ class CapOperations {
 
         const key = this.keyManager.createKey(request, keyParts, requestOptions.key);
         const startTime = process.hrtime();
+        const tagParams = {
+            ...request.params,
+            user: request.user?.id,
+            tenant: request.tenant,
+            locale: request.locale,
+            hash: this.keyManager.createContentHash(request),
+        };
 
         // Track the miss with total latency (cache lookup + backend operation)
         const metadata = {
@@ -153,7 +160,9 @@ class CapOperations {
                 event: request.event,
                 headers: redactHeaders(request.headers),
             }),
-            cacheOptions: JSON.stringify(requestOptions)
+            cacheOptions: JSON.stringify(requestOptions),
+            // Static tags resolve without a payload; data tags fill in on miss after the response.
+            tags: this.tagResolver.resolveTags(requestOptions.tags, undefined, tagParams) || [],
         };
 
         // Safely check if key exists in cache
@@ -169,17 +178,7 @@ class CapOperations {
         if (hasKey) {
             const latency = this.getElapsedMs(startTime);
 
-            // Safely record hit statistics
-            const hitStatsResult = await this.safeCacheOperation(
-                () => this.statistics.recordHit(latency, key, metadata),
-                'recordHit',
-                { key, latency }
-            );
-            if (!hitStatsResult.success) {
-                cacheErrors.push(hitStatsResult.error);
-            }
-
-            // Safely get value from cache
+            // Safely get value from cache (before recording so entry tags are available)
             const getResult = await this.safeCacheOperation(
                 () => this.cache.send("GET", { key }),
                 'get',
@@ -187,6 +186,19 @@ class CapOperations {
             );
 
             if (getResult.success && getResult.result?.value !== undefined) {
+                if (Array.isArray(getResult.result.tags) && getResult.result.tags.length > 0) {
+                    metadata.tags = getResult.result.tags;
+                }
+
+                const hitStatsResult = await this.safeCacheOperation(
+                    () => this.statistics.recordHit(latency, key, metadata),
+                    'recordHit',
+                    { key, latency }
+                );
+                if (!hitStatsResult.success) {
+                    cacheErrors.push(hitStatsResult.error);
+                }
+
                 return {
                     result: getResult.result.value,
                     cacheKey: key,
@@ -200,6 +212,8 @@ class CapOperations {
         try {
             const response = await service.send(request);
             const totalLatency = this.getElapsedMs(startTime);
+            const tags = this.tagResolver.resolveTags(requestOptions.tags, response, tagParams) || [];
+            metadata.tags = tags;
 
             // Safely record miss statistics
             const missStatsResult = await this.safeCacheOperation(
@@ -214,7 +228,7 @@ class CapOperations {
             // Safely store in cache
             const wrappedValue = {
                 value: response,
-                tags: this.tagResolver.resolveTags(requestOptions.tags, response, { ...request.params, user: request.user?.id, tenant: request.tenant, locale: request.locale, hash: this.keyManager.createContentHash(request) }),
+                tags,
                 timestamp: Date.now()
             };
 
@@ -311,9 +325,14 @@ class CapOperations {
                     const cacheHit = getResult.success && getResult.result?.value !== undefined;
                     const cacheLatency = this.getElapsedMs(startTime);
                     const metadata = this.extractMetadataFromRequest(req);
+                    const tagParams = { ...req.params, hash: this.keyManager.createContentHash(req) };
                     const cacheErrors = [];
 
                     if (cacheHit) {
+                        metadata.tags = (Array.isArray(getResult.result.tags) && getResult.result.tags.length > 0)
+                            ? getResult.result.tags
+                            : (this.tagResolver.resolveTags(req.cacheOptions.tags, getResult.result.value, tagParams) || []);
+
                         // Cache hit
                         const hitStatsResult = await this.safeCacheOperation(
                             () => this.statistics.recordHit(cacheLatency, req.cacheKey, metadata),
@@ -336,6 +355,8 @@ class CapOperations {
                         try {
                             const response = await next();
                             const totalLatency = this.getElapsedMs(startTime);
+                            const tags = this.tagResolver.resolveTags(req.cacheOptions.tags, response, tagParams) || [];
+                            metadata.tags = tags;
 
                             // Safely record miss statistics
                             const missStatsResult = await this.safeCacheOperation(
@@ -352,7 +373,7 @@ class CapOperations {
                             // Safely store in cache
                             const wrappedValue = {
                                 value: response,
-                                tags: this.tagResolver.resolveTags(req.cacheOptions.tags, response, { ...req.params, hash: this.keyManager.createContentHash(req) }),
+                                tags,
                                 timestamp: Date.now()
                             };
 
@@ -407,6 +428,7 @@ class CapOperations {
 
                         const hasCachedValue = hasCachedValueResult.success && hasCachedValueResult.result;
                         const cacheLatency = this.getElapsedMs(startTime);
+                        const tagParams = { ...query.params, hash: this.keyManager.createContentHash(query) };
                         const metadata = {
                             dataType: 'Query',
                             operation: 'SELECT',
@@ -423,21 +445,12 @@ class CapOperations {
                                 serviceName: srv?.name,
                                 path: query.path,
                             }),
-                            cacheOptions: JSON.stringify(options)
+                            cacheOptions: JSON.stringify(options),
+                            tags: this.tagResolver.resolveTags(options.tags, undefined, tagParams) || [],
                         };
                         const cacheErrors = [];
 
                         if (hasCachedValue) {
-                            // Cache hit
-                            const hitStatsResult = await this.safeCacheOperation(
-                                () => this.statistics.recordHit(cacheLatency, query.cacheKey, metadata),
-                                'recordHit',
-                                { key: query.cacheKey, latency: cacheLatency }
-                            );
-                            if (!hitStatsResult.success) {
-                                cacheErrors.push(hitStatsResult.error);
-                            }
-
                             const getResult = await this.safeCacheOperation(
                                 () => this.cache.send("GET", { key: query.cacheKey }),
                                 'get',
@@ -445,6 +458,19 @@ class CapOperations {
                             );
 
                             if (getResult.success && getResult.result?.value !== undefined) {
+                                if (Array.isArray(getResult.result.tags) && getResult.result.tags.length > 0) {
+                                    metadata.tags = getResult.result.tags;
+                                }
+
+                                const hitStatsResult = await this.safeCacheOperation(
+                                    () => this.statistics.recordHit(cacheLatency, query.cacheKey, metadata),
+                                    'recordHit',
+                                    { key: query.cacheKey, latency: cacheLatency }
+                                );
+                                if (!hitStatsResult.success) {
+                                    cacheErrors.push(hitStatsResult.error);
+                                }
+
                                 return {
                                     result: getResult.result.value,
                                     cacheKey: query.cacheKey,
@@ -458,6 +484,8 @@ class CapOperations {
                         try {
                             const data = await srv.run(query);
                             const totalLatency = this.getElapsedMs(startTime);
+                            const tags = this.tagResolver.resolveTags(options.tags, data, tagParams) || [];
+                            metadata.tags = tags;
 
                             // Safely record miss statistics
                             const missStatsResult = await this.safeCacheOperation(
@@ -472,7 +500,7 @@ class CapOperations {
                             // Safely store in cache
                             const wrappedValue = {
                                 value: data,
-                                tags: this.tagResolver.resolveTags(options.tags, data, { ...query.params, hash: this.keyManager.createContentHash(query) }),
+                                tags,
                                 timestamp: Date.now()
                             };
 
@@ -590,7 +618,11 @@ class CapOperations {
                 path: req.http?.req?.path,
                 url: req.http?.req?.url
             }),
-            cacheOptions: JSON.stringify(req.cacheOptions)
+            cacheOptions: JSON.stringify(req.cacheOptions),
+            tags: this.tagResolver.resolveTags(req.cacheOptions?.tags, undefined, {
+                ...req.params,
+                hash: this.keyManager.createContentHash(req),
+            }) || [],
         };
 
         return metadata;