cds-caching 0.3.3 → 1.1.0

package/lib/support/CacheStoreManager.js

@@ -0,0 +1,120 @@
+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');
+
+/**
+ * Manages cache store initialization and configuration
+ */
+class CacheStoreManager {
+    constructor(options = {}) {
+        this.options = options;
+        this.log = cds.log('cds-caching')
+    }
+
+    /**
+     * Create and configure the cache store based on options
+     * @param {object} options - Cache configuration options
+     * @param {string} cacheName - Name of the cache for logging
+     * @returns {object} - Configured Keyv instance and cleanup function
+     */
+    createStore(options, cacheName) {
+        const store = this._createStoreInstance(options);
+        const cacheOptions = this._createCacheOptions(options, cacheName);
+        const cache = new Keyv(cacheOptions);
+        cache.throwOnErrors = options.throwOnErrors;
+
+        // Set up error handling
+        cache.on('error', err => {
+            this.log.error(`Cache error for ${cacheName}:`, err);
+        });
+
+        // Set up cleanup function
+        const cleanup = this._createCleanupFunction(store, cacheName);
+
+        return { cache, cleanup };
+    }
+
+    /**
+     * Create the appropriate store instance based on configuration
+     * @private
+     */
+    _createStoreInstance(options) {
+        switch (options.store) {
+            case "sqlite":
+                return new KeyvSqlite({
+                    url: options.credentials?.url,
+                    table: options.credentials?.table || 'cache',
+                    busyTimeout: options.credentials?.busyTimeout || 10000
+                });
+            case "redis":
+                const store = new KeyvRedis({
+                    ...options.credentials,
+                    ...(options.credentials?.uri ? { url: options.credentials?.uri } : {}),
+                    ...{ throwOnConnectErrors: options.throwOnErrors, useKeyPrefix: false, throwOnErrors: options.throwOnErrors }
+                });
+
+                if (options.throwOnErrors) {
+                    store.throwOnConnectErrors = false; // We want to handle the errors ourselves
+                    store.throwOnErrors = true;
+                    const redisClient = store.client;
+                    if (redisClient.options) {
+                        redisClient.options.disableOfflineQueue = true;
+                        if (redisClient.options.socket) {
+                            redisClient.options.socket.reconnectStrategy = false;
+                        }
+                    }
+                }
+
+                return store;
+            default:
+                return new Map();
+        }
+    }
+
+    /**
+     * Create cache options object
+     * @private
+     */
+    _createCacheOptions(options, cacheName) {
+        return {
+            namespace: options.namespace || cacheName,
+            store: this._createStoreInstance(options),
+            compression: this._createCompression(options.compression)
+        };
+    }
+
+    /**
+     * Create compression instance if specified
+     * @private
+     */
+    _createCompression(compressionType) {
+        switch (compressionType) {
+            case "lz4":
+                return new KeyvLz4();
+            case "gzip":
+                return new KeyvGzip();
+            default:
+                return undefined;
+        }
+    }
+
+    /**
+     * Create cleanup function for the store
+     * @private
+     */
+    _createCleanupFunction(store, cacheName) {
+        return async () => {
+            if (store?.disconnect) {
+                try {
+                    await store.disconnect();
+                } catch (err) {
+                    this.log.error(`Error disconnecting from store for ${cacheName}:`, err);
+                }
+            }
+        };
+    }
+}
+
+module.exports = CacheStoreManager; 

package/lib/support/KeyManager.js

@@ -0,0 +1,132 @@
+const crypto = require('crypto');
+
+/**
+ * Manages cache key generation and creation
+ */
+class KeyManager {
+    constructor(runtimeConfigManager) {
+        this.createHash = (data) => crypto.createHash('md5').update(JSON.stringify(data)).digest('hex');
+        this.runtimeConfigManager = runtimeConfigManager;
+    }
+
+    /**
+     * Create a cache key from various input types
+     * @param {string|object} keyOrObject - Key string or object to create key from
+     * @param {object} additionalContext - Additional context to include in the key
+     * @param {string} key - Optional key string to override default
+     * @returns {string} - Generated cache key
+     */
+    createKey(keyOrObject, additionalContext = {}, key = null) {
+        // Use provided key or get default from configuration
+        const keyTemplate = key || this.runtimeConfigManager.getDefaultKeyTemplate();
+        
+        // Create content hash from the object being cached
+        let contentHash = '';
+        if (typeof keyOrObject === "string") {
+            // For strings, use the string itself as the hash
+            contentHash = keyOrObject;
+        } else if (typeof keyOrObject === "object" && keyOrObject !== null) {
+            contentHash = this.createContentHash(keyOrObject);
+            // If contentHash is undefined, the object should not be cached
+            if (contentHash === undefined) {
+                return undefined;
+            }
+        } else {
+            contentHash = this.createHash({ content: keyOrObject });
+        }
+
+        // Get context values
+        const contextVars = {
+            tenant: additionalContext.tenant || cds.context?.tenant || 'global',
+            user: additionalContext.user || (cds.context?.user?.id || cds.context?.user) || 'anonymous',
+            locale: additionalContext.locale || cds.context?.locale || 'en',
+            hash: contentHash,
+            baseKey: additionalContext.baseKey || ''
+        };
+
+        // Handle argument placeholders for async functions
+        if (additionalContext.args && Array.isArray(additionalContext.args)) {
+            additionalContext.args.forEach((arg, index) => {
+                contextVars[`args[${index}]`] = this.serializeArgument(arg);
+            });
+        }
+
+        // Replace placeholders in template
+        return keyTemplate.replace(
+            /\{(tenant|user|locale|hash|baseKey|args\[\d+\])\}/g,
+            (match, variable) => {
+                if (variable.startsWith('args[')) {
+                    return contextVars[variable] || '';
+                }
+                return contextVars[variable] || '';
+            }
+        );
+    }
+
+    /**
+     * Create a hash from the content being cached (without context)
+     * @param {object} keyOrObject - Object to create hash from
+     * @returns {string} - Generated hash
+     */
+    createContentHash(keyOrObject) {
+        if (typeof keyOrObject === "string") {
+            return this.createHash({ content: keyOrObject });
+        }
+
+        if (typeof keyOrObject === "object" && keyOrObject !== null) {
+            switch (keyOrObject.constructor.name) {
+                case "Request":
+                case "NoaRequest":
+                case "ODataRequest":
+                    // Only hash the request information, not user/tenant/locale
+                    return this.createHash({
+                        method: keyOrObject.method,
+                        path: keyOrObject.path || keyOrObject.http?.req?.path,
+                        data: keyOrObject.data,
+                        params: keyOrObject.params,
+                        query: keyOrObject.query,
+                        event: keyOrObject.event,
+                        target: keyOrObject.target?.name
+                    });
+                case "cds.ql":
+                    if (keyOrObject.SELECT) {
+                        // Only hash the query structure, exclude cacheKey property
+                        const { cacheKey, ...queryWithoutCacheKey } = keyOrObject;
+                        return this.createHash({ query: queryWithoutCacheKey });
+                    } else {
+                        // Non-SELECT queries should not be cached
+                        return undefined;
+                    }
+                default:
+                    return this.createHash({ content: keyOrObject });
+            }
+        }
+
+        return this.createHash({ content: keyOrObject });
+    }
+
+    /**
+     * Serialize function arguments for cache key generation
+     * @param {any} arg - argument to serialize
+     * @returns {string} serialized argument
+     */
+    serializeArgument(arg) {
+        if (arg === null) return 'null';
+        if (arg === undefined) return 'undefined';
+        if (typeof arg === 'string') return arg;
+        if (typeof arg === 'number') return arg.toString();
+        if (typeof arg === 'boolean') return arg.toString();
+        if (Array.isArray(arg)) return `[${arg.map(a => this.serializeArgument(a)).join(',')}]`;
+        if (typeof arg === 'object') {
+            // For objects, create a stable string representation
+            try {
+                return this.createHash(arg);
+            } catch (e) {
+                return 'object';
+            }
+        }
+        return String(arg);
+    }
+}
+
+module.exports = KeyManager; 

package/lib/support/RuntimeConfigurationManager.js

@@ -0,0 +1,148 @@
+const cds = require('@sap/cds');
+
+/**
+ * Manages runtime configuration for cache services
+ */
+class RuntimeConfigurationManager {
+    constructor(cacheName, log, options = {}) {
+        this.cacheName = cacheName;
+        this.log = log || cds.log('cds-caching');
+        this.options = options;
+    }
+
+    /**
+     * Load runtime configuration from database and package.json
+     * @returns {Promise<object>} Configuration object
+     */
+    async loadRuntimeConfiguration() {
+        try {
+            this.log.info(`Loading runtime configuration for cache ${this.cacheName}...`);
+
+            const cacheConfig = await SELECT.one.from("plugin_cds_caching_Caches")
+                .where({ name: this.cacheName });
+
+            // Get key management configuration from package.json options (defaults to false)
+            const keyManagementConfig = this.options?.keyManagement || {};
+            const keyManagement = {
+                isUserAware: keyManagementConfig.isUserAware === true, // Default to false
+                isTenantAware: keyManagementConfig.isTenantAware === true, // Default to false
+                isLocaleAware: keyManagementConfig.isLocaleAware === true // Default to false
+            };
+
+            if (cacheConfig) {
+                return {
+                    enableKeyTracking: cacheConfig.enableKeyTracking || false,
+                    enableStatistics: cacheConfig.enableStatistics || false,
+                    keyManagement
+                };
+            } else {
+                this.log.warn(`No cache configuration found for cache ${this.cacheName}`);
+                return {
+                    enableKeyTracking: false,
+                    enableStatistics: false,
+                    keyManagement
+                };
+            }
+        } catch (error) {
+            this.log.warn(`Failed to load runtime configuration for cache ${this.cacheName}:`, error);
+            return {
+                enableKeyTracking: false,
+                enableStatistics: false,
+                keyManagement: {
+                    isUserAware: false,
+                    isTenantAware: false,
+                    isLocaleAware: false
+                }
+            };
+        }
+    }
+
+    /**
+     * Update metrics enabled status in database
+     * @param {boolean} enabled - Whether metrics should be enabled
+     */
+    async setMetricsEnabled(enabled) {
+        await UPDATE('plugin_cds_caching_Caches')
+            .set({ metricsEnabled: enabled })
+            .where({ name: this.cacheName });
+
+        this.log.debug(`Statistics ${enabled ? 'enabled' : 'disabled'} for cache ${this.cacheName}`);
+    }
+
+    /**
+     * Update key metrics enabled status in database
+     * @param {boolean} enabled - Whether key metrics should be enabled
+     */
+    async setKeyMetricsEnabled(enabled) {
+        await UPDATE('plugin_cds_caching_Caches')
+            .set({ keyMetricsEnabled: enabled })
+            .where({ name: this.cacheName });
+
+        this.log.debug(`Key tracking ${enabled ? 'enabled' : 'disabled'} for cache ${this.cacheName}`);
+    }
+
+
+
+    /**
+     * Get current runtime configuration
+     * @returns {Promise<object>} Current configuration
+     */
+    async getRuntimeConfiguration() {
+        try {
+            const cacheConfig = await SELECT.one.from("plugin_cds_caching_Caches")
+                .where({ name: this.cacheName });
+
+            // Get key management configuration from package.json options (defaults to false)
+            const keyManagementConfig = this.options?.keyManagement || {};
+            const keyManagement = {
+                isUserAware: keyManagementConfig.isUserAware === true,
+                isTenantAware: keyManagementConfig.isTenantAware === true,
+                isLocaleAware: keyManagementConfig.isLocaleAware === true
+            };
+
+            return {
+                metricsEnabled: cacheConfig?.metricsEnabled === true || cacheConfig?.metricsEnabled === 1 || false,
+                keyMetricsEnabled: cacheConfig?.keyMetricsEnabled === true || cacheConfig?.keyMetricsEnabled === 1 || false,
+                keyManagement,
+                throwOnErrors: this.options.throwOnErrors
+            };
+        } catch (error) {
+            this.log.warn(`Failed to get runtime configuration for cache ${this.cacheName}:`, error);
+            return {
+                metricsEnabled: false,
+                keyMetricsEnabled: false,
+                keyManagement: {
+                    isUserAware: false,
+                    isTenantAware: false,
+                    isLocaleAware: false
+                },
+                throwOnErrors: this.options.throwOnErrors
+            };
+        }
+    }
+
+    /**
+     * Get default key template based on runtime configuration
+     * @returns {string} Default template string
+     */
+    getDefaultKeyTemplate() {
+        // Get key management configuration from package.json options (defaults to false)
+        const keyManagementConfig = this.options?.keyManagement || {};
+        const keyManagement = {
+            isUserAware: keyManagementConfig.isUserAware === true, // Default to false
+            isTenantAware: keyManagementConfig.isTenantAware === true, // Default to false
+            isLocaleAware: keyManagementConfig.isLocaleAware === true // Default to false
+        };
+        
+        const parts = [];
+        
+        if (keyManagement.isTenantAware) parts.push('{tenant}');
+        if (keyManagement.isUserAware) parts.push('{user}');
+        if (keyManagement.isLocaleAware) parts.push('{locale}');
+        parts.push('{hash}');
+        
+        return parts.join(':');
+    }
+}
+
+module.exports = RuntimeConfigurationManager;