cds-caching 0.3.3 → 1.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cds-caching",
-  "version": "0.3.3",
-  "description": "A caching plugin for SAP CAP applications supporting Redis",
+  "version": "1.1.0",
+  "description": "A caching plugin for SAP CAP applications",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mikezaschka/cds-caching.git"
@@ -21,9 +21,11 @@
   },
   "homepage": "https://github.com/mikezaschka/cds-caching#readme",
   "main": "cds-plugin.js",
+  "types": "lib/CachingService.d.ts",
   "files": [
     "srv/**",
-    "index.cds"
+    "index.cds",
+    "lib/**"
   ],
   "scripts": {
     "test": "jest --runInBand --silent",
@@ -32,27 +34,30 @@
     "release": "release-it"
   },
   "peerDependencies": {
-    "@sap/cds": ">=9"
+    "@sap/cds": ">=8"
   },
   "workspaces": [
     ".",
-    "test/**"
+    "test/app",
+    "examples/dashboard",
+    "examples/app"
   ],
   "dependencies": {
     "@keyv/compress-gzip": "^2.0.3",
-    "@keyv/compress-lz4": "^1.0.0",
-    "@keyv/redis": "^4.5.0",
+    "@keyv/compress-lz4": "^1.0.1",
+    "@keyv/redis": "^5.0.0",
     "@keyv/sqlite": "^4.0.5",
-    "keyv": "^5.3.4"
+    "keyv": "^5.4.0"
   },
   "devDependencies": {
-    "eslint": "^9.30.1",
+    "@cap-js/cds-test": "^0.4.0",
+    "@release-it/conventional-changelog": "^10.0.1",
+    "eslint": "^9.32.0",
     "husky": "^9.1.7",
-    "jest": "^30.0.4",
-    "release-it": "^19.0.3",
-    "@cap-js/cds-test": "^0.4.0"
+    "jest": "^30.0.5",
+    "release-it": "^19.0.4"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   }
 }

package/srv/caching-api-service.js

@@ -0,0 +1,124 @@
+const cds = require('@sap/cds')
+
+class CachingApiService extends cds.ApplicationService {
+    log = cds.log('cds-caching');
+
+    async init() {
+
+        // Handle setMetricsEnabled action
+        this.on('setMetricsEnabled', async (req) => {
+            const { enabled } = req.data
+            const cache = req.params[0].name;
+            const cacheService = await cds.connect.to(cache);
+            try {
+                await cacheService.setMetricsEnabled(enabled)
+                req.info(`Metrics ${enabled ? 'enabled' : 'disabled'} for cache ${cache}`);
+                return true;
+            } catch (error) {
+                req.error(`Failed to set metrics enabled: ${error.message}`);
+                return false;
+            }
+        })
+
+        // Handle setKeyMetricsEnabled action
+        this.on('setKeyMetricsEnabled', async (req) => {
+            const { enabled } = req.data
+            const cache = req.params[0].name;
+            const cacheService = await cds.connect.to(cache);
+            try {
+                await cacheService.setKeyMetricsEnabled(enabled)
+                req.info(`Key metrics ${enabled ? 'enabled' : 'disabled'} for cache ${cache}`);
+                return true;
+            } catch (error) {
+                req.error(`Failed to set key metrics enabled: ${error.message}`);
+                return false;
+            }
+        })
+
+        // Handle getCacheEntries function
+        this.on('getEntries', async (req) => {
+            const cache = req.params[0].name;
+            try {
+                const cacheService = await cds.connect.to(cache);
+                const entries = [];
+                for await (const [key, value] of cacheService.iterator()) {
+                    entries.push({
+                        entryKey: key,
+                        value: JSON.stringify(value.value),
+                        timestamp: value.timestamp,
+                        tags: value.tags,
+                    });
+                }
+                return entries;
+            } catch (error) {
+                req.error(`Failed to get cache entries: ${error.message}`);
+                return [];
+            }
+        });
+
+        // Handle getCacheEntry function
+        this.on('getEntry', async (req) => {
+            const { key } = req.data;
+            const cache = req.params[0].name;
+            const cacheService = await cds.connect.to(cache);
+            const value = await cacheService.get(key);
+            return {
+                value: value,
+            };
+        });
+
+        // Handle setCacheEntry action
+        this.on('setEntry', async (req) => {
+            const { key, value, ttl } = req.data;
+            const cache = req.params[0].name;
+            const cacheService = await cds.connect.to(cache);
+            await cacheService.set(key, value, { ttl: ttl });
+            req.info(`Cache entry set successfully: ${key}`);
+            return true;
+        });
+
+        // Handle deleteCacheEntry action
+        this.on('deleteEntry', async (req) => {
+            const { key } = req.data;
+            const cache = req.params[0].name;
+            const cacheService = await cds.connect.to(cache);
+            await cacheService.delete(key);
+            req.info(`Cache entry deleted successfully: ${key}`);
+            return true;
+        });
+
+        // Handle clearCache action
+        this.on('clear', async (req) => {
+            const cache = req.params[0].name;
+            const cacheService = await cds.connect.to(cache);
+            await cacheService.clear();
+            req.info(`Cache cleared successfully: ${cache}`);
+            return true;
+        });
+
+        // Handle clearKeyMetrics action
+        this.on('clearKeyMetrics', async (req) => {
+            const cache = req.params[0].name;
+            const cacheService = await cds.connect.to(cache);
+            await cacheService.clearKeyMetrics();
+            req.info(`Key metrics cleared successfully: ${cache}`);
+            return true;
+        });
+
+        // Handle clearMetrics action
+        this.on('clearMetrics', async (req) => {
+            const cache = req.params[0].name;
+            const cacheService = await cds.connect.to(cache);
+            await cacheService.clearMetrics();
+            req.info(`Metrics cleared successfully: ${cache}`);
+            return true;
+        });
+
+        await super.init()
+    }
+
+   
+
+}
+
+module.exports = CachingApiService 

package/srv/CacheStatisticsHandler.js

@@ -1,213 +0,0 @@
-const cds = require('@sap/cds');
-
-class CacheStatisticsHandler {
-    constructor(options = {}) {
-        console.log(options);
-        this.options = {
-            persistenceInterval: 5 * 60 * 60 * 1000, // 5 minutes
-            maxLatencies: 1000,
-            ...options
-        };
-
-        this.stats = {
-            current: {
-                hits: 0,
-                misses: 0,
-                sets: 0,
-                deletes: 0,
-                errors: 0,
-                latencies: []
-            },
-            lastPersisted: Date.now()
-        };
-
-        if (this.options.enabled) {
-            cds.once('served', () => {
-                this.persistInterval = setInterval(
-                    () => this.persistStats(),
-                    this.options.persistenceInterval
-                );
-            })
-            cds.on('shutdown', () => {
-                clearInterval(this.persistInterval)
-            })
-        }
-    }
-
-    recordHit(latencyMs) {
-        this.stats.current.hits++;
-        this.recordLatency(latencyMs);
-    }
-
-    recordMiss() {
-        this.stats.current.misses++;
-    }
-
-    recordSet() {
-        this.stats.current.sets++;
-    }
-
-    recordDelete() {
-        this.stats.current.deletes++;
-    }
-
-    recordError() {
-        this.stats.current.errors++;
-    }
-
-    recordLatency(ms) {
-        this.stats.current.latencies.push(ms);
-        if (this.stats.current.latencies.length > this.options.maxLatencies) {
-            this.stats.current.latencies.shift();
-        }
-    }
-
-    async persistStats() {
-        if (!this.options.enabled) return;
-
-        const now = new Date().toISOString();
-        const hourlyId = `hourly:${now.slice(0, 13)}`;
-        const dailyId = `daily:${now.slice(0, 10)}`;
-
-        const stats = await this.calculateStats();
-
-        try {
-
-            // Persist hourly stats
-            const existingHourly = await SELECT.one.from("cds_caching_Statistics")
-                .where({ ID: hourlyId, cache: this.options.cache });
-
-            if (!existingHourly) {
-                await INSERT.into('cds_caching_Statistics').entries([{
-                    ID: hourlyId,
-                    cache: this.options.cache,
-                    timestamp: now,
-                    period: 'hourly',
-                    ...stats
-                }]);
-            } else {
-                await UPDATE('cds_caching_Statistics')
-                    .set({
-                        hits: { '+=': stats.hits },
-                        misses: { '+=': stats.misses },
-                        sets: { '+=': stats.sets },
-                        deletes: { '+=': stats.deletes },
-                        errors: { '+=': stats.errors },
-                        avgLatency: (existingHourly.avgLatency + stats.avgLatency) / 2,
-                        p95Latency: Math.max(existingHourly.p95Latency, stats.p95Latency),
-                        memoryUsage: stats.memoryUsage,
-                        itemCount: stats.itemCount
-                    })
-                    .where({ ID: hourlyId, cache: this.options.cache });
-            }
-
-            // Update or insert daily stats
-            const existingDaily = await SELECT.one.from("cds_caching_Statistics")
-                .where({ ID: dailyId, cache: this.options.cache });
-
-            if (existingDaily) {
-                await UPDATE('cds_caching_Statistics')
-                    .set({
-                        hits: { '+=': stats.hits },
-                        misses: { '+=': stats.misses },
-                        sets: { '+=': stats.sets },
-                        deletes: { '+=': stats.deletes },
-                        errors: { '+=': stats.errors },
-                        avgLatency: (existingDaily.avgLatency + stats.avgLatency) / 2,
-                        p95Latency: Math.max(existingDaily.p95Latency, stats.p95Latency),
-                        memoryUsage: stats.memoryUsage,
-                        itemCount: stats.itemCount
-                    })
-                    .where({ ID: dailyId, cache: this.options.cache });
-            } else {
-                await INSERT.into("cds_caching_Statistics").entries({
-                    ID: dailyId,
-                    cache: this.options.cache,
-                    timestamp: now,
-                    period: 'daily',
-                    ...stats
-                });
-            }
-
-            this.resetCurrentStats();
-
-        } catch (error) {
-            cds.log('caching').error('Error persisting cache statistics:', error);
-        }
-    }
-
-    async calculateStats() {
-        const latencies = this.stats.current.latencies;
-        const avgLatency = latencies.length > 0
-            ? latencies.reduce((a, b) => a + b, 0) / latencies.length
-            : 0;
-        const p95Latency = latencies.length > 0
-            ? latencies.sort((a, b) => a - b)[Math.floor(latencies.length * 0.95)]
-            : 0;
-
-        return {
-            hits: this.stats.current.hits,
-            misses: this.stats.current.misses,
-            sets: this.stats.current.sets,
-            deletes: this.stats.current.deletes,
-            errors: this.stats.current.errors,
-            avgLatency,
-            p95Latency,
-            memoryUsage: process.memoryUsage().heapUsed,
-            itemCount: await this.options.getItemCount?.() || 0
-        };
-    }
-
-    resetCurrentStats() {
-        this.stats.current = {
-            hits: 0,
-            misses: 0,
-            sets: 0,
-            deletes: 0,
-            errors: 0,
-            latencies: []
-        };
-        this.stats.lastPersisted = Date.now();
-    }
-
-    async getStats(period = 'hourly', from, to) {
-        if (!this.options.enabled) return null;
-
-        const query = SELECT.from("cds_caching_Statistics")
-            .where({ period: period });
-
-        if (from) query.and({ timestamp: { '>=': from } });
-        if (to) query.and({ timestamp: { '<=': to } });
-
-        query.orderBy({ timestamp: 'desc' });
-
-        return await query;
-    }
-
-    async getCurrentStats() {
-        if (!this.options.enabled) return null;
-
-        const { current, lastPersisted } = this.stats;
-        const latencies = current.latencies;
-
-        return {
-            ...current,
-            avgLatency: latencies.length > 0
-                ? latencies.reduce((a, b) => a + b, 0) / latencies.length
-                : 0,
-            p95Latency: latencies.length > 0
-                ? latencies.sort((a, b) => a - b)[Math.floor(latencies.length * 0.95)]
-                : 0,
-            hitRatio: (current.hits / (current.hits + current.misses)) || 0,
-            lastPersisted: new Date(lastPersisted)
-        };
-    }
-
-    dispose() {
-        if (this.persistInterval) {
-            clearInterval(this.persistInterval);
-        }
-    }
-}
-
-module.exports = CacheStatisticsHandler;