cds-caching 1.0.0 → 1.2.0

package/lib/operations/CapOperations.js

@@ -15,9 +15,39 @@ class CapOperations {
         this.statistics = statistics;
         this.tagResolver = new TagResolver();
         this.runtimeConfigManager = runtimeConfigManager;
+        this.log = log || console;
     }
 
-
+    /**
+     * 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();
+            this.log.info('RESULT', { result, operationName, context });
+            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
+                }
+            };
+        }
+    }
 
     /**
      * Send a request with caching with read-through capabilities.
@@ -34,7 +64,7 @@ class CapOperations {
         }
 
         if (['POST', 'PUT', 'DELETE', 'PATCH'].includes(request.method?.toUpperCase()) || !service.send) {
-            return { result: null, cacheKey: null, metadata: { hit: false, latency: 0 } };
+            return { result: null, cacheKey: null, metadata: { hit: false, latency: 0 }, cacheErrors: [] };
         }
 
         const keyParts = {
@@ -79,31 +109,94 @@ class CapOperations {
             cacheOptions: JSON.stringify(requestOptions)
         };
 
-        if (await this.cache.has(key)) {
+        // Safely check if key exists in cache
+        const hasKeyResult = await this.safeCacheOperation(
+            () => this.cache.has(key),
+            'has',
+            { key, serviceName: service.name }
+        );
+
+        const hasKey = hasKeyResult.success && hasKeyResult.result;
+        const cacheErrors = [];
+
+        if (hasKey) {
             const latency = this.getElapsedMs(startTime);
 
-            this.statistics.recordHit(latency, key, metadata);
+            // 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
+            const getResult = await this.safeCacheOperation(
+                () => this.cache.send("GET", { key }),
+                'get',
+                { key }
+            );
+
+            if (getResult.success && getResult.result?.value !== undefined) {
+                return { 
+                    result: getResult.result.value, 
+                    cacheKey: key, 
+                    metadata: { hit: true, latency: latency },
+                    cacheErrors: cacheErrors
+                };
+            }
+        }
 
-            const wrappedValue = await this.cache.send("GET", { key });
-            return { result: wrappedValue?.value, cacheKey: key, metadata: { hit: true, latency: latency } };
-        } else {
+        // Cache miss or cache error - delegate to underlying service
+        try {
             const response = await service.send(request);
             const totalLatency = this.getElapsedMs(startTime);
-            this.statistics.recordMiss(totalLatency, key, metadata);
+            
+            // Safely record miss statistics
+            const missStatsResult = await this.safeCacheOperation(
+                () => this.statistics.recordMiss(totalLatency, key, metadata),
+                'recordMiss',
+                { key, latency: totalLatency }
+            );
+            if (!missStatsResult.success) {
+                cacheErrors.push(missStatsResult.error);
+            }
 
+            // 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) }),
                 timestamp: Date.now()
             };
-            await this.cache.send("SET", { key, value: wrappedValue, ttl: requestOptions.ttl || 0 });
+            
+            const setResult = await this.safeCacheOperation(
+                () => this.cache.send("SET", { key, value: wrappedValue, ttl: requestOptions.ttl || 0 }),
+                'set',
+                { key, ttl: requestOptions.ttl }
+            );
+            if (!setResult.success) {
+                cacheErrors.push(setResult.error);
+            }
 
-            return { result: response, cacheKey: key, metadata: { hit: false, latency: totalLatency } };
+            return { 
+                result: response, 
+                cacheKey: key, 
+                metadata: { hit: false, latency: totalLatency },
+                cacheErrors: cacheErrors
+            };
+        } catch (serviceError) {
+            // If the underlying service fails, throw the error
+            this.log.error('Service operation failed:', {
+                error: serviceError.message,
+                serviceName: service.name,
+                key: key
+            });
+            throw serviceError;
         }
     }
 
-
-
     /**
      * Run a cached operation with automatic key generation
      * @param {object} req - the request object
@@ -133,34 +226,87 @@ class CapOperations {
 
                     // Track cache operation timing
                     const startTime = process.hrtime();
-                    const wrappedValue = await this.cache.send("GET", { key: req.cacheKey });
-                    const cacheHit = wrappedValue?.value !== undefined;
+                    
+                    // Safely get value from cache
+                    const getResult = await this.safeCacheOperation(
+                        () => this.cache.send("GET", { key: req.cacheKey }),
+                        'get',
+                        { key: req.cacheKey, serviceName: req.target?.name }
+                    );
+                    
+                    const cacheHit = getResult.success && getResult.result?.value !== undefined;
                     const cacheLatency = this.getElapsedMs(startTime);
                     const metadata = this.extractMetadataFromRequest(req);
+                    const cacheErrors = [];
 
                     if (cacheHit) {
                         // Cache hit
-                        this.statistics.recordHit(cacheLatency, req.cacheKey, metadata);
+                        const hitStatsResult = await this.safeCacheOperation(
+                            () => this.statistics.recordHit(cacheLatency, req.cacheKey, metadata),
+                            'recordHit',
+                            { key: req.cacheKey, latency: cacheLatency }
+                        );
+                        if (!hitStatsResult.success) {
+                            cacheErrors.push(hitStatsResult.error);
+                        }
+                        
                         req.res?.setHeader('x-sap-cap-cache', "hit");
-
-                        const wrappedValue = await this.cache.send("GET", { key: req.cacheKey });
-                        return { result: wrappedValue?.value, cacheKey: req.cacheKey, metadata: { hit: true, latency: cacheLatency } };
+                        return { 
+                            result: getResult.result.value, 
+                            cacheKey: req.cacheKey, 
+                            metadata: { hit: true, latency: cacheLatency },
+                            cacheErrors: cacheErrors
+                        };
                     } else {
                         // Cache miss - track the backend operation
-                        const response = await next();
-                        const totalLatency = this.getElapsedMs(startTime);
-
-                        // Track the miss with total latency (cache lookup + backend operation)
-                        this.statistics.recordMiss(totalLatency, req.cacheKey, metadata);
-                        req.res?.setHeader('x-sap-cap-cache', "miss");
+                        try {
+                            const response = await next();
+                            const totalLatency = this.getElapsedMs(startTime);
 
-                        const wrappedValue = {
-                            value: response,
-                            tags: this.tagResolver.resolveTags(req.cacheOptions.tags, response, { ...req.params, hash: this.keyManager.createContentHash(req) }),
-                            timestamp: Date.now()
-                        };
-                        await this.cache.send("SET", { key: req.cacheKey, value: wrappedValue, ttl: req.cacheOptions.ttl || 0 });
-                        return { result: response, cacheKey: req.cacheKey, metadata: { hit: false, latency: totalLatency } };
+                            // Safely record miss statistics
+                            const missStatsResult = await this.safeCacheOperation(
+                                () => this.statistics.recordMiss(totalLatency, req.cacheKey, metadata),
+                                'recordMiss',
+                                { key: req.cacheKey, latency: totalLatency }
+                            );
+                            if (!missStatsResult.success) {
+                                cacheErrors.push(missStatsResult.error);
+                            }
+                            
+                            req.res?.setHeader('x-sap-cap-cache', "miss");
+
+                            // Safely store in cache
+                            const wrappedValue = {
+                                value: response,
+                                tags: this.tagResolver.resolveTags(req.cacheOptions.tags, response, { ...req.params, hash: this.keyManager.createContentHash(req) }),
+                                timestamp: Date.now()
+                            };
+                            
+                            const setResult = await this.safeCacheOperation(
+                                () => this.cache.send("SET", { key: req.cacheKey, value: wrappedValue, ttl: req.cacheOptions.ttl || 0 }),
+                                'set',
+                                { key: req.cacheKey, ttl: req.cacheOptions.ttl }
+                            );
+
+                            if (!setResult.success) {
+                                cacheErrors.push(setResult.error);
+                            }
+                            
+                            return { 
+                                result: response, 
+                                cacheKey: req.cacheKey, 
+                                metadata: { hit: false, latency: totalLatency },
+                                cacheErrors: cacheErrors
+                            };
+                        } catch (serviceError) {
+                            // If the underlying service fails, throw the error
+                            this.log.error('Service operation failed:', {
+                                error: serviceError.message,
+                                serviceName: req.target?.name,
+                                key: req.cacheKey
+                            });
+                            throw serviceError;
+                        }
                     }
                 case "cds.ql":
                     const query = arg1;
@@ -177,7 +323,15 @@ class CapOperations {
 
                         // Track cache operation timing
                         const startTime = process.hrtime();
-                        const hasCachedValue = await this.cache.has(query.cacheKey);
+                        
+                        // Safely check if key exists in cache
+                        const hasCachedValueResult = await this.safeCacheOperation(
+                            () => this.cache.has(query.cacheKey),
+                            'has',
+                            { key: query.cacheKey, serviceName: srv?.name }
+                        );
+                        
+                        const hasCachedValue = hasCachedValueResult.success && hasCachedValueResult.result;
                         const cacheLatency = this.getElapsedMs(startTime);
                         const metadata = {
                             dataType: 'Query',
@@ -197,35 +351,89 @@ class CapOperations {
                             }),
                             cacheOptions: JSON.stringify(options)
                         };
+                        const cacheErrors = [];
 
                         if (hasCachedValue) {
                             // Cache hit
-                            this.statistics.recordHit(cacheLatency, query.cacheKey, metadata);
+                            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',
+                                { key: query.cacheKey }
+                            );
+                            
+                            if (getResult.success && getResult.result?.value !== undefined) {
+                                                            return { 
+                                result: getResult.result.value, 
+                                cacheKey: query.cacheKey, 
+                                metadata: { hit: true, latency: cacheLatency },
+                                cacheErrors: cacheErrors
+                            };
+                            }
+                        }
 
-                            const wrappedValue = await this.cache.send("GET", { key: query.cacheKey });
-                            return { result: wrappedValue?.value, cacheKey: query.cacheKey, metadata: { hit: true, latency: cacheLatency } };
-                        } else {
-                            // Cache miss
+                        // Cache miss or cache error
+                        try {
                             const data = await srv.run(query);
                             const totalLatency = this.getElapsedMs(startTime);
 
-                            // Track the miss with total latency (cache lookup + backend operation)
-                            this.statistics.recordMiss(totalLatency, query.cacheKey, metadata);
-
+                            // Safely record miss statistics
+                            const missStatsResult = await this.safeCacheOperation(
+                                () => this.statistics.recordMiss(totalLatency, query.cacheKey, metadata),
+                                'recordMiss',
+                                { key: query.cacheKey, latency: totalLatency }
+                            );
+                            if (!missStatsResult.success) {
+                                cacheErrors.push(missStatsResult.error);
+                            }
+
+                            // Safely store in cache
                             const wrappedValue = {
                                 value: data,
                                 tags: this.tagResolver.resolveTags(options.tags, data, { ...query.params, hash: this.keyManager.createKey(query, { serviceName: srv?.name, template: '{hash}' }) }),
                                 timestamp: Date.now()
                             };
-                            await this.cache.send("SET", { key: query.cacheKey, value: wrappedValue, ttl: options.ttl || 0 });
-                            return { result: data, cacheKey: query.cacheKey, metadata: { hit: false, latency: totalLatency } };
+                            
+                            const setResult = await this.safeCacheOperation(
+                                () => this.cache.send("SET", { key: query.cacheKey, value: wrappedValue, ttl: options.ttl || 0 }),
+                                'set',
+                                { key: query.cacheKey, ttl: options.ttl }
+                            );
+                            if (!setResult.success) {
+                                cacheErrors.push(setResult.error);
+                            }
+
+                            this.log.info('REEEESULT', { setResult, cacheErrors, wrappedValue });
+                            
+                            return { 
+                                result: data, 
+                                cacheKey: query.cacheKey, 
+                                metadata: { hit: false, latency: totalLatency },
+                                cacheErrors: cacheErrors
+                            };
+                        } catch (serviceError) {
+                            // If the underlying service fails, throw the error
+                            this.log.error('Service operation failed:', {
+                                error: serviceError.message,
+                                serviceName: srv?.name,
+                                key: query.cacheKey
+                            });
+                            throw serviceError;
                         }
                     } else {
                         return srv.run(query);
                     }
             }
         }
-        return null;
+        return { result: null, cacheKey: null, metadata: { hit: false, latency: 0 }, cacheErrors: [] };
     }
 
     /**
@@ -292,8 +500,6 @@ class CapOperations {
      */
     extractMetadataFromRequest(req) {
 
-        console.log(JSON.stringify(req.http?.req, null, 2));
-
         const metadata = {
             dataType: req.constructor.name,
             serviceName: req.target?.name || '',

package/lib/support/CacheStoreManager.js

@@ -1,8 +1,5 @@
 const { Keyv } = require('keyv');
-const { default: KeyvRedis } = require('@keyv/redis');
-const { default: KeyvSqlite } = require('@keyv/sqlite');
-const { default: KeyvLz4 } = require('@keyv/compress-lz4');
-const { default: KeyvGzip } = require('@keyv/compress-gzip');
+const { requireOptional, requireAnyOptional } = require('./optionalRequire');
 
 /**
  * Manages cache store initialization and configuration
@@ -10,6 +7,7 @@ const { default: KeyvGzip } = require('@keyv/compress-gzip');
 class CacheStoreManager {
     constructor(options = {}) {
         this.options = options;
+        this.log = cds.log('cds-caching')
     }
 
     /**
@@ -20,12 +18,13 @@ class CacheStoreManager {
      */
     createStore(options, cacheName) {
         const store = this._createStoreInstance(options);
-        const cacheOptions = this._createCacheOptions(options, cacheName);
+        const cacheOptions = this._createCacheOptions(options, cacheName, store);
         const cache = new Keyv(cacheOptions);
+        cache.throwOnErrors = options.throwOnErrors;
 
         // Set up error handling
         cache.on('error', err => {
-            console.error(`Cache error for ${cacheName}:`, err);
+            this.log.error(`Cache error for ${cacheName}:`, err);
         });
 
         // Set up cleanup function
@@ -41,15 +40,46 @@ class CacheStoreManager {
     _createStoreInstance(options) {
         switch (options.store) {
             case "sqlite":
+                // Support both adapters:
+                // - @keyv/sqlite (default export)
+                // - @resolid/keyv-sqlite (named export KeyvSqlite) https://github.com/huijiewei/keyv-sqlite
+                const sqliteMod = requireAnyOptional(['@keyv/sqlite', '@resolid/keyv-sqlite'], { feature: 'store', value: 'sqlite' });
+                const KeyvSqlite = sqliteMod?.KeyvSqlite ?? sqliteMod?.default ?? sqliteMod;
                 return new KeyvSqlite({
                     url: options.credentials?.url,
                     table: options.credentials?.table || 'cache',
                     busyTimeout: options.credentials?.busyTimeout || 10000
                 });
             case "redis":
-                return new KeyvRedis({
+                const KeyvRedis = requireOptional('@keyv/redis', { feature: 'store', value: 'redis' });
+                const store = new KeyvRedis({
                     ...options.credentials,
                     ...(options.credentials?.uri ? { url: options.credentials?.uri } : {}),
+                    ...{ throwOnConnectErrors: options.throwOnErrors, useKeyPrefix: false, throwOnErrors: options.throwOnErrors }
+                });
+
+                // see https://keyv.org/docs/storage-adapters/redis/#gracefully-handling-errors-and-timeouts for more details
+                if (options.throwOnErrors) {
+                    store.throwOnConnectErrors = false; // We want to handle the errors ourselves
+                    store.throwOnErrors = true; // Redis will throw errors for connection issues, etc.
+                    const redisClient = store.client;
+                    if (redisClient.options) {
+                        redisClient.options.disableOfflineQueue = true;
+                        if (redisClient.options.socket) {
+                            redisClient.options.socket.reconnectStrategy = false; // Disable automatic reconnection
+                        }
+                    }
+                }
+
+                return store;
+            case "postgres":
+                const KeyvPostgres = requireOptional('@keyv/postgres', { feature: 'store', value: 'postgres' });
+                return new KeyvPostgres({
+                    ...options.credentials,
+                    ...(options.credentials?.url ? { uri: options.credentials?.url } : options.credentials?.uri ? { url: options.credentials?.uri } : {}),
+                    ...(options.credentials?.schema ? { schema: options.credentials?.schema } : {}),
+                    ...(options.credentials?.table ? { table: options.credentials?.table } : {}),
+                    ...{ throwOnConnectErrors: options.throwOnErrors, useKeyPrefix: false, throwOnErrors: options.throwOnErrors }
                 });
             default:
                 return new Map();
@@ -60,11 +90,12 @@ class CacheStoreManager {
      * Create cache options object
      * @private
      */
-    _createCacheOptions(options, cacheName) {
+    _createCacheOptions(options, cacheName, store) {
         return {
             namespace: options.namespace || cacheName,
-            store: this._createStoreInstance(options),
-            compression: this._createCompression(options.compression)
+            store,
+            compression: this._createCompression(options.compression),
+            useKeyPrefix: store.constructor.name === 'KeyvRedis' ? false : true // see https://github.com/mikezaschka/cds-caching/issues/11
         };
     }
 
@@ -75,8 +106,10 @@ class CacheStoreManager {
     _createCompression(compressionType) {
         switch (compressionType) {
             case "lz4":
+                const KeyvLz4 = requireOptional('@keyv/compress-lz4', { feature: 'compression', value: 'lz4' });
                 return new KeyvLz4();
             case "gzip":
+                const KeyvGzip = requireOptional('@keyv/compress-gzip', { feature: 'compression', value: 'gzip' });
                 return new KeyvGzip();
             default:
                 return undefined;
@@ -93,7 +126,7 @@ class CacheStoreManager {
                 try {
                     await store.disconnect();
                 } catch (err) {
-                    console.error(`Error disconnecting from store for ${cacheName}:`, err);
+                    this.log.error(`Error disconnecting from store for ${cacheName}:`, err);
                 }
             }
         };

package/lib/support/RuntimeConfigurationManager.js

@@ -103,7 +103,8 @@ class RuntimeConfigurationManager {
             return {
                 metricsEnabled: cacheConfig?.metricsEnabled === true || cacheConfig?.metricsEnabled === 1 || false,
                 keyMetricsEnabled: cacheConfig?.keyMetricsEnabled === true || cacheConfig?.keyMetricsEnabled === 1 || false,
-                keyManagement
+                keyManagement,
+                throwOnErrors: this.options.throwOnErrors
             };
         } catch (error) {
             this.log.warn(`Failed to get runtime configuration for cache ${this.cacheName}:`, error);
@@ -114,7 +115,8 @@ class RuntimeConfigurationManager {
                     isUserAware: false,
                     isTenantAware: false,
                     isLocaleAware: false
-                }
+                },
+                throwOnErrors: this.options.throwOnErrors
             };
         }
     }

package/lib/support/optionalRequire.js

@@ -0,0 +1,45 @@
+function isMissingModuleError(err, packageName) {
+  const msg = String(err?.message || '');
+  return (
+    (err?.code === 'MODULE_NOT_FOUND' || err?.code === 'ERR_MODULE_NOT_FOUND') &&
+    (msg.includes(`'${packageName}'`) || msg.includes(`"${packageName}"`) || msg.includes(packageName))
+  );
+}
+
+function requireOptional(packageName, { feature, value } = {}) {
+  try {
+    const mod = require(packageName);
+    return mod?.default ?? mod;
+  } catch (err) {
+    if (!isMissingModuleError(err, packageName)) throw err;
+
+    const featureText = feature ? `${feature}="${value}" ` : '';
+    throw new Error(`cds-caching: ${featureText}requires installing "${packageName}" (npm i ${packageName})`);
+  }
+}
+
+function requireAnyOptional(packageNames, { feature, value } = {}) {
+  const missing = [];
+  for (const packageName of packageNames) {
+    try {
+      return require(packageName);
+    } catch (err) {
+      if (isMissingModuleError(err, packageName)) {
+        missing.push(packageName);
+        continue;
+      }
+      throw err;
+    }
+  }
+
+  const featureText = feature ? `${feature}="${value}" ` : '';
+  const pkgsQuoted = missing.map((p) => `"${p}"`).join(' or ');
+  const pkgsInstall = missing.map((p) => `npm i ${p}`).join(' OR ');
+  throw new Error(`cds-caching: ${featureText}requires installing ${pkgsQuoted} (${pkgsInstall})`);
+}
+
+module.exports = {
+  requireOptional,
+  requireAnyOptional
+};
+

package/lib/util.js

@@ -93,7 +93,7 @@ const bindEntity = async (service, entity) => {
 const createCacheEntry = async (cacheName, serviceConfig = {}) => {
     try {
         const db = await cds.connect.to('db');
-        const { Caches } = db.entities('plugin.cds_caching');
+        const { Caches } = cds.entities('plugin.cds_caching');
 
         // Check if cache entry already exists
         const existingCache = await db.read(Caches).where({ name: cacheName });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cds-caching",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "A caching plugin for SAP CAP applications",
   "repository": {
     "type": "git",
@@ -34,7 +34,33 @@
     "release": "release-it"
   },
   "peerDependencies": {
-    "@sap/cds": ">=8"
+    "@sap/cds": ">=8",
+    "@keyv/compress-gzip": "^2.0.3",
+    "@keyv/compress-lz4": "^1.0.1",
+    "@keyv/redis": "^5.0.0",
+    "@keyv/sqlite": "^4.0.5",
+    "@resolid/keyv-sqlite": "^4.0.5",
+    "@keyv/postgres": "^4.0.5"
+  },
+  "peerDependenciesMeta": {
+    "@keyv/redis": {
+      "optional": true
+    },
+    "@keyv/sqlite": {
+      "optional": true
+    },
+    "@keyv/compress-lz4": {
+      "optional": true
+    },
+    "@keyv/compress-gzip": {
+      "optional": true
+    },
+    "@resolid/keyv-sqlite": {
+      "optional": true
+    },
+    "@keyv/postgres": {
+      "optional": true
+    }
   },
   "workspaces": [
     ".",
@@ -43,20 +69,22 @@
     "examples/app"
   ],
   "dependencies": {
-    "@keyv/compress-gzip": "^2.0.3",
-    "@keyv/compress-lz4": "^1.0.0",
-    "@keyv/redis": "^4.5.0",
-    "@keyv/sqlite": "^4.0.5",
-    "keyv": "^5.3.4"
+    "keyv": "^5.6.0"
   },
   "devDependencies": {
-    "eslint": "^9.30.1",
+    "@cap-js/cds-test": "^0.4.1",
+    "@release-it/conventional-changelog": "^10.0.5",
+    "eslint": "^10.0.0",
     "husky": "^9.1.7",
-    "jest": "^30.0.4",
-    "release-it": "^19.0.3",
-    "@cap-js/cds-test": "^0.4.0"
+    "jest": "^30.2.0",
+    "release-it": "^19.2.4",
+    "@resolid/keyv-sqlite": "~5.0.1",
+    "@keyv/sqlite": "~4.0.8",
+    "@keyv/compress-lz4": "~1.0.1",
+    "@keyv/compress-gzip": "~2.0.3",
+    "@keyv/postgres": "~2.2.3"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   }
 }