@memberjunction/generic-database-provider 5.37.0 → 5.39.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
@@ -26,6 +26,7 @@ import { RenderPipeline } from './renderPipeline.js';
 import { useJsonArgShape } from './crudSprocFieldRules.js';
 import { QueryEngine, ViewInfo, } from '@memberjunction/core-entities';
 import { AIEngine } from '@memberjunction/aiengine';
+import { SimpleVectorServiceProvider } from '@memberjunction/ai-vectors-memory';
 import { QueueManager } from '@memberjunction/queue';
 import { EntityActionEngineServer } from '@memberjunction/actions';
 import { EncryptionEngine } from '@memberjunction/encryption';
@@ -43,14 +44,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.
@@ -675,6 +668,24 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
     getDialect() {
         return null;
     }
+    /**
+     * Detects infrastructure-level connection errors (timeout, refused, pool closed)
+     * as opposed to query-level errors (bad SQL, constraint violations).
+     * Delegates to the dialect's driver-specific error classification, with a
+     * fallback for POOL_CLOSED errors thrown by our own code.
+     */
+    isConnectionError(e) {
+        // Dialect-specific check (mssql ConnectionError, pg network codes, etc.)
+        if (this.getDialect()?.IsConnectionError(e))
+            return true;
+        // Our own pool-closed errors are not dialect-specific
+        if (e instanceof Error) {
+            const code = e.code ?? '';
+            if (code === 'POOL_CLOSED')
+                return true;
+        }
+        return false;
+    }
     /**
      * Returns the batch separator token for the underlying database platform by delegating to
      * the SQLDialect instance returned by `getDialect()`.
@@ -1128,13 +1139,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
@@ -1291,6 +1300,12 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
             };
         }
         catch (e) {
+            // Re-throw infrastructure errors (connection timeout, pool closed, etc.)
+            // so callers can distinguish "database is unreachable" from "query returned
+            // no results." Only query-level errors are safe to return as { Success: false }.
+            if (this.isConnectionError(e)) {
+                throw e;
+            }
             const exceptionStopTime = new Date();
             LogError(e);
             return {
@@ -1750,11 +1765,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 +1973,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 +2024,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 +2067,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 +2080,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 +2106,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 +2151,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 +2171,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 +2182,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
@@ -2287,6 +2230,9 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
             };
         }
         catch (e) {
+            if (this.isConnectionError(e)) {
+                throw e;
+            }
             LogError(e);
             const errorMessage = e instanceof Error ? e.message : String(e);
             return {
@@ -2327,30 +2273,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 +2303,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 +2338,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 +2401,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 +2423,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 +2490,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 +2512,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 +2574,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 +2593,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;
@@ -3198,5 +3073,79 @@ export class GenericDatabaseProvider extends DatabaseProviderBase {
         }
         return maxDate ? maxDate.toISOString() : new Date().toISOString();
     }
+    /**
+     * Server-side semantic ranking pass for {@link ProviderBase.SearchEntity}
+     * (and, by extension, the batched {@link ProviderBase.SearchEntities}).
+     *
+     * The query embedding MUST be generated with the same model that produced
+     * the indexed vectors — otherwise cosine scores compare apples to oranges
+     * and rankings are garbage. We look up the EntityDocument's `AIModelID` via
+     * `AIEngine.Models` to recover the driver class / APIName and call
+     * `EmbedText(model, text)` directly. If the EntityDocument does not specify
+     * a model (or the model isn't loaded) we fall back to
+     * `EmbedTextLocal` (highest-power local model) only as a last resort.
+     *
+     * Vector ranking runs against the in-process `SimpleVectorServiceProvider`,
+     * which rehydrates the vector pool for `entityDocumentId` from
+     * `MJ: Entity Record Documents.VectorJSON` rows.
+     *
+     * Failures (no embedding model available, vector index miss) degrade to an
+     * empty result set so hybrid mode can still surface lexical matches.
+     */
+    async searchEntitiesSemanticPass(entityDocumentId, searchText, overFetch, embeddingAIModelId, contextUser) {
+        // Ensure AIEngine is loaded so Models / EmbedText are usable. Config()
+        // is a no-op when already initialized — safe to call on every search.
+        try {
+            await AIEngine.Instance.Config(false, contextUser);
+        }
+        catch (e) {
+            LogError(`searchEntitiesSemanticPass: AIEngine.Config failed: ${e instanceof Error ? e.message : String(e)}`);
+            return [];
+        }
+        let queryVector = null;
+        try {
+            if (embeddingAIModelId) {
+                const model = AIEngine.Instance.Models.find(m => UUIDsEqual(m.ID, embeddingAIModelId));
+                if (!model) {
+                    LogError(`searchEntitiesSemanticPass: EntityDocument AIModelID="${embeddingAIModelId}" not found in AIEngine.Models. Index/query model mismatch is likely — refusing to fall back silently.`);
+                    return [];
+                }
+                const result = await AIEngine.Instance.EmbedText(model, searchText);
+                queryVector = result?.vector ?? null;
+            }
+            else {
+                // No model on the EntityDocument — last-resort fallback to the
+                // highest-power local embedder. Logged because this path means
+                // indexing-time and query-time models can diverge.
+                LogError(`searchEntitiesSemanticPass: no AIModelID on EntityDocument "${entityDocumentId}"; falling back to highest-power local embedding model. Index/query mismatch possible.`);
+                const embed = await AIEngine.Instance.EmbedTextLocal(searchText);
+                queryVector = embed?.result?.vector ?? null;
+            }
+        }
+        catch (e) {
+            LogError(`searchEntitiesSemanticPass: embedding generation threw: ${e instanceof Error ? e.message : String(e)}`);
+            return [];
+        }
+        if (!queryVector)
+            return [];
+        const vectorProvider = new SimpleVectorServiceProvider();
+        const result = await vectorProvider.QueryIndex({ id: entityDocumentId, vector: queryVector, topK: overFetch }, contextUser);
+        if (!result.success)
+            return [];
+        const data = result.data;
+        const matches = data?.matches ?? [];
+        const out = [];
+        for (const m of matches) {
+            const recordId = String(m.metadata?.['RecordID'] ?? '');
+            if (!recordId)
+                continue;
+            out.push({
+                ID: recordId,
+                Score: m.score,
+                Metadata: { entityRecordDocumentId: m.id },
+            });
+        }
+        return out;
+    }
 }
 //# sourceMappingURL=GenericDatabaseProvider.js.map