@memberjunction/generic-database-provider 5.36.0 → 5.38.0

package/dist/GenericDatabaseProvider.js

@@ -15,7 +15,7 @@
  *
  * @module @memberjunction/generic-database-provider
  */
-import { DatabaseProviderBase, EntityFieldTSType, EntityPermissionType, InMemoryLocalStorageProvider, Metadata, RunView, QueryInfo, LocalCacheManager, LogError, LogStatus, LogStatusEx, StripStopWords, QueryCacheManager, AfterKeyNotSupportedError, IsKeysetPaginationOrderableType, } from '@memberjunction/core';
+import { DatabaseProviderBase, EntityFieldTSType, EntityPermissionType, InMemoryLocalStorageProvider, Metadata, RunView, LocalCacheManager, LogError, LogStatus, LogStatusEx, StripStopWords, AfterKeyNotSupportedError, IsKeysetPaginationOrderableType, } from '@memberjunction/core';
 import { MJGlobal, SQLExpressionValidator, UUIDsEqual } from '@memberjunction/global';
 import { QueryPagingEngine } from './queryPagingEngine.js';
 // QueryParameterProcessor is now called internally by RenderPipeline
@@ -43,14 +43,6 @@ const GEO_EXTENDED_TYPES = new Set([
     'GeoCountry', 'GeoPostalCode', 'GeoLatitude', 'GeoLongitude'
 ]);
 export class GenericDatabaseProvider extends DatabaseProviderBase {
-    constructor() {
-        // Composition engine is now owned by RenderPipeline
-        super(...arguments);
-        /**************************************************************************/
-        // InternalRunQuery — Shared Pipeline Implementation
-        /**************************************************************************/
-        this._queryCacheInitialized = false;
-    }
     /**
      * Returns the active local storage provider, lazily creating an
      * {@link InMemoryLocalStorageProvider} if none has been set.
@@ -1128,13 +1120,11 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
                 whereSQL = bHasWhere ? `${whereSQL} AND (${sExcludeSQL})` : `(${sExcludeSQL})`;
                 bHasWhere = true;
             }
-            // 5. Row-Level Security
-            if (!entityInfo.UserExemptFromRowLevelSecurity(user, EntityPermissionType.Read)) {
-                const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, EntityPermissionType.Read, '');
-                if (rlsWhereClause && rlsWhereClause.length > 0) {
-                    whereSQL = bHasWhere ? `${whereSQL} AND (${rlsWhereClause})` : `(${rlsWhereClause})`;
-                    bHasWhere = true;
-                }
+            // 5. Row-Level Security (exemption check is centralized in GetUserRowLevelSecurityWhereClause)
+            const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, EntityPermissionType.Read, '');
+            if (rlsWhereClause && rlsWhereClause.length > 0) {
+                whereSQL = bHasWhere ? `${whereSQL} AND (${rlsWhereClause})` : `(${rlsWhereClause})`;
+                bHasWhere = true;
             }
             // 6. Keyset (AfterKey) seek predicate — only on the data query, NOT the count query.
             //    The count is the total matching the user-visible filters; the seek predicate is
@@ -1750,11 +1740,9 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
                 bHasWhere = true;
             }
         }
-        if (!entityInfo.UserExemptFromRowLevelSecurity(user, EntityPermissionType.Read)) {
-            const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, EntityPermissionType.Read, '');
-            if (rlsWhereClause && rlsWhereClause.length > 0) {
-                whereSQL = bHasWhere ? `${whereSQL} AND (${rlsWhereClause})` : `(${rlsWhereClause})`;
-            }
+        const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, EntityPermissionType.Read, '');
+        if (rlsWhereClause && rlsWhereClause.length > 0) {
+            whereSQL = bHasWhere ? `${whereSQL} AND (${rlsWhereClause})` : `(${rlsWhereClause})`;
         }
         return whereSQL;
     }
@@ -1960,45 +1948,45 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
             const errorResults = [];
             for (let i = 0; i < params.length; i++) {
                 const item = params[i];
-                const queryInfo = this.resolveQueryInfo(item.params);
-                if (!queryInfo) {
+                const query = this.resolveQuery(item.params);
+                if (!query) {
                     errorResults.push({ queryIndex: i, queryId: item.params.QueryID || '', status: 'error', errorMessage: `Query not found: ${item.params.QueryID || item.params.QueryName}` });
                     continue;
                 }
-                if (!queryInfo.UserCanRun(user)) {
-                    errorResults.push({ queryIndex: i, queryId: queryInfo.ID, status: 'error', errorMessage: `User does not have permission to run query: ${queryInfo.Name}` });
+                if (!query.UserCanRun(user)) {
+                    errorResults.push({ queryIndex: i, queryId: query.ID, status: 'error', errorMessage: `User does not have permission to run query: ${query.Name}` });
                     continue;
                 }
                 if (!item.cacheStatus) {
                     itemsWithoutCacheCheck.push({ index: i, item });
                     continue;
                 }
-                if (!queryInfo.CacheValidationSQL) {
-                    itemsWithoutValidationSQL.push({ index: i, item, queryInfo });
+                if (!query.CacheValidationSQL) {
+                    itemsWithoutValidationSQL.push({ index: i, item, query });
                     continue;
                 }
-                itemsNeedingCacheCheck.push({ index: i, item, queryInfo });
+                itemsNeedingCacheCheck.push({ index: i, item, query });
             }
             const cacheStatusResults = await this.getBatchedQueryCacheStatus(itemsNeedingCacheCheck, contextUser);
             const staleItems = [];
             const currentResults = [];
-            for (const { index, item, queryInfo } of itemsNeedingCacheCheck) {
+            for (const { index, item, query } of itemsNeedingCacheCheck) {
                 const serverStatus = cacheStatusResults.get(index);
                 if (!serverStatus || !serverStatus.success) {
-                    errorResults.push({ queryIndex: index, queryId: queryInfo.ID, status: 'error', errorMessage: serverStatus?.errorMessage || 'Failed to get cache status' });
+                    errorResults.push({ queryIndex: index, queryId: query.ID, status: 'error', errorMessage: serverStatus?.errorMessage || 'Failed to get cache status' });
                     continue;
                 }
                 if (this.isCacheCurrent(item.cacheStatus, serverStatus)) {
-                    currentResults.push({ queryIndex: index, queryId: queryInfo.ID, status: 'current' });
+                    currentResults.push({ queryIndex: index, queryId: query.ID, status: 'current' });
                 }
                 else {
-                    staleItems.push({ index, params: item.params, queryInfo });
+                    staleItems.push({ index, params: item.params, query });
                 }
             }
             const fullQueryPromises = [
                 ...itemsWithoutCacheCheck.map(({ index, item }) => this.runFullQueryAndReturnForQuery(item.params, index, 'stale', contextUser)),
-                ...itemsWithoutValidationSQL.map(({ index, item, queryInfo }) => this.runFullQueryAndReturnForQuery(item.params, index, 'no_validation', contextUser, queryInfo.ID)),
-                ...staleItems.map(({ index, params: queryParams, queryInfo }) => this.runFullQueryAndReturnForQuery(queryParams, index, 'stale', contextUser, queryInfo.ID)),
+                ...itemsWithoutValidationSQL.map(({ index, item, query }) => this.runFullQueryAndReturnForQuery(item.params, index, 'no_validation', contextUser, query.ID)),
+                ...staleItems.map(({ index, params: queryParams, query }) => this.runFullQueryAndReturnForQuery(queryParams, index, 'stale', contextUser, query.ID)),
             ];
             const fullQueryResults = await Promise.all(fullQueryPromises);
             const allResults = [...errorResults, ...currentResults, ...fullQueryResults];
@@ -2011,69 +1999,42 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
         }
     }
     /**
-     * Resolves QueryInfo from RunQueryParams (by ID or Name+CategoryPath).
-     * Tries QueryEngine first for fresh data, falls back to ProviderBase cache.
-     */
-    resolveQueryInfo(params) {
-        const freshEntity = this.findQueryInEngine(params.QueryID, params.QueryName, params.CategoryID, params.CategoryPath);
-        if (freshEntity)
-            return this.refreshQueryInfoFromEntity(freshEntity);
-        if (params.QueryID)
-            return this.Queries.find(q => UUIDsEqual(q.ID, params.QueryID));
-        if (params.QueryName) {
-            const matchingQueries = this.Queries.filter(q => q.Name.trim().toLowerCase() === params.QueryName?.trim().toLowerCase());
-            if (matchingQueries.length === 0)
-                return undefined;
-            if (matchingQueries.length === 1)
-                return matchingQueries[0];
-            if (params.CategoryPath) {
-                const byPath = matchingQueries.find(q => q.CategoryPath.toLowerCase() === params.CategoryPath?.toLowerCase());
-                if (byPath)
-                    return byPath;
-            }
-            if (params.CategoryID) {
-                const byId = matchingQueries.find(q => UUIDsEqual(q.CategoryID, params.CategoryID));
-                if (byId)
-                    return byId;
-            }
-            return matchingQueries[0];
-        }
-        return undefined;
-    }
-    /**
-     * Searches QueryEngine for a fresh query entity.
+     * Resolves a query from RunQueryParams (by ID or Name+CategoryPath).
+     * Uses QueryEngine as the single source of truth for query metadata.
      */
-    findQueryInEngine(QueryID, QueryName, CategoryID, CategoryPath) {
+    resolveQuery(params) {
         const engineQueries = QueryEngine.Instance?.Queries;
         if (!engineQueries || engineQueries.length === 0)
-            return null;
-        if (QueryID) {
-            const lower = QueryID.trim().toLowerCase();
-            return engineQueries.find(q => q.ID.trim().toLowerCase() === lower) ?? null;
+            return undefined;
+        if (params.QueryID) {
+            return engineQueries.find(q => UUIDsEqual(q.ID, params.QueryID));
         }
-        if (QueryName) {
-            const lowerName = QueryName.trim().toLowerCase();
+        if (params.QueryName) {
+            const lowerName = params.QueryName.trim().toLowerCase();
             const matches = engineQueries.filter(q => q.Name.trim().toLowerCase() === lowerName);
             if (matches.length === 0)
-                return null;
+                return undefined;
             if (matches.length === 1)
                 return matches[0];
-            if (CategoryID) {
-                const byId = matches.find(q => q.CategoryID?.trim().toLowerCase() === CategoryID.trim().toLowerCase());
+            if (params.CategoryPath) {
+                const byPath = matches.find(q => q.CategoryPath.toLowerCase() === params.CategoryPath?.toLowerCase());
+                if (byPath)
+                    return byPath;
+            }
+            if (params.CategoryID) {
+                const byId = matches.find(q => UUIDsEqual(q.CategoryID, params.CategoryID));
                 if (byId)
                     return byId;
-            }
-            if (CategoryPath) {
-                const resolvedCategoryId = this.resolveCategoryPath(CategoryPath);
+                const resolvedCategoryId = this.resolveCategoryPath(params.CategoryPath ?? '');
                 if (resolvedCategoryId) {
-                    const byPath = matches.find(q => UUIDsEqual(q.CategoryID, resolvedCategoryId));
-                    if (byPath)
-                        return byPath;
+                    const byResolvedPath = matches.find(q => UUIDsEqual(q.CategoryID, resolvedCategoryId));
+                    if (byResolvedPath)
+                        return byResolvedPath;
                 }
             }
             return matches[0];
         }
-        return null;
+        return undefined;
     }
     /**
      * Validates that a query can be executed by the given user. Checks both permissions
@@ -2081,7 +2042,7 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
      * emits a console warning but allows execution to proceed, enabling query testing
      * before formal approval.
      *
-     * @param query - The resolved QueryInfo to validate
+     * @param query - The resolved MJQueryEntityExtended to validate
      * @param contextUser - The user attempting to execute the query
      * @throws Error if the user does not have permission to run the query
      */
@@ -2094,20 +2055,6 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
             LogStatus(`WARNING: Executing query '${query.Name}' (ID: ${query.ID}) with status '${query.Status}'. Query has not been approved.`);
         }
     }
-    /**
-     * Creates a fresh QueryInfo from a MJQueryEntity and patches the ProviderBase cache.
-     */
-    refreshQueryInfoFromEntity(entity) {
-        const freshInfo = new QueryInfo(entity.GetAll());
-        const existingIndex = this.Queries.findIndex(q => UUIDsEqual(q.ID, freshInfo.ID));
-        if (existingIndex >= 0) {
-            this.Queries[existingIndex] = freshInfo;
-        }
-        else {
-            this.Queries.push(freshInfo);
-        }
-        return freshInfo;
-    }
     /**
      * Resolves a category path string to a QueryCategoryInfo ID.
      */
@@ -2134,9 +2081,9 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
         const results = new Map();
         if (items.length === 0)
             return results;
-        const promises = items.map(async ({ index, queryInfo }) => {
+        const promises = items.map(async ({ index, query }) => {
             try {
-                const rows = await this.ExecuteSQL(queryInfo.CacheValidationSQL, undefined, undefined, contextUser);
+                const rows = await this.ExecuteSQL(query.CacheValidationSQL, undefined, undefined, contextUser);
                 if (rows && rows.length > 0) {
                     const row = rows[0];
                     results.set(index, {
@@ -2179,13 +2126,9 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
             rowCount: result.Results.length,
         };
     }
-    get QueryCacheMgr() {
-        if (!this._queryCacheInitialized) {
-            QueryCacheManager.Instance.Init(this.InstanceConnectionString);
-            this._queryCacheInitialized = true;
-        }
-        return QueryCacheManager.Instance;
-    }
+    /**************************************************************************/
+    // InternalRunQuery — Shared Pipeline Implementation
+    /**************************************************************************/
     /**
      * Full query execution pipeline: resolve → validate → compose → template → cache check →
      * execute → paginate → audit → cache store. Platform providers inherit this; only
@@ -2203,7 +2146,6 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
             const { finalSQL, appliedParameters } = this.processQueryParameters(query, params.Parameters, contextUser);
             // Execute query — use SQL-level paging when requested, else fetch all rows
             const useSQLPaging = QueryPagingEngine.ShouldPage(params.StartRow, params.MaxRows);
-            const cacheConfig = query.CacheConfig;
             let paginatedResult;
             let totalRowCount;
             let executionTime;
@@ -2215,43 +2157,19 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
                     return pagedCacheHit;
                 }
                 const paging = QueryPagingEngine.WrapWithPaging(finalSQL, params.StartRow, params.MaxRows, this.PlatformKey);
-                // Check count cache — skip COUNT SQL if we have a cached total
-                const cachedCount = cacheConfig?.enabled
-                    ? await this.QueryCacheMgr.GetTotalRowCount(query, params.Parameters || {})
-                    : null;
+                // Execute data + count queries in parallel
                 const start = Date.now();
-                if (cachedCount != null) {
-                    // Only execute data query — count is cached
-                    const dataResult = await this.ExecuteSQL(paging.DataSQL, undefined, undefined, contextUser);
-                    executionTime = Date.now() - start;
-                    if (!dataResult)
-                        throw new Error('Error executing paged query SQL');
-                    paginatedResult = dataResult;
-                    totalRowCount = cachedCount;
-                }
-                else {
-                    // Execute data + count queries in parallel
-                    const [dataResult, countResult] = await Promise.all([
-                        this.ExecuteSQL(paging.DataSQL, undefined, undefined, contextUser),
-                        this.ExecuteSQL(paging.CountSQL, undefined, undefined, contextUser),
-                    ]);
-                    executionTime = Date.now() - start;
-                    if (!dataResult)
-                        throw new Error('Error executing paged query SQL');
-                    paginatedResult = dataResult;
-                    totalRowCount = countResult?.[0]?.TotalRowCount != null
-                        ? Number(countResult[0].TotalRowCount)
-                        : paginatedResult.length;
-                    // Cache the count for subsequent page requests (fire-and-forget)
-                    if (cacheConfig?.enabled) {
-                        void this.QueryCacheMgr.SetTotalRowCount(query, params.Parameters || {}, totalRowCount);
-                    }
-                }
-                // Cache the paged results (fire-and-forget)
-                if (cacheConfig?.enabled) {
-                    void this.QueryCacheMgr.SetPaged(query, params.Parameters || {}, params.StartRow, params.MaxRows, paginatedResult);
-                    void this.QueryCacheMgr.InvalidateWithDependents(query);
-                }
+                const [dataResult, countResult] = await Promise.all([
+                    this.ExecuteSQL(paging.DataSQL, undefined, undefined, contextUser),
+                    this.ExecuteSQL(paging.CountSQL, undefined, undefined, contextUser),
+                ]);
+                executionTime = Date.now() - start;
+                if (!dataResult)
+                    throw new Error('Error executing paged query SQL');
+                paginatedResult = dataResult;
+                totalRowCount = countResult?.[0]?.TotalRowCount != null
+                    ? Number(countResult[0].TotalRowCount)
+                    : paginatedResult.length;
             }
             else {
                 // Check full-result cache before executing
@@ -2327,30 +2245,7 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
                     ErrorMessage: validation.error || 'SQL validation failed',
                 };
             }
-            // Check ad-hoc cache if opt-in TTL is provided
-            const adhocTTL = params.AdhocCacheTTLMinutes;
-            if (adhocTTL != null && adhocTTL > 0) {
-                const cached = await this.QueryCacheMgr.GetAdhoc(params.SQL, adhocTTL);
-                if (cached) {
-                    const { paginatedResult, totalRowCount } = this.applyQueryPagination(cached.results, params);
-                    return {
-                        Success: true,
-                        QueryID: '',
-                        QueryName: 'Ad-Hoc Query',
-                        Results: paginatedResult,
-                        RowCount: paginatedResult.length,
-                        TotalRowCount: totalRowCount,
-                        ExecutionTime: 0,
-                        ErrorMessage: '',
-                        CacheHit: true,
-                    };
-                }
-            }
             const { result, executionTime } = await this.executeQueryWithTiming(params.SQL, contextUser);
-            // Store in ad-hoc cache if opt-in (fire-and-forget)
-            if (adhocTTL != null && adhocTTL > 0) {
-                void this.QueryCacheMgr.SetAdhoc(params.SQL, adhocTTL, result);
-            }
             const { paginatedResult, totalRowCount } = this.applyQueryPagination(result, params);
             return {
                 Success: true,
@@ -2380,10 +2275,10 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
     }
     /**
      * Finds a query from RunQueryParams and validates user permissions.
-     * Uses `resolveQueryInfo()` for lookup and `ValidateQueryForExecution()` for permissions.
+     * Uses `resolveQuery()` for lookup and `ValidateQueryForExecution()` for permissions.
      */
     findAndValidateQuery(params, contextUser) {
-        const query = this.resolveQueryInfo(params);
+        const query = this.resolveQuery(params);
         if (!query) {
             let errorDetails = 'Query not found';
             if (params.QueryName) {
@@ -2415,8 +2310,12 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
             Platform: this.PlatformKey,
             ContextUser: contextUser,
             Parameters: parameters,
-            UsesTemplate: query.UsesTemplate,
-            QueryInfo: query,
+            UsesTemplate: query.UsesTemplate ?? false,
+            QueryInfo: {
+                SQL: query.SQL ?? '',
+                UsesTemplate: query.UsesTemplate ?? false,
+                Parameters: query.QueryParameters,
+            },
         });
         if (!result.HasCompositions && !query.UsesTemplate && parameters && Object.keys(parameters).length > 0) {
             LogStatus('Warning: Parameters provided but query does not use templates. Parameters will be ignored.');
@@ -2474,11 +2373,15 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
      * pipeline. Supports inline dependencies for transient query testing.
      */
     resolveSpecParameters(spec, contextUser) {
+        // QueryExecutionSpec.ParameterDefinitions is QueryParameterInfo[] (MJCore),
+        // while RenderContext expects MJQueryParameterEntity[] (core-entities).
+        // Both share the structural shape the processor needs (Name, DataType, IsRequired).
+        const paramDefs = spec.ParameterDefinitions;
         const result = RenderPipeline.Run(spec.SQL, {
             Platform: this.PlatformKey,
             ContextUser: contextUser,
             Parameters: spec.Parameters,
-            ParameterDefinitions: spec.ParameterDefinitions,
+            ParameterDefinitions: paramDefs,
             UsesTemplate: spec.UsesTemplate,
             Dependencies: spec.Dependencies,
             OriginalSQL: spec.SQL,
@@ -2492,62 +2395,18 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
     // wrapWithMaxRows is now handled by RenderPipeline.applyMaxRows
     /**
      * Checks the query cache for existing results and returns them if valid.
+     * Currently always returns null (query caching is not active).
      */
-    async checkQueryCache(query, params, appliedParameters) {
-        const cacheConfig = query.CacheConfig;
-        if (!cacheConfig?.enabled) {
-            return null;
-        }
-        const cached = await this.QueryCacheMgr.Get(query, params.Parameters || {});
-        if (!cached) {
-            return null;
-        }
-        LogStatus(`Cache hit for query ${query.Name} (${query.ID})`);
-        const { paginatedResult, totalRowCount } = this.applyQueryPagination(cached.results, params);
-        return {
-            Success: true,
-            QueryID: query.ID,
-            QueryName: query.Name,
-            Results: paginatedResult,
-            RowCount: paginatedResult.length,
-            TotalRowCount: totalRowCount,
-            ExecutionTime: 0,
-            ErrorMessage: '',
-            AppliedParameters: appliedParameters,
-            CacheHit: true,
-            CacheTTLRemaining: cached.ttlRemainingMs,
-        };
+    async checkQueryCache(_query, _params, _appliedParameters) {
+        return null;
     }
     /**
      * Checks the paged cache for a specific page of query results.
      * Returns a full RunQueryResult on hit, null on miss.
+     * Currently always returns null (query caching is not active).
      */
-    async checkPagedQueryCache(query, params, appliedParameters) {
-        const cacheConfig = query.CacheConfig;
-        if (!cacheConfig?.enabled)
-            return null;
-        const cached = await this.QueryCacheMgr.GetPaged(query, params.Parameters || {}, params.StartRow, params.MaxRows);
-        if (!cached)
-            return null;
-        // Also try to get the cached count
-        const cachedCount = await this.QueryCacheMgr.GetTotalRowCount(query, params.Parameters || {});
-        const totalRowCount = cachedCount ?? cached.results.length;
-        LogStatus(`Paged cache hit for query ${query.Name} (${query.ID}) page ${params.StartRow}+${params.MaxRows}`);
-        return {
-            Success: true,
-            QueryID: query.ID,
-            QueryName: query.Name,
-            Results: cached.results,
-            RowCount: cached.results.length,
-            TotalRowCount: totalRowCount,
-            PageNumber: Math.floor(params.StartRow / params.MaxRows) + 1,
-            PageSize: params.MaxRows,
-            ExecutionTime: 0,
-            ErrorMessage: '',
-            AppliedParameters: appliedParameters,
-            CacheHit: true,
-            CacheTTLRemaining: cached.ttlRemainingMs,
-        };
+    async checkPagedQueryCache(_query, _params, _appliedParameters) {
+        return null;
     }
     /**
      * Executes the query SQL and tracks execution time.
@@ -2603,16 +2462,10 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
     }
     /**
      * Caches query results if caching is enabled for the query.
-     * Caches the full result set (before pagination).
+     * Currently a no-op (query caching is not active).
      */
-    async cacheQueryResults(query, parameters, results) {
-        const cacheConfig = query.CacheConfig;
-        if (!cacheConfig?.enabled) {
-            return;
-        }
-        await this.QueryCacheMgr.Set(query, parameters, results);
-        await this.QueryCacheMgr.InvalidateWithDependents(query);
-        LogStatus(`Cached results for query ${query.Name} (${query.ID})`);
+    async cacheQueryResults(_query, _parameters, _results) {
+        // No-op: query caching has been removed
     }
     /**************************************************************************/
     // Load — Shared Implementation
@@ -2631,9 +2484,9 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
             const quotes = pk.NeedsQuotes ? "'" : '';
             return `${this.QuoteIdentifier(pk.CodeName)}=${quotes}${val.Value}${quotes}`;
         }).join(' AND ');
-        // Append Read RLS filter if user is not exempt
+        // Append Read RLS filter (exemption check is centralized in GetUserRowLevelSecurityWhereClause)
         let fullWhere = where;
-        if (user && !entityInfo.UserExemptFromRowLevelSecurity(user, EntityPermissionType.Read)) {
+        if (user) {
             const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, EntityPermissionType.Read, '');
             if (rlsWhereClause && rlsWhereClause.length > 0) {
                 fullWhere = `${where} AND (${rlsWhereClause})`;
@@ -2693,9 +2546,6 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
      */
     async CheckRecordRLS(entity, user, type) {
         const entityInfo = entity.EntityInfo;
-        if (entityInfo.UserExemptFromRowLevelSecurity(user, type)) {
-            return true;
-        }
         const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, type, '');
         if (!rlsWhereClause || rlsWhereClause.length === 0) {
             return true;
@@ -2715,9 +2565,6 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
      */
     async CheckCreateRLS(entity, user) {
         const entityInfo = entity.EntityInfo;
-        if (entityInfo.UserExemptFromRowLevelSecurity(user, EntityPermissionType.Create)) {
-            return true;
-        }
         const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, EntityPermissionType.Create, '');
         if (!rlsWhereClause || rlsWhereClause.length === 0) {
             return true;