cds-caching 1.2.1 → 1.3.1

package/lib/operations/CapOperations.js

@@ -1,4 +1,5 @@
 const TagResolver = require('../support/TagResolver');
+const telemetry = require('../support/Telemetry');
 /**
  * Manages CAP-specific cache operations
  */
@@ -36,10 +37,11 @@ class CapOperations {
                 stack: error.stack,
                 context: context
             });
-            
-            return { 
-                success: false, 
-                result: null, 
+            telemetry.recordError({ 'cache.error_operation': operationName });
+
+            return {
+                success: false,
+                result: null,
                 error: {
                     message: error.message,
                     operation: operationName,
@@ -51,13 +53,38 @@ class CapOperations {
 
     /**
      * Send a request with caching with read-through capabilities.
-     * 
+     *
      * @param {object} arg1 - the request object
      * @param {Service} service - the service to send the request to
      * @param {object} options - the options for the request
      * @returns {Promise<any>} - the result
      */
     async send(request, service, options) {
+        const tracer = telemetry.getTracer('cds-caching');
+        if (tracer) {
+            return tracer.startActiveSpan('cds-caching - send', async (span) => {
+                try {
+                    const result = await this._send(request, service, options);
+                    const hasCacheKey = typeof result.cacheKey === 'string' && result.cacheKey.length > 0;
+                    span.setAttribute('cache.hit', result.metadata.hit);
+                    if (hasCacheKey) span.setAttribute('cache.key', result.cacheKey);
+                    span.setAttribute('cache.operation', 'send');
+                    span.setAttribute('cache.operation_type', 'read_through');
+                    if (hasCacheKey && !result.metadata.hit) span.setAttribute('cache.ttl_ms', options?.ttl || 0);
+                    return result;
+                } catch (e) {
+                    span.setStatus({ code: telemetry.SpanStatusCode.ERROR, message: e.message });
+                    throw e;
+                } finally {
+                    span.end();
+                }
+            });
+        }
+        return this._send(request, service, options);
+    }
+
+    /** @private */
+    async _send(request, service, options) {
         const requestOptions = {
             ttl: 0,
             ...(options || {}),
@@ -140,9 +167,9 @@ class CapOperations {
             );
 
             if (getResult.success && getResult.result?.value !== undefined) {
-                return { 
-                    result: getResult.result.value, 
-                    cacheKey: key, 
+                return {
+                    result: getResult.result.value,
+                    cacheKey: key,
                     metadata: { hit: true, latency: latency },
                     cacheErrors: cacheErrors
                 };
@@ -153,7 +180,7 @@ class CapOperations {
         try {
             const response = await service.send(request);
             const totalLatency = this.getElapsedMs(startTime);
-            
+
             // Safely record miss statistics
             const missStatsResult = await this.safeCacheOperation(
                 () => this.statistics.recordMiss(totalLatency, key, metadata),
@@ -170,7 +197,7 @@ class CapOperations {
                 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()
             };
-            
+
             const setResult = await this.safeCacheOperation(
                 () => this.cache.send("SET", { key, value: wrappedValue, ttl: requestOptions.ttl || 0 }),
                 'set',
@@ -180,9 +207,9 @@ class CapOperations {
                 cacheErrors.push(setResult.error);
             }
 
-            return { 
-                result: response, 
-                cacheKey: key, 
+            return {
+                result: response,
+                cacheKey: key,
                 metadata: { hit: false, latency: totalLatency },
                 cacheErrors: cacheErrors
             };
@@ -206,6 +233,31 @@ class CapOperations {
      * @returns {Promise<any>} - the result
      */
     async run() {
+        const tracer = telemetry.getTracer('cds-caching');
+        if (tracer) {
+            return tracer.startActiveSpan('cds-caching - run', async (span) => {
+                try {
+                    const result = await this._run(...arguments);
+                    if (result?.cacheKey) {
+                        span.setAttribute('cache.hit', result.metadata?.hit ?? false);
+                        span.setAttribute('cache.key', result.cacheKey);
+                    }
+                    span.setAttribute('cache.operation', 'run');
+                    span.setAttribute('cache.operation_type', 'read_through');
+                    return result;
+                } catch (e) {
+                    span.setStatus({ code: telemetry.SpanStatusCode.ERROR, message: e.message });
+                    throw e;
+                } finally {
+                    span.end();
+                }
+            });
+        }
+        return this._run(...arguments);
+    }
+
+    /** @private */
+    async _run() {
         const arg1 = arguments[0];
         if (typeof arg1 === "object") {
             switch (arg1.constructor.name) {
@@ -226,14 +278,14 @@ class CapOperations {
 
                     // Track cache operation timing
                     const startTime = process.hrtime();
-                    
+
                     // 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);
@@ -249,11 +301,11 @@ class CapOperations {
                         if (!hitStatsResult.success) {
                             cacheErrors.push(hitStatsResult.error);
                         }
-                        
+
                         req.res?.setHeader('x-sap-cap-cache', "hit");
-                        return { 
-                            result: getResult.result.value, 
-                            cacheKey: req.cacheKey, 
+                        return {
+                            result: getResult.result.value,
+                            cacheKey: req.cacheKey,
                             metadata: { hit: true, latency: cacheLatency },
                             cacheErrors: cacheErrors
                         };
@@ -272,7 +324,7 @@ class CapOperations {
                             if (!missStatsResult.success) {
                                 cacheErrors.push(missStatsResult.error);
                             }
-                            
+
                             req.res?.setHeader('x-sap-cap-cache', "miss");
 
                             // Safely store in cache
@@ -281,7 +333,7 @@ class CapOperations {
                                 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',
@@ -291,10 +343,10 @@ class CapOperations {
                             if (!setResult.success) {
                                 cacheErrors.push(setResult.error);
                             }
-                            
-                            return { 
-                                result: response, 
-                                cacheKey: req.cacheKey, 
+
+                            return {
+                                result: response,
+                                cacheKey: req.cacheKey,
                                 metadata: { hit: false, latency: totalLatency },
                                 cacheErrors: cacheErrors
                             };
@@ -323,14 +375,14 @@ class CapOperations {
 
                         // Track cache operation timing
                         const startTime = process.hrtime();
-                        
+
                         // 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 = {
@@ -369,14 +421,14 @@ class CapOperations {
                                 '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
-                            };
+                                return {
+                                    result: getResult.result.value,
+                                    cacheKey: query.cacheKey,
+                                    metadata: { hit: true, latency: cacheLatency },
+                                    cacheErrors: cacheErrors
+                                };
                             }
                         }
 
@@ -401,7 +453,7 @@ class CapOperations {
                                 tags: this.tagResolver.resolveTags(options.tags, data, { ...query.params, hash: this.keyManager.createKey(query, { serviceName: srv?.name, template: '{hash}' }) }),
                                 timestamp: Date.now()
                             };
-                            
+
                             const setResult = await this.safeCacheOperation(
                                 () => this.cache.send("SET", { key: query.cacheKey, value: wrappedValue, ttl: options.ttl || 0 }),
                                 'set',
@@ -412,10 +464,10 @@ class CapOperations {
                             }
 
                             this.log.info('REEEESULT', { setResult, cacheErrors, wrappedValue });
-                            
-                            return { 
-                                result: data, 
-                                cacheKey: query.cacheKey, 
+
+                            return {
+                                result: data,
+                                cacheKey: query.cacheKey,
                                 metadata: { hit: false, latency: totalLatency },
                                 cacheErrors: cacheErrors
                             };
@@ -535,4 +587,4 @@ class CapOperations {
     }
 }
 
-module.exports = CapOperations; 
+module.exports = CapOperations;

package/lib/support/CacheStatisticsHandler.js

@@ -1,6 +1,8 @@
 const cds = require('@sap/cds');
 const StatisticsPersistenceManager = require('./StatisticsPersistenceManager');
+const telemetry = require('./Telemetry');
 const { query } = require('@sap/cds/lib/env/defaults');
+const { isPluginModelAvailable } = require('../util');
 
 /**
  * Class to handle all things caching statistics.
@@ -118,6 +120,9 @@ class CacheStatisticsHandler {
             this.recordKeyAccess(key, 'hit', { ...metadata, latency });
         }
 
+        // Emit OTel metric (independent of metricsEnabled)
+        telemetry.recordHit(latency, { 'cache.name': this.options.cache });
+
         // Log for debugging
         this.log.debug(`Recorded HIT for key: ${key}, latency: ${latency}ms, enabled: ${this.options.metricsEnabled}, keyMetrics: ${this.options.keyMetricsEnabled}`);
     }
@@ -141,6 +146,9 @@ class CacheStatisticsHandler {
             this.recordKeyAccess(key, 'miss', { ...metadata, latency });
         }
 
+        // Emit OTel metric (independent of metricsEnabled)
+        telemetry.recordMiss(latency, { 'cache.name': this.options.cache });
+
         // Log for debugging
         this.log.debug(`Recorded MISS for key: ${key}, latency: ${latency}ms, enabled: ${this.options.metricsEnabled}, keyMetrics: ${this.options.keyMetricsEnabled}`);
     }
@@ -164,6 +172,9 @@ class CacheStatisticsHandler {
             this.recordKeyAccess(key, 'set', { ...metadata, latency });
         }
 
+        // Emit OTel metric (independent of metricsEnabled)
+        telemetry.recordSet({ 'cache.name': this.options.cache });
+
         // Log for debugging
         this.log.debug(`Recorded SET for key: ${key}, latency: ${latency}ms, enabled: ${this.options.metricsEnabled}, keyMetrics: ${this.options.keyMetricsEnabled}`);
     }
@@ -187,6 +198,9 @@ class CacheStatisticsHandler {
             this.recordKeyAccess(key, 'delete', { ...metadata, latency });
         }
 
+        // Emit OTel metric (independent of metricsEnabled)
+        telemetry.recordDelete({ 'cache.name': this.options.cache });
+
         // Log for debugging
         this.log.debug(`Recorded DELETE for key: ${key}, latency: ${latency}ms, enabled: ${this.options.metricsEnabled}, keyMetrics: ${this.options.keyMetricsEnabled}`);
     }
@@ -210,6 +224,9 @@ class CacheStatisticsHandler {
             this.recordKeyAccess(key, 'nativeSet', metadata);
         }
 
+        // Emit OTel metric (independent of metricsEnabled)
+        telemetry.recordSet({ 'cache.name': this.options.cache });
+
         // Log for debugging
         this.log.debug(`Recorded NATIVE SET for key: ${key}, enabled: ${this.options.metricsEnabled}, keyMetrics: ${this.options.keyMetricsEnabled}`);
     }
@@ -257,6 +274,9 @@ class CacheStatisticsHandler {
             this.recordKeyAccess(key, 'nativeDelete', metadata);
         }
 
+        // Emit OTel metric (independent of metricsEnabled)
+        telemetry.recordDelete({ 'cache.name': this.options.cache });
+
         // Log for debugging
         this.log.debug(`Recorded NATIVE DELETE for key: ${key}, enabled: ${this.options.metricsEnabled}, keyMetrics: ${this.options.keyMetricsEnabled}`);
     }
@@ -301,6 +321,9 @@ class CacheStatisticsHandler {
         if (this.options.metricsEnabled) {
             this.stats.current.errors++;
         }
+
+        // Emit OTel metric (independent of metricsEnabled)
+        telemetry.recordError({ 'cache.name': this.options.cache });
     }
 
     /**
@@ -652,8 +675,8 @@ class CacheStatisticsHandler {
      * @returns {Array} - array of all tracked keys with enhanced data
      */
     async getAllTrackedKeys() {
-        // If key metrics is enabled, try to get from database first
-        if (this.options.keyMetricsEnabled) {
+        // If key metrics is enabled and the model is available, try to get from database first
+        if (this.options.keyMetricsEnabled && isPluginModelAvailable()) {
             try {
                 const dbKeys = await SELECT.from("plugin_cds_caching_KeyMetrics")
                     .where({ cache: this.options.cache });
@@ -729,8 +752,8 @@ class CacheStatisticsHandler {
      * @returns {object|null} - detailed key information or null if not found
      */
     async getKeyDetails(keyName) {
-        // If key metrics is enabled, try to get from database first
-        if (this.options.keyMetricsEnabled) {
+        // If key metrics is enabled and the model is available, try to get from database first
+        if (this.options.keyMetricsEnabled && isPluginModelAvailable()) {
             try {
                 const keyDetails = await SELECT.one.from("plugin_cds_caching_KeyMetrics")
                     .where({ cache: this.options.cache, keyName: keyName });
@@ -938,7 +961,7 @@ class CacheStatisticsHandler {
     }
 
     async getMetrics(period = 'hourly', from, to) {
-        if (!this.options.metricsEnabled) return null;
+        if (!this.options.metricsEnabled || !isPluginModelAvailable()) return null;
 
         const query = SELECT.from("plugin_cds_caching_Metrics")
             .where({ period: period });
@@ -952,7 +975,7 @@ class CacheStatisticsHandler {
     }
 
     async getKeyMetrics(key, from, to) {
-        if (!this.options.keyMetricsEnabled) return null;
+        if (!this.options.keyMetricsEnabled || !isPluginModelAvailable()) return null;
         const query = SELECT.from("plugin_cds_caching_KeyMetrics")
             .where({ cache: this.options.cache, keyName: key });
 
@@ -1093,14 +1116,16 @@ class CacheStatisticsHandler {
     }
 
     async clearMetrics() {
-        await this.persistenceManager.deleteMetrics();
-        // Also reset the current stats
+        if (isPluginModelAvailable()) {
+            await this.persistenceManager.deleteMetrics();
+        }
         this.resetCurrentStats();
     }
 
     async clearKeyMetrics() {
-        await this.persistenceManager.deleteKeyMetrics();
-        // Also reset the current stats
+        if (isPluginModelAvailable()) {
+            await this.persistenceManager.deleteKeyMetrics();
+        }
         this.resetCurrentStats();
     }
 

package/lib/support/CacheStoreManager.js

@@ -1,5 +1,7 @@
 const { Keyv } = require('keyv');
 const { requireOptional, requireAnyOptional } = require('./optionalRequire');
+const KeyvCDS = require('./KeyvCDS');
+const { isMultitenantMode } = require('./MultitenancyDetector');
 
 /**
  * Manages cache store initialization and configuration
@@ -81,6 +83,33 @@ class CacheStoreManager {
                     ...(options.credentials?.table ? { table: options.credentials?.table } : {}),
                     ...{ throwOnConnectErrors: options.throwOnErrors, useKeyPrefix: false, throwOnErrors: options.throwOnErrors }
                 });
+            case "cds":
+                return new KeyvCDS(options);
+            case "hana":
+                if (isMultitenantMode()) {
+                    this.log.warn(
+                        `Store 'hana' uses direct connections that bypass CAP's tenant-aware connection management. ` +
+                        `Consider using store: 'cds' instead for multi-tenant deployments.`
+                    );
+                }
+                const KeyvHana = requireOptional('keyv-hana', { feature: 'store', value: 'hana' });
+                // BTP HANA service bindings use "user"/"password"; keyv-hana expects "uid"/"pwd"
+                return new KeyvHana({
+                    host: options.credentials?.host,
+                    port: options.credentials?.port,
+                    uid: options.credentials?.uid || options.credentials?.user,
+                    pwd: options.credentials?.pwd || options.credentials?.password,
+                    schema: options.credentials?.schema,
+                    table: options.credentials?.table || 'KEYV',
+                    keySize: options.credentials?.keySize || 255,
+                    createTable: options.credentials?.createTable ?? false,
+                    connectOptions: {
+                        ...(options.credentials?.certificate ? { ca: options.credentials.certificate } : {}),
+                        ...(options.credentials?.encrypt !== undefined ? { encrypt: options.credentials.encrypt } : {}),
+                        ...(options.credentials?.sslValidateCertificate !== undefined ? { sslValidateCertificate: options.credentials.sslValidateCertificate } : {}),
+                        ...options.credentials?.connectOptions,
+                    },
+                });
             default:
                 return new Map();
         }

package/lib/support/KeyManager.js

@@ -78,13 +78,34 @@ class KeyManager {
                 case "Request":
                 case "NoaRequest":
                 case "ODataRequest":
-                    // Only hash the request information, not user/tenant/locale
+                    // Hash request information including the HTTP URL which
+                    // contains $filter/$select/$orderby query parameters.
+                    //
+                    // Why req.query (CQN) is unreliable for hashing:
+                    // NoaRequest ("New OData Adapter Request", defined in
+                    // @sap/cds/libx/odata/ODataAdapter.js) carries cds.ql
+                    // query objects where SELECT.where lives on the prototype
+                    // chain, not as an own property. JSON.stringify only
+                    // serializes own enumerable properties, so the where clause
+                    // from $filter is silently dropped — two requests that
+                    // differ only by $filter produce the same hash.
+                    // This does NOT affect programmatic CQL (e.g.
+                    // SELECT.from(Entity).where(...)) where `where` is an own
+                    // property. It only affects CQN built from OData URL
+                    // parsing in the adapter pipeline.
+                    //
+                    // The HTTP URL (req._.req.url / req.http.req.url) always
+                    // contains the full query string as a plain string and is
+                    // the reliable source for all OData query options. When a
+                    // URL is available it supersedes req.query.
+                    const url = this.normalizeUrl(keyOrObject._?.req?.url || keyOrObject.http?.req?.url);
                     return this.createHash({
                         method: keyOrObject.method,
                         path: keyOrObject.path || keyOrObject.http?.req?.path,
+                        url,
                         data: keyOrObject.data,
                         params: keyOrObject.params,
-                        query: keyOrObject.query,
+                        query: url ? undefined : keyOrObject.query,
                         event: keyOrObject.event,
                         target: keyOrObject.target?.name
                     });
@@ -105,6 +126,23 @@ class KeyManager {
         return this.createHash({ content: keyOrObject });
     }
 
+    /**
+     * Normalize a URL by sorting its query parameters alphabetically by key.
+     * Ensures the same parameters in different order produce the same cache key.
+     * @param {string} url - URL string to normalize
+     * @returns {string|undefined} - Normalized URL or undefined if input is falsy
+     */
+    normalizeUrl(url) {
+        if (!url) return undefined;
+        try {
+            const urlObj = new URL(url, 'http://localhost');
+            urlObj.searchParams.sort();
+            return urlObj.pathname + (urlObj.searchParams.size ? '?' + urlObj.searchParams.toString() : '');
+        } catch {
+            return url;
+        }
+    }
+
     /**
      * Serialize function arguments for cache key generation
      * @param {any} arg - argument to serialize

package/lib/support/KeyvCDS.js

@@ -0,0 +1,149 @@
+const cds = require('@sap/cds');
+
+/**
+ * Keyv-compatible store adapter that uses CAP's managed DB connection (CQL).
+ *
+ * Benefits:
+ * - Works with any DB backend CAP supports (HANA, PostgreSQL, SQLite)
+ * - In MTX mode, automatically routes to the correct tenant's HDI container
+ * - No separate credentials needed — reuses the app's existing DB connection
+ */
+class KeyvCDS {
+    constructor(options = {}) {
+        this.log = cds.log('cds-caching');
+        this._entity = null;
+        // Keyv checks store.opts.dialect to enable iterator support
+        this.opts = { dialect: 'sqlite', url: '' };
+    }
+
+    /**
+     * Lazily resolve the CacheStore entity and DB service.
+     * Both are only available after the CDS server has fully bootstrapped.
+     * @private
+     */
+    async _getDB() {
+        if (!cds.db) await cds.connect.to('db');
+        const db = cds.db;
+        if (!this._entity) {
+            this._entity = cds.entities('plugin.cds_caching')?.CacheStore;
+        }
+        return { db, entity: this._entity };
+    }
+
+    /**
+     * Get a value by key.
+     * Returns undefined if the key does not exist or is expired.
+     */
+    async get(key) {
+        try {
+            const { db, entity } = await this._getDB();
+            if (!db || !entity) return undefined;
+            const row = await db.run(SELECT.one.from(entity).where({ ID: key }));
+            if (!row) return undefined;
+            if (row.expiresAt && row.expiresAt <= Date.now()) {
+                await db.run(DELETE.from(entity).where({ ID: key }));
+                return undefined;
+            }
+            return row.value;
+        } catch (error) {
+            this.log.error(`KeyvCDS get error for key ${key}:`, error);
+            return undefined;
+        }
+    }
+
+    /**
+     * Set a key-value pair with optional TTL (in milliseconds).
+     */
+    async set(key, value, ttl) {
+        try {
+            const { db, entity } = await this._getDB();
+            if (!db || !entity) return;
+            const expiresAt = ttl ? Date.now() + ttl : null;
+            const existing = await db.run(SELECT.one.from(entity).columns('ID').where({ ID: key }));
+            if (existing) {
+                await db.run(UPDATE(entity).set({ value, expiresAt }).where({ ID: key }));
+            } else {
+                await db.run(INSERT.into(entity).entries({ ID: key, value, expiresAt }));
+            }
+        } catch (error) {
+            this.log.error(`KeyvCDS set error for key ${key}:`, error);
+        }
+    }
+
+    /**
+     * Delete a key. Returns true if the key existed, false otherwise.
+     */
+    async delete(key) {
+        try {
+            const { db, entity } = await this._getDB();
+            if (!db || !entity) return false;
+            const result = await db.run(DELETE.from(entity).where({ ID: key }));
+            return !!result;
+        } catch (error) {
+            this.log.error(`KeyvCDS delete error for key ${key}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Clear all entries from the store.
+     */
+    async clear() {
+        try {
+            const { db, entity } = await this._getDB();
+            if (!db || !entity) return;
+            await db.run(DELETE.from(entity));
+        } catch (error) {
+            this.log.error('KeyvCDS clear error:', error);
+        }
+    }
+
+    /**
+     * Check if a key exists and is not expired.
+     */
+    async has(key) {
+        try {
+            const { db, entity } = await this._getDB();
+            if (!db || !entity) return false;
+            const row = await db.run(SELECT.one.from(entity).columns('ID', 'expiresAt').where({ ID: key }));
+            if (!row) return false;
+            if (row.expiresAt && row.expiresAt <= Date.now()) {
+                await db.run(DELETE.from(entity).where({ ID: key }));
+                return false;
+            }
+            return true;
+        } catch (error) {
+            this.log.error(`KeyvCDS has error for key ${key}:`, error);
+            return false;
+        }
+    }
+
+    /**
+     * Async iterator over all non-expired [key, value] pairs.
+     */
+    async *iterator() {
+        try {
+            const { db, entity } = await this._getDB();
+            if (!db || !entity) return;
+            const rows = await db.run(SELECT.from(entity));
+            const now = Date.now();
+            for (const row of rows) {
+                if (row.expiresAt && row.expiresAt <= now) {
+                    continue;
+                }
+                yield [row.ID, row.value];
+            }
+        } catch (error) {
+            this.log.error('KeyvCDS iterator error:', error);
+        }
+    }
+
+    /**
+     * No-op — CAP manages the DB connection lifecycle.
+     */
+    async disconnect() {
+        // Nothing to do; the DB connection is managed by the CAP runtime
+    }
+}
+
+module.exports = KeyvCDS;

package/lib/support/MultitenancyDetector.js

@@ -0,0 +1,25 @@
+const cds = require('@sap/cds');
+
+/**
+ * Detects whether the application is running in multi-tenant mode (MTX)
+ * and whether a tenant context is currently available.
+ */
+
+/**
+ * Check if the application is configured for multi-tenancy.
+ * Returns true when @sap/cds-mtxs sets cds.env.requires.multitenancy.
+ * @returns {boolean}
+ */
+function isMultitenantMode() {
+    return !!(cds.env.requires?.multitenancy || cds.env.requires?.['cds.xt.SaasProvisioningService']);
+}
+
+/**
+ * Check if a tenant context is currently available (i.e., we are inside a tenant request).
+ * @returns {boolean}
+ */
+function hasTenantContext() {
+    return !!cds.context?.tenant;
+}
+
+module.exports = { isMultitenantMode, hasTenantContext };