@memberjunction/sqlserver-dataprovider 5.4.1 → 5.5.0

package/dist/SQLServerDataProvider.js

@@ -15,29 +15,84 @@
  * In practice - this FILE will NOT exist in the entities library, we need to move to its own separate project
  * so it is only included by the consumer of the entities library if they want to use it.
  **************************************************************************************************************/
-import { ApplicationInfo, EntityFieldTSType, ProviderType, UserInfo, AuditLogTypeInfo, AuthorizationInfo, TransactionItem, EntityPermissionType, EntitySaveOptions, LogError, StripStopWords, LogStatus, CompositeKey, EntityDeleteOptions, BaseEntityResult, Metadata, DatabaseProviderBase, QueryInfo, QueryCache, InMemoryLocalStorageProvider, } from '@memberjunction/core';
-import { QueryParameterProcessor } from './queryParameterProcessor.js';
+import { EntityFieldTSType, ProviderType, LogError, LogStatus, CompositeKey, QueryCache, InMemoryLocalStorageProvider, } from '@memberjunction/core';
+import { QueryParameterProcessor } from '@memberjunction/query-processor';
 import { NodeFileSystemProvider } from './NodeFileSystemProvider.js';
-import { QueryEngine, ViewInfo, } from '@memberjunction/core-entities';
-import { AIEngine } from '@memberjunction/aiengine';
 import { QueueManager } from '@memberjunction/queue';
+import { GenericDatabaseProvider } from '@memberjunction/generic-database-provider';
 import sql from 'mssql';
 import { BehaviorSubject, Subject, concatMap, from, tap, catchError, of } from 'rxjs';
 import { SQLServerTransactionGroup } from './SQLServerTransactionGroup.js';
-import { SqlLoggingSessionImpl } from './SqlLogger.js';
-import { EntityActionEngineServer } from '@memberjunction/actions';
 import { EncryptionEngine } from '@memberjunction/encryption';
 import { v4 as uuidv4 } from 'uuid';
-import { MJGlobal, SQLExpressionValidator } from '@memberjunction/global';
+import { SQLExpressionValidator, UUIDsEqual } from '@memberjunction/global';
 /**
- * Core SQL execution function - handles the actual database query execution
+ * Checks whether an error indicates a stale/dead database connection that
+ * could be resolved by retrying with a fresh connection from the pool.
+ * Common in Azure environments where load balancers or SQL connection
+ * governance drop idle TCP connections.
+ */
+function isStaleConnectionError(error) {
+    const message = error.message ?? '';
+    const code = error.code ?? '';
+    return (
+    // tedious connection state errors (e.g. "Requests can only be made in the LoggedIn state, not the Final state")
+    message.includes('not the Final state') ||
+        message.includes('not the SentClientRequest state') ||
+        // General connection-dropped errors
+        message.includes('Connection lost') ||
+        message.includes('Connection closed') ||
+        message.includes('socket hang up') ||
+        code === 'ESOCKET' ||
+        code === 'ECONNRESET');
+}
+/**
+ * Builds a sql.Request, binds parameters, and processes positional placeholders.
+ */
+function buildRequest(connectionSource, query, parameters) {
+    // Note: The branch looks redundant but is required for TypeScript type narrowing.
+    // The sql.Request constructor has overloads for ConnectionPool and Transaction,
+    // but TypeScript can't resolve the overload with a union type parameter.
+    let request;
+    if (connectionSource instanceof sql.Transaction) {
+        request = new sql.Request(connectionSource);
+    }
+    else {
+        request = new sql.Request(connectionSource);
+    }
+    let processedQuery = query;
+    if (parameters) {
+        if (Array.isArray(parameters)) {
+            // Handle positional parameters (legacy TypeORM style)
+            parameters.forEach((value, index) => {
+                request.input(`p${index}`, value);
+            });
+            let paramIndex = 0;
+            processedQuery = query.replace(/\?/g, () => `@p${paramIndex++}`);
+        }
+        else if (typeof parameters === 'object') {
+            for (const [key, value] of Object.entries(parameters)) {
+                request.input(key, value);
+            }
+        }
+    }
+    return { request, processedQuery };
+}
+/**
+ * Core SQL execution function - handles the actual database query execution.
  * This is outside the class to allow both static and instance methods to use it
- * without creating circular dependencies or forcing everything to be static
+ * without creating circular dependencies or forcing everything to be static.
+ *
+ * Includes automatic retry logic for stale connection errors: when Azure drops
+ * idle TCP connections, the pool may hand out dead connections that fail on first
+ * use. For non-transactional queries, we retry once so the pool can evict the
+ * dead connection and provide a fresh one.
  */
-async function executeSQLCore(query, parameters, context, options) {
+async function executeSQLCore(query, parameters, context, options, isRetry = false) {
     // Determine which connection source to use
     let connectionSource;
-    if (context.transaction) {
+    const isTransaction = !!context.transaction;
+    if (isTransaction) {
         // Use the transaction if provided
         // Note: We no longer test the transaction validity here because:
         // 1. It could cause race conditions with concurrent queries
@@ -64,36 +119,7 @@ async function executeSQLCore(query, parameters, context, options) {
         logPromise = Promise.resolve();
     }
     try {
-        // Create a new request object for this query
-        // Note: This looks redundant but is required for TypeScript type narrowing.
-        // The sql.Request constructor has overloads for ConnectionPool and Transaction,
-        // but TypeScript can't resolve the overload with a union type parameter.
-        let request;
-        if (connectionSource instanceof sql.Transaction) {
-            request = new sql.Request(connectionSource);
-        }
-        else {
-            request = new sql.Request(connectionSource);
-        }
-        // Add parameters if provided
-        let processedQuery = query;
-        if (parameters) {
-            if (Array.isArray(parameters)) {
-                // Handle positional parameters (legacy TypeORM style)
-                parameters.forEach((value, index) => {
-                    request.input(`p${index}`, value);
-                });
-                // Replace ? with @p0, @p1, etc. in the query
-                let paramIndex = 0;
-                processedQuery = query.replace(/\?/g, () => `@p${paramIndex++}`);
-            }
-            else if (typeof parameters === 'object') {
-                // Handle named parameters
-                for (const [key, value] of Object.entries(parameters)) {
-                    request.input(key, value);
-                }
-            }
-        }
+        const { request, processedQuery } = buildRequest(connectionSource, query, parameters);
         // Execute query and logging in parallel
         const [result] = await Promise.all([
             request.query(processedQuery),
@@ -102,6 +128,14 @@ async function executeSQLCore(query, parameters, context, options) {
         return result;
     }
     catch (error) {
+        // Retry once for stale connection errors on non-transactional queries.
+        // Transactions cannot be retried because the connection state is already
+        // corrupted and the caller must handle rollback/retry at a higher level.
+        if (!isRetry && !isTransaction && isStaleConnectionError(error)) {
+            console.warn(`[SQLServerDataProvider] Stale connection detected, retrying query once. ` +
+                `Original error: ${error.message}`);
+            return executeSQLCore(query, parameters, context, options, true);
+        }
         // Build detailed error message with query and parameters
         const errorMessage = `Error executing SQL
     Error: ${error?.message ? error.message : error}
@@ -130,8 +164,11 @@ async function executeSQLCore(query, parameters, context, options) {
  * await provider.Config();
  * ```
  */
-export class SQLServerDataProvider extends DatabaseProviderBase {
+export class SQLServerDataProvider extends GenericDatabaseProvider {
     constructor() {
+        /**************************************************************************/
+        // SQL Dialect Implementations (override abstract methods from DatabaseProviderBase)
+        /**************************************************************************/
         super(...arguments);
         this._transactionDepth = 0;
         this._savepointCounter = 0;
@@ -148,18 +185,19 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         this._transactionState$ = new BehaviorSubject(false);
         this._deferredTasks = [];
     }
-    static { this._sqlLoggingSessionsKey = 'MJ_SQLServerDataProvider_SqlLoggingSessions'; }
-    get _sqlLoggingSessions() {
-        const g = MJGlobal.Instance.GetGlobalObjectStore();
-        if (g) {
-            if (!g[SQLServerDataProvider._sqlLoggingSessionsKey]) {
-                g[SQLServerDataProvider._sqlLoggingSessionsKey] = new Map();
-            }
-            return g[SQLServerDataProvider._sqlLoggingSessionsKey];
-        }
-        else {
-            throw new Error('No global object store available for SQL logging session');
-        }
+    QuoteIdentifier(name) {
+        return `[${name}]`;
+    }
+    QuoteSchemaAndView(schemaName, objectName) {
+        return `[${schemaName}].[${objectName}]`;
+    }
+    static { this._sqlServerUUIDPattern = /^\s*(newid|newsequentialid)\s*\(\s*\)\s*$/i; }
+    static { this._sqlServerDefaultPattern = /^\s*(getdate|getutcdate|sysdatetime|sysdatetimeoffset|sysutcdatetime|current_timestamp)\s*\(\s*\)\s*$/i; }
+    get UUIDFunctionPattern() {
+        return SQLServerDataProvider._sqlServerUUIDPattern;
+    }
+    get DBDefaultFunctionPattern() {
+        return SQLServerDataProvider._sqlServerDefaultPattern;
     }
     /**
      * Observable that emits the current transaction state (true when active, false when not)
@@ -288,105 +326,14 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
     get MJCoreSchemaName() {
         return this.ConfigData.MJCoreSchemaName;
     }
-    /**************************************************************************/
-    // START ---- SQL Logging Methods
-    /**************************************************************************/
-    /**
-     * Creates a new SQL logging session that will capture all SQL operations to a file.
-     * Returns a disposable session object that must be disposed to stop logging.
-     *
-     * @param filePath - Full path to the file where SQL statements will be logged
-     * @param options - Optional configuration for the logging session
-     * @returns Promise<SqlLoggingSession> - Disposable session object
-     *
-     * @example
-     * ```typescript
-     * // Basic usage
-     * const session = await provider.CreateSqlLogger('./logs/metadata-sync.sql');
-     * try {
-     *   // Perform operations that will be logged
-     *   await provider.ExecuteSQL('INSERT INTO ...');
-     * } finally {
-     *   await session.dispose(); // Stop logging
-     * }
-     *
-     * // With migration formatting
-     * const session = await provider.CreateSqlLogger('./migrations/changes.sql', {
-     *   formatAsMigration: true,
-     *   description: 'MetadataSync push operation'
-     * });
-     * ```
-     */
-    async CreateSqlLogger(filePath, options) {
-        const sessionId = uuidv4();
-        const mjCoreSchema = this.ConfigData.MJCoreSchemaName;
-        const session = new SqlLoggingSessionImpl(sessionId, filePath, {
-            defaultSchemaName: mjCoreSchema,
-            ...options // if defaultSchemaName is not provided, it will use the MJCoreSchemaName, otherwise
-            // the caller's defaultSchemaName will be used
-        });
-        // Initialize the session (create file, write header)
-        await session.initialize();
-        // Store in active sessions map
-        this._sqlLoggingSessions.set(sessionId, session);
-        // Return a proxy that handles cleanup on dispose
-        return {
-            id: session.id,
-            filePath: session.filePath,
-            startTime: session.startTime,
-            get statementCount() {
-                return session.statementCount;
-            },
-            options: session.options,
-            dispose: async () => {
-                await session.dispose();
-                this._sqlLoggingSessions.delete(sessionId);
-            },
-        };
-    }
     async GetCurrentUser() {
         return this.CurrentUser;
     }
-    /**
-     * Gets information about all active SQL logging sessions.
-     * Useful for monitoring and debugging.
-     *
-     * @returns Array of session information objects
-     */
-    GetActiveSqlLoggingSessions() {
-        return Array.from(this._sqlLoggingSessions.values()).map((session) => ({
-            id: session.id,
-            filePath: session.filePath,
-            startTime: session.startTime,
-            statementCount: session.statementCount,
-            options: session.options,
-        }));
-    }
-    /**
-     * Gets a specific SQL logging session by its ID.
-     * Returns the session if found, or undefined if not found.
-     *
-     * @param sessionId - The unique identifier of the session to retrieve
-     * @returns The SqlLoggingSession if found, undefined otherwise
-     */
-    GetSqlLoggingSessionById(sessionId) {
-        return this._sqlLoggingSessions.get(sessionId);
-    }
-    /**
-     * Disposes all active SQL logging sessions.
-     * Useful for cleanup on provider shutdown.
-     */
-    async DisposeAllSqlLoggingSessions() {
-        const disposePromises = Array.from(this._sqlLoggingSessions.values()).map((session) => session.dispose());
-        await Promise.all(disposePromises);
-        this._sqlLoggingSessions.clear();
-    }
     /**
      * Dispose of this provider instance and clean up resources.
      * This should be called when the provider is no longer needed.
      */
     async Dispose() {
-        // Dispose all SQL logging sessions
         await this.DisposeAllSqlLoggingSessions();
         // Unsubscribe from the SQL queue
         if (this._queueSubscription) {
@@ -400,155 +347,6 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         // Note: We don't close the pool here as it might be shared
         // The caller is responsible for closing the pool when appropriate
     }
-    /**
-     * Internal method to log SQL statement to all active logging sessions.
-     * This is called automatically by ExecuteSQL methods.
-     *
-     * @param query - The SQL query being executed
-     * @param parameters - Parameters for the query
-     * @param description - Optional description for this operation
-     * @param ignoreLogging - If true, this statement will not be logged
-     * @param isMutation - Whether this is a data mutation operation
-     * @param simpleSQLFallback - Optional simple SQL to use for loggers with logRecordChangeMetadata=false
-     */
-    async _logSqlStatement(query, parameters, description, ignoreLogging = false, isMutation = false, simpleSQLFallback, contextUser) {
-        if (ignoreLogging || this._sqlLoggingSessions.size === 0) {
-            return;
-        }
-        // Check if any session has verbose output enabled for debug logging
-        const allSessions = Array.from(this._sqlLoggingSessions.values());
-        const hasVerboseSession = allSessions.some(s => s.options.verboseOutput === true);
-        if (hasVerboseSession) {
-            console.log('=== SQL LOGGING DEBUG ===');
-            console.log(`Query to log: ${query.substring(0, 100)}...`);
-            console.log(`Context user email: ${contextUser?.Email || 'NOT_PROVIDED'}`);
-            console.log(`Active sessions count: ${this._sqlLoggingSessions.size}`);
-            console.log(`All sessions:`, allSessions.map(s => ({
-                id: s.id,
-                filterByUserId: s.options.filterByUserId,
-                sessionName: s.options.sessionName
-            })));
-        }
-        const filteredSessions = allSessions.filter((session) => {
-            // If session has user filter, only log if contextUser matches AND contextUser is provided
-            if (session.options.filterByUserId) {
-                if (!contextUser?.Email) {
-                    if (hasVerboseSession) {
-                        console.log(`Session ${session.id}: Has user filter but no contextUser provided - SKIPPING`);
-                    }
-                    return false; // Don't log if filtering requested but no user context provided
-                }
-                const matches = session.options.filterByUserId === contextUser.ID;
-                if (hasVerboseSession) {
-                    console.log(`Session ${session.id} filter check:`, {
-                        filterByUserId: session.options.filterByUserId,
-                        contextUserEmail: contextUser.Email,
-                        matches: matches
-                    });
-                }
-                return matches;
-            }
-            // No filter means log for all users (regardless of contextUser)
-            if (hasVerboseSession) {
-                console.log(`Session ${session.id} has no filter - including`);
-            }
-            return true;
-        });
-        if (hasVerboseSession) {
-            console.log(`Sessions after filtering: ${filteredSessions.length}`);
-        }
-        const logPromises = filteredSessions.map((session) => session.logSqlStatement(query, parameters, description, isMutation, simpleSQLFallback));
-        await Promise.all(logPromises);
-        if (hasVerboseSession) {
-            console.log('=== SQL LOGGING DEBUG END ===');
-        }
-    }
-    /**
-     * Static method to log SQL statements from external sources like transaction groups
-     *
-     * @param query - The SQL query being executed
-     * @param parameters - Parameters for the query
-     * @param description - Optional description for this operation
-     * @param isMutation - Whether this is a data mutation operation
-     * @param simpleSQLFallback - Optional simple SQL to use for loggers with logRecordChangeMetadata=false
-     */
-    static async LogSQLStatement(query, parameters, description, isMutation = false, simpleSQLFallback, contextUser) {
-        // Get the current provider instance
-        const provider = Metadata.Provider;
-        if (provider && provider._sqlLoggingSessions.size > 0) {
-            await provider._logSqlStatement(query, parameters, description, false, isMutation, simpleSQLFallback, contextUser);
-        }
-    }
-    /**************************************************************************/
-    // END ---- SQL Logging Methods
-    /**************************************************************************/
-    /**************************************************************************/
-    // START ---- IRunReportProvider
-    /**************************************************************************/
-    async RunReport(params, contextUser) {
-        const ReportID = params.ReportID;
-        // run the sql and return the data
-        const sqlReport = `SELECT ReportSQL FROM [${this.MJCoreSchemaName}].vwReports WHERE ID =${ReportID}`;
-        const reportInfo = await this.ExecuteSQL(sqlReport, undefined, undefined, contextUser);
-        if (reportInfo && reportInfo.length > 0) {
-            const start = new Date().getTime();
-            const sql = reportInfo[0].ReportSQL;
-            const result = await this.ExecuteSQL(sql, undefined, undefined, contextUser);
-            const end = new Date().getTime();
-            if (result)
-                return {
-                    Success: true,
-                    ReportID,
-                    Results: result,
-                    RowCount: result.length,
-                    ExecutionTime: end - start,
-                    ErrorMessage: '',
-                };
-            else
-                return {
-                    Success: false,
-                    ReportID,
-                    Results: [],
-                    RowCount: 0,
-                    ExecutionTime: end - start,
-                    ErrorMessage: 'Error running report SQL',
-                };
-        }
-        else
-            return { Success: false, ReportID, Results: [], RowCount: 0, ExecutionTime: 0, ErrorMessage: 'Report not found' };
-    }
-    /**************************************************************************/
-    // END ---- IRunReportProvider
-    /**************************************************************************/
-    /**
-     * Resolves a hierarchical category path (e.g., "/MJ/AI/Agents/") to a CategoryID.
-     * The path is split by "/" and each segment is matched case-insensitively against
-     * category names, walking down the hierarchy from root to leaf.
-     *
-     * @param categoryPath The hierarchical category path (e.g., "/MJ/AI/Agents/")
-     * @returns The CategoryID if the path exists, null otherwise
-     */
-    resolveCategoryPath(categoryPath) {
-        if (!categoryPath)
-            return null;
-        // Split path and clean segments - remove empty strings from leading/trailing slashes
-        const segments = categoryPath.split('/')
-            .map(s => s.trim())
-            .filter(s => s.length > 0);
-        if (segments.length === 0)
-            return null;
-        // Walk down the hierarchy to find the target category
-        let currentCategory = null;
-        for (const segment of segments) {
-            const parentId = currentCategory?.ID || null;
-            currentCategory = this.QueryCategories.find(cat => cat.Name.trim().toLowerCase() === segment.toLowerCase() &&
-                cat.ParentID === parentId);
-            if (!currentCategory) {
-                return null; // Path not found
-            }
-        }
-        return currentCategory.ID;
-    }
     /**
      * Finds a query by ID or by Name+Category combination.
      * Supports both direct CategoryID lookup and hierarchical CategoryPath path resolution.
@@ -581,7 +379,7 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
                 else if (CategoryPath) {
                     const resolvedCategoryId = this.resolveCategoryPath(CategoryPath);
                     if (resolvedCategoryId) {
-                        matches = matches && q.CategoryID === resolvedCategoryId;
+                        matches = matches && UUIDsEqual(q.CategoryID, resolvedCategoryId);
                     }
                     else {
                         matches = matches && q.Category.trim().toLowerCase() === CategoryPath.trim().toLowerCase();
@@ -604,59 +402,6 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
             return queries[0];
         }
     }
-    /**
-     * Looks up a query from QueryEngine's auto-refreshed cache by ID, name, and optional category filters.
-     */
-    findQueryInEngine(QueryID, QueryName, CategoryID, CategoryPath) {
-        const engineQueries = QueryEngine.Instance?.Queries;
-        if (!engineQueries || engineQueries.length === 0) {
-            return null; // Engine not loaded yet
-        }
-        if (QueryID) {
-            const lower = QueryID.trim().toLowerCase();
-            return engineQueries.find(q => q.ID.trim().toLowerCase() === lower) ?? null;
-        }
-        if (QueryName) {
-            const lowerName = QueryName.trim().toLowerCase();
-            const matches = engineQueries.filter(q => q.Name.trim().toLowerCase() === lowerName);
-            if (matches.length === 0)
-                return null;
-            if (matches.length === 1)
-                return matches[0];
-            // Disambiguate by category
-            if (CategoryID) {
-                const byId = matches.find(q => q.CategoryID?.trim().toLowerCase() === CategoryID.trim().toLowerCase());
-                if (byId)
-                    return byId;
-            }
-            if (CategoryPath) {
-                const resolvedCategoryId = this.resolveCategoryPath(CategoryPath);
-                if (resolvedCategoryId) {
-                    const byPath = matches.find(q => q.CategoryID === resolvedCategoryId);
-                    if (byPath)
-                        return byPath;
-                }
-            }
-            return matches[0];
-        }
-        return null;
-    }
-    /**
-     * Creates a fresh QueryInfo from a MJQueryEntity and patches the ProviderBase in-memory cache.
-     * This avoids stale data without requiring a full metadata reload.
-     */
-    refreshQueryInfoFromEntity(entity) {
-        const freshInfo = new QueryInfo(entity.GetAll());
-        // Patch the ProviderBase cache: replace the stale entry or add the new one
-        const existingIndex = this.Queries.findIndex(q => q.ID === freshInfo.ID);
-        if (existingIndex >= 0) {
-            this.Queries[existingIndex] = freshInfo;
-        }
-        else {
-            this.Queries.push(freshInfo);
-        }
-        return freshInfo;
-    }
     /**************************************************************************/
     // START ---- IRunQueryProvider
     /**************************************************************************/
@@ -799,10 +544,10 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
      * Processes query parameters and applies template substitution if needed
      */
     processQueryParameters(query, parameters) {
-        let finalSQL = query.SQL;
+        let finalSQL = query.GetPlatformSQL(this.PlatformKey);
         let appliedParameters = {};
         if (query.UsesTemplate) {
-            const processingResult = QueryParameterProcessor.processQueryTemplate(query, parameters);
+            const processingResult = QueryParameterProcessor.processQueryTemplate(query, parameters, finalSQL);
             if (!processingResult.success) {
                 throw new Error(processingResult.error);
             }
@@ -925,154 +670,6 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         const promises = params.map((p) => this.InternalRunQuery(p, contextUser));
         return Promise.all(promises);
     }
-    /**
-     * RunQueriesWithCacheCheck - Smart cache validation for batch RunQueries.
-     * For each query request, if cacheStatus is provided, uses the Query's CacheValidationSQL
-     * to check if the cached data is still current by comparing MAX(__mj_UpdatedAt) and COUNT(*)
-     * with client's values. Returns 'current' if cache is valid (no data), or 'stale' with fresh data.
-     *
-     * Queries without CacheValidationSQL configured will return 'no_validation' status with full data.
-     */
-    async RunQueriesWithCacheCheck(params, contextUser) {
-        try {
-            const user = contextUser || this.CurrentUser;
-            if (!user) {
-                return {
-                    success: false,
-                    results: [],
-                    errorMessage: 'No user context available',
-                };
-            }
-            // Separate items that need cache check from those that don't
-            const itemsNeedingCacheCheck = [];
-            const itemsWithoutCacheCheck = [];
-            const itemsWithoutValidationSQL = [];
-            const errorResults = [];
-            // Pre-process all items to resolve query info and validate
-            for (let i = 0; i < params.length; i++) {
-                const item = params[i];
-                // Resolve query info
-                const queryInfo = this.resolveQueryInfo(item.params);
-                if (!queryInfo) {
-                    errorResults.push({
-                        queryIndex: i,
-                        queryId: item.params.QueryID || '',
-                        status: 'error',
-                        errorMessage: `Query not found: ${item.params.QueryID || item.params.QueryName}`,
-                    });
-                    continue;
-                }
-                // Check permissions
-                if (!queryInfo.UserCanRun(user)) {
-                    errorResults.push({
-                        queryIndex: i,
-                        queryId: queryInfo.ID,
-                        status: 'error',
-                        errorMessage: `User does not have permission to run query: ${queryInfo.Name}`,
-                    });
-                    continue;
-                }
-                if (!item.cacheStatus) {
-                    // No cache status provided - will run full query
-                    itemsWithoutCacheCheck.push({ index: i, item });
-                    continue;
-                }
-                // Check if query has CacheValidationSQL
-                if (!queryInfo.CacheValidationSQL) {
-                    // No validation SQL configured - will run full query and return 'no_validation'
-                    itemsWithoutValidationSQL.push({ index: i, item, queryInfo });
-                    continue;
-                }
-                itemsNeedingCacheCheck.push({ index: i, item, queryInfo });
-            }
-            // Execute batched cache status check for all items that need it
-            const cacheStatusResults = await this.getBatchedQueryCacheStatus(itemsNeedingCacheCheck, contextUser);
-            // Determine which items are current vs stale
-            const staleItems = [];
-            const currentResults = [];
-            for (const { index, item, queryInfo } 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',
-                    });
-                    continue;
-                }
-                const isCurrent = this.isCacheCurrent(item.cacheStatus, serverStatus);
-                if (isCurrent) {
-                    currentResults.push({
-                        queryIndex: index,
-                        queryId: queryInfo.ID,
-                        status: 'current',
-                    });
-                }
-                else {
-                    staleItems.push({ index, params: item.params, queryInfo });
-                }
-            }
-            // Run full queries in parallel for:
-            // 1. Items without cache status (no fingerprint from client)
-            // 2. Items without CacheValidationSQL (always return data with 'no_validation' status)
-            // 3. Items with stale cache
-            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)),
-            ];
-            const fullQueryResults = await Promise.all(fullQueryPromises);
-            // Combine all results and sort by queryIndex
-            const allResults = [...errorResults, ...currentResults, ...fullQueryResults];
-            allResults.sort((a, b) => a.queryIndex - b.queryIndex);
-            return {
-                success: true,
-                results: allResults,
-            };
-        }
-        catch (e) {
-            LogError(e);
-            return {
-                success: false,
-                results: [],
-                errorMessage: e instanceof Error ? e.message : String(e),
-            };
-        }
-    }
-    /**
-     * Resolves QueryInfo from RunQueryParams (by ID or Name+CategoryPath).
-     */
-    resolveQueryInfo(params) {
-        // Try QueryEngine first for fresh, auto-refreshed data
-        const freshEntity = this.findQueryInEngine(params.QueryID, params.QueryName, params.CategoryID, params.CategoryPath);
-        if (freshEntity) {
-            return this.refreshQueryInfoFromEntity(freshEntity);
-        }
-        // Fall back to ProviderBase cache if engine isn't loaded
-        if (params.QueryID) {
-            return this.Queries.find((q) => 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) => q.CategoryID === params.CategoryID);
-                if (byId)
-                    return byId;
-            }
-            return matchingQueries[0];
-        }
-        return undefined;
-    }
     /**
      * Executes a batched cache status check for multiple queries using their CacheValidationSQL.
      */
@@ -1116,1193 +713,81 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         }
         return results;
     }
-    /**
-     * Runs the full query and returns results with cache metadata.
-     */
-    async runFullQueryAndReturnForQuery(params, queryIndex, status, contextUser, queryId) {
-        const result = await this.InternalRunQuery(params, contextUser);
-        if (!result.Success) {
-            return {
-                queryIndex,
-                queryId: queryId || result.QueryID || '',
-                status: 'error',
-                errorMessage: result.ErrorMessage || 'Unknown error executing query',
-            };
-        }
-        // Extract maxUpdatedAt from results
-        const maxUpdatedAt = this.extractMaxUpdatedAt(result.Results);
-        return {
-            queryIndex,
-            queryId: result.QueryID,
-            status,
-            results: result.Results,
-            maxUpdatedAt,
-            rowCount: result.Results.length,
-        };
-    }
     /**************************************************************************/
     // END ---- IRunQueryProvider
     /**************************************************************************/
+    /**************************************************************************/
+    // START ---- IRunViewProvider
+    /**************************************************************************/
+    BuildTopClause(maxRows) {
+        return `TOP ${maxRows}`;
+    }
+    BuildPaginationSQL(maxRows, startRow) {
+        return `OFFSET ${startRow} ROWS FETCH NEXT ${maxRows} ROWS ONLY`;
+    }
+    BuildParameterPlaceholder(index) {
+        return `@p${index}`;
+    }
     /**
-     * This method will check to see if the where clause for the view provided has any templating within it, and if it does
-     * will replace the templating with the appropriate run-time values. This is done recursively with depth-first traversal
-     * so that if there are nested templates, they will be replaced as well. We also maintain a stack to ensure that any
-     * possible circular references are caught and an error is thrown if that is the case.
-     * @param viewEntity
-     * @param user
+     * Executes a batched cache status check for multiple views in a single SQL call.
+     * Uses multiple result sets to return status for each view efficiently.
      */
-    async RenderViewWhereClause(viewEntity, user, stack = []) {
+    async getBatchedServerCacheStatus(items, contextUser) {
+        const results = new Map();
+        if (items.length === 0) {
+            return results;
+        }
+        // Build array of SQL statements for batch execution
+        const sqlStatements = [];
+        for (const { entityInfo, whereSQL } of items) {
+            const statusSQL = `SELECT COUNT(*) AS TotalRows, MAX(__mj_UpdatedAt) AS MaxUpdatedAt FROM [${entityInfo.SchemaName}].${entityInfo.BaseView}${whereSQL ? ' WHERE ' + whereSQL : ''}`;
+            sqlStatements.push(statusSQL);
+        }
         try {
-            let sWhere = viewEntity.WhereClause;
-            if (sWhere && sWhere.length > 0) {
-                // check for the existence of one or more templated values in the where clause which will follow the nunjucks format of {%variable%}
-                const templateRegex = /{%([^%]+)%}/g;
-                const matches = sWhere.match(templateRegex);
-                if (matches) {
-                    for (const match of matches) {
-                        const variable = match.substring(2, match.length - 2); // remove the {% and %}
-                        // the variable has a name and a parameter value for example {%UserView "123456"%}
-                        // where UserView is the variable name and 123456 is the parameter value, in this case the View ID
-                        // we need to split the variable into its name and parameter value
-                        const parts = variable.split(' ');
-                        const variableName = parts[0];
-                        if (variableName.trim().toLowerCase() === 'userview') {
-                            let variableValue = parts.length > 1 ? parts[1] : null;
-                            // now strip the quotes from the variable value if they are there
-                            if (variableValue && variableValue.startsWith('"') && variableValue.endsWith('"'))
-                                variableValue = variableValue.substring(1, variableValue.length - 1);
-                            if (stack.includes(variable))
-                                throw new Error(`Circular reference detected in view where clause for variable ${variable}`);
-                            else
-                                stack.push(variable); // add to the stack for circular reference detection
-                            // variable values is the view ID of the view that we want to get its WHERE CLAUSE, so we need to get the view entity
-                            const innerViewEntity = await ViewInfo.GetViewEntity(variableValue, user);
-                            if (innerViewEntity) {
-                                // we have the inner view, so now call this function recursively to get the where clause for the inner view
-                                const innerWhere = await this.RenderViewWhereClause(innerViewEntity, user, stack);
-                                const innerSQL = `SELECT [${innerViewEntity.ViewEntityInfo.FirstPrimaryKey.Name}] FROM [${innerViewEntity.ViewEntityInfo.SchemaName}].[${innerViewEntity.ViewEntityInfo.BaseView}] WHERE (${innerWhere})`;
-                                sWhere = sWhere.replace(match, innerSQL);
-                            }
-                            else
-                                throw new Error(`View ID ${variableValue} not found in metadata`);
-                        }
-                        else {
-                            // we don't know what this variable is, so throw an error
-                            throw new Error(`Unknown variable ${variableName} as part of template match ${match} in view where clause`);
-                        }
-                    }
+            // Execute the batched SQL using existing ExecuteSQLBatch method
+            const resultSets = await this.ExecuteSQLBatch(sqlStatements, undefined, undefined, contextUser);
+            // Process each result set and map to the corresponding item index
+            for (let i = 0; i < items.length; i++) {
+                const { index } = items[i];
+                const resultSet = resultSets[i];
+                if (resultSet && resultSet.length > 0) {
+                    const row = resultSet[0];
+                    results.set(index, {
+                        success: true,
+                        rowCount: row.TotalRows,
+                        maxUpdatedAt: row.MaxUpdatedAt ? new Date(row.MaxUpdatedAt).toISOString() : undefined,
+                    });
                 }
                 else {
-                    // no matches, just a regular old SQL where clause, so we're done, do nothing here as the return process will be below
+                    results.set(index, { success: true, rowCount: 0, maxUpdatedAt: undefined });
                 }
             }
-            return sWhere;
         }
         catch (e) {
-            LogError(e);
-            throw e;
+            // If batch fails, mark all items as failed
+            const errorMessage = e instanceof Error ? e.message : String(e);
+            for (const { index } of items) {
+                results.set(index, { success: false, errorMessage });
+            }
         }
+        return results;
+    }
+    async executeSQLForUserViewRunLogging(viewId, entityBaseView, whereSQL, orderBySQL, user) {
+        const entityInfo = this.Entities.find((e) => e.BaseView.trim().toLowerCase() === entityBaseView.trim().toLowerCase());
+        const sSQL = `
+            DECLARE @ViewIDList TABLE ( ID NVARCHAR(255) );
+            INSERT INTO @ViewIDList (ID) (SELECT ${entityInfo.FirstPrimaryKey.Name} FROM [${entityInfo.SchemaName}].${entityBaseView} WHERE (${whereSQL}))
+            EXEC [${this.MJCoreSchemaName}].spCreateUserViewRunWithDetail(${viewId},${user.Email}, @ViewIDLIst)
+            `;
+        const runIDResult = await this.ExecuteSQL(sSQL, undefined, undefined, user);
+        const runID = runIDResult[0].UserViewRunID;
+        const sRetSQL = `SELECT * FROM [${entityInfo.SchemaName}].${entityBaseView} WHERE ${entityInfo.FirstPrimaryKey.Name} IN
+                                    (SELECT RecordID FROM [${this.MJCoreSchemaName}].vwUserViewRunDetails WHERE UserViewRunID=${runID})
+                                 ${orderBySQL && orderBySQL.length > 0 ? ` ORDER BY ${orderBySQL}` : ''}`;
+        return { executeViewSQL: sRetSQL, runID };
     }
     /**************************************************************************/
-    // START ---- IRunViewProvider
-    /**************************************************************************/
-    async InternalRunView(params, contextUser) {
-        // This is the internal implementation - pre/post processing is handled by ProviderBase.RunView()
-        // Log aggregate input for debugging
-        if (params?.Aggregates?.length) {
-            LogStatus(`[SQLServerDataProvider] InternalRunView received aggregates: entityName=${params.EntityName}, viewID=${params.ViewID}, viewName=${params.ViewName}, aggregateCount=${params.Aggregates.length}, aggregates=${JSON.stringify(params.Aggregates.map(a => ({ expression: a.expression, alias: a.alias })))}`);
-        }
-        const startTime = new Date();
-        try {
-            if (params) {
-                const user = contextUser ? contextUser : this.CurrentUser;
-                if (!user)
-                    throw new Error(`User not found in metadata and no contextUser provided to RunView()`);
-                let viewEntity = null, entityInfo = null;
-                if (params.ViewEntity)
-                    viewEntity = params.ViewEntity;
-                else if (params.ViewID && params.ViewID.length > 0)
-                    viewEntity = await ViewInfo.GetViewEntity(params.ViewID, contextUser);
-                else if (params.ViewName && params.ViewName.length > 0)
-                    viewEntity = await ViewInfo.GetViewEntityByName(params.ViewName, contextUser);
-                if (!viewEntity) {
-                    // if we don't have viewEntity, that means it is a dynamic view, so we need EntityName at a minimum
-                    if (!params.EntityName || params.EntityName.length === 0)
-                        throw new Error(`EntityName is required when ViewID or ViewName is not provided`);
-                    entityInfo = this.Entities.find((e) => e.Name.trim().toLowerCase() === params.EntityName.trim().toLowerCase());
-                    if (!entityInfo)
-                        throw new Error(`Entity ${params.EntityName} not found in metadata`);
-                }
-                else {
-                    entityInfo = this.Entities.find((e) => e.ID === viewEntity.EntityID);
-                    if (!entityInfo)
-                        throw new Error(`Entity ID: ${viewEntity.EntityID} not found in metadata`);
-                }
-                // check permissions now, this call will throw an error if the user doesn't have permission
-                this.CheckUserReadPermissions(entityInfo.Name, user);
-                // get other variaables from params
-                const extraFilter = params.ExtraFilter;
-                const userSearchString = params.UserSearchString;
-                const excludeUserViewRunID = params.ExcludeUserViewRunID;
-                const overrideExcludeFilter = params.OverrideExcludeFilter;
-                const saveViewResults = params.SaveViewResults;
-                let topSQL = '';
-                // Only use TOP if we're NOT using OFFSET/FETCH pagination
-                const usingPagination = params.MaxRows && params.MaxRows > 0 && (params.StartRow !== undefined && params.StartRow >= 0);
-                if (params.IgnoreMaxRows === true) {
-                    // do nothing, leave it blank, this structure is here to make the code easier to read
-                }
-                else if (usingPagination) {
-                    // When using OFFSET/FETCH, don't add TOP clause
-                    // do nothing, leave it blank
-                }
-                else if (params.MaxRows && params.MaxRows > 0) {
-                    // user provided a max rows, so we use that (but not using pagination)
-                    topSQL = 'TOP ' + params.MaxRows;
-                }
-                else if (entityInfo.UserViewMaxRows && entityInfo.UserViewMaxRows > 0) {
-                    topSQL = 'TOP ' + entityInfo.UserViewMaxRows;
-                }
-                const fields = this.getRunTimeViewFieldString(params, viewEntity);
-                let viewSQL = `SELECT ${topSQL} ${fields} FROM [${entityInfo.SchemaName}].${entityInfo.BaseView}`;
-                // We need countSQL for pagination (to get total count) or when using TOP (to show limited vs total)
-                let countSQL = (usingPagination || (topSQL && topSQL.length > 0)) ? `SELECT COUNT(*) AS TotalRowCount FROM [${entityInfo.SchemaName}].${entityInfo.BaseView}` : null;
-                let whereSQL = '';
-                let bHasWhere = false;
-                let userViewRunID = '';
-                // The view may have a where clause that is part of the view definition. If so, we need to add it to the SQL
-                if (viewEntity?.WhereClause && viewEntity?.WhereClause.length > 0) {
-                    const renderedWhere = await this.RenderViewWhereClause(viewEntity, contextUser);
-                    whereSQL = `(${renderedWhere})`;
-                    bHasWhere = true;
-                }
-                // a developer calling the function can provide an additional Extra Filter which is any valid SQL exprssion that can be added to the WHERE clause
-                if (extraFilter && extraFilter.length > 0) {
-                    // extra filter is simple- we just AND it to the where clause if it exists, or we add it as a where clause if there was no prior WHERE
-                    if (!this.validateUserProvidedSQLClause(extraFilter))
-                        throw new Error(`Invalid Extra Filter: ${extraFilter}, contains one more for forbidden keywords`);
-                    if (bHasWhere) {
-                        whereSQL += ` AND (${extraFilter})`;
-                    }
-                    else {
-                        whereSQL = `(${extraFilter})`;
-                        bHasWhere = true;
-                    }
-                }
-                // check for a user provided search string and generate SQL as needed if provided
-                if (userSearchString && userSearchString.length > 0) {
-                    if (!this.validateUserProvidedSQLClause(userSearchString))
-                        throw new Error(`Invalid User Search SQL clause: ${userSearchString}, contains one more for forbidden keywords`);
-                    const sUserSearchSQL = this.createViewUserSearchSQL(entityInfo, userSearchString);
-                    if (sUserSearchSQL.length > 0) {
-                        if (bHasWhere) {
-                            whereSQL += ` AND (${sUserSearchSQL})`;
-                        }
-                        else {
-                            whereSQL = `(${sUserSearchSQL})`;
-                            bHasWhere = true;
-                        }
-                    }
-                }
-                // now, check for an exclude UserViewRunID, or exclusion of ALL prior runs
-                // if provided, we need to exclude the records that were part of that run (or all prior runs)
-                if ((excludeUserViewRunID && excludeUserViewRunID.length > 0) || params.ExcludeDataFromAllPriorViewRuns === true) {
-                    let sExcludeSQL = `ID NOT IN (SELECT RecordID FROM [${this.MJCoreSchemaName}].vwUserViewRunDetails WHERE EntityID='${viewEntity.EntityID}' AND`;
-                    if (params.ExcludeDataFromAllPriorViewRuns === true)
-                        sExcludeSQL += ` UserViewID=${viewEntity.ID})`; // exclude ALL prior runs for this view, we do NOT need to also add the UserViewRunID even if it was provided because this will automatically filter that out too
-                    else
-                        sExcludeSQL += `UserViewRunID=${excludeUserViewRunID})`; // exclude just the run that was provided
-                    if (overrideExcludeFilter && overrideExcludeFilter.length > 0) {
-                        if (!this.validateUserProvidedSQLClause(overrideExcludeFilter))
-                            throw new Error(`Invalid OverrideExcludeFilter: ${overrideExcludeFilter}, contains one more for forbidden keywords`);
-                        // add in the OVERRIDE filter with an OR statement, this results in those rows that match the Exclude filter to be included
-                        // even if they're in the UserViewRunID that we're excluding
-                        sExcludeSQL += ' OR (' + overrideExcludeFilter + ')';
-                    }
-                    if (bHasWhere) {
-                        whereSQL += ` AND (${sExcludeSQL})`;
-                    }
-                    else {
-                        whereSQL = `(${sExcludeSQL})`;
-                        bHasWhere = true;
-                    }
-                }
-                // NEXT, apply Row Level Security (RLS)
-                if (!entityInfo.UserExemptFromRowLevelSecurity(user, EntityPermissionType.Read)) {
-                    // user is NOT exempt from RLS, so we need to apply it
-                    const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, EntityPermissionType.Read, '');
-                    if (rlsWhereClause && rlsWhereClause.length > 0) {
-                        if (bHasWhere) {
-                            whereSQL += ` AND (${rlsWhereClause})`;
-                        }
-                        else {
-                            whereSQL = `(${rlsWhereClause})`;
-                            bHasWhere = true;
-                        }
-                    }
-                }
-                if (bHasWhere) {
-                    viewSQL += ` WHERE ${whereSQL}`;
-                    if (countSQL)
-                        countSQL += ` WHERE ${whereSQL}`;
-                }
-                // figure out the sorting for the view
-                // first check params.OrderBy, that takes first priority
-                // if that's not provided, then we check the view definition for its SortState
-                // if that's not provided we do NOT sort
-                const orderBy = params.OrderBy ? params.OrderBy : viewEntity ? viewEntity.OrderByClause : '';
-                // if we're saving the view results, we need to wrap the entire SQL statement
-                if (viewEntity?.ID && viewEntity?.ID.length > 0 && saveViewResults && user) {
-                    const { executeViewSQL, runID } = await this.executeSQLForUserViewRunLogging(viewEntity.ID, viewEntity.EntityBaseView, whereSQL, orderBy, user);
-                    viewSQL = executeViewSQL;
-                    userViewRunID = runID;
-                }
-                else if (orderBy && orderBy.length > 0) {
-                    // we only add order by if we're not doing run logging. This is becuase the run logging will
-                    // add the order by to its SELECT query that pulls from the list of records that were returned
-                    // there is no point in ordering the rows as they are saved into an audit list anyway so no order-by above
-                    // just here for final step before we execute it.
-                    if (!this.validateUserProvidedSQLClause(orderBy))
-                        throw new Error(`Invalid Order By clause: ${orderBy}, contains one more for forbidden keywords`);
-                    viewSQL += ` ORDER BY ${orderBy}`;
-                }
-                // Apply pagination using OFFSET/FETCH if both MaxRows and StartRow are specified
-                if (params.MaxRows && params.MaxRows > 0 && (params.StartRow !== undefined && params.StartRow >= 0) && entityInfo.FirstPrimaryKey) {
-                    // If no ORDER BY was already added, add one based on primary key (required for OFFSET/FETCH)
-                    if (!orderBy) {
-                        viewSQL += ` ORDER BY ${entityInfo.FirstPrimaryKey.Name} `;
-                    }
-                    viewSQL += ` OFFSET ${params.StartRow} ROWS FETCH NEXT ${params.MaxRows} ROWS ONLY`;
-                }
-                // Build aggregate SQL if aggregates are requested
-                let aggregateSQL = null;
-                let aggregateValidationErrors = [];
-                if (params.Aggregates && params.Aggregates.length > 0) {
-                    const aggregateBuild = this.buildAggregateSQL(params.Aggregates, entityInfo, entityInfo.SchemaName, entityInfo.BaseView, whereSQL);
-                    aggregateSQL = aggregateBuild.aggregateSQL;
-                    aggregateValidationErrors = aggregateBuild.validationErrors;
-                }
-                // Execute queries in parallel for better performance
-                // - Data query (if not count_only)
-                // - Count query (if needed)
-                // - Aggregate query (if aggregates requested)
-                const queries = [];
-                const queryKeys = [];
-                // Data query
-                if (params.ResultType !== 'count_only') {
-                    queries.push(this.ExecuteSQL(viewSQL, undefined, undefined, contextUser));
-                    queryKeys.push('data');
-                }
-                // Count query (run in parallel if we'll need it)
-                const maxRowsUsed = params.MaxRows || entityInfo.UserViewMaxRows;
-                const willNeedCount = countSQL && (usingPagination || params.ResultType === 'count_only');
-                if (willNeedCount) {
-                    queries.push(this.ExecuteSQL(countSQL, undefined, undefined, contextUser));
-                    queryKeys.push('count');
-                }
-                // Aggregate query (runs in parallel with data/count queries)
-                const aggregateStartTime = Date.now();
-                if (aggregateSQL) {
-                    queries.push(this.ExecuteSQL(aggregateSQL, undefined, undefined, contextUser));
-                    queryKeys.push('aggregate');
-                }
-                // Execute all queries in parallel
-                const results = await Promise.all(queries);
-                // Map results back to their queries
-                const resultMap = {};
-                queryKeys.forEach((key, index) => {
-                    resultMap[key] = results[index];
-                });
-                // Process data results
-                let retData = resultMap['data'] || [];
-                // Process rows for datetime conversion and field-level decryption
-                // This is critical for encrypted fields - without this, encrypted data stays encrypted in the UI
-                if (retData.length > 0 && params.ResultType !== 'count_only') {
-                    retData = await this.ProcessEntityRows(retData, entityInfo, contextUser);
-                }
-                // Process count results - also check if we need count based on result length
-                let rowCount = null;
-                if (willNeedCount && resultMap['count']) {
-                    const countResult = resultMap['count'];
-                    if (countResult && countResult.length > 0) {
-                        rowCount = countResult[0].TotalRowCount;
-                    }
-                }
-                else if (countSQL && maxRowsUsed && retData.length === maxRowsUsed) {
-                    // Need to run count query because we hit the limit
-                    const countResult = await this.ExecuteSQL(countSQL, undefined, undefined, contextUser);
-                    if (countResult && countResult.length > 0) {
-                        rowCount = countResult[0].TotalRowCount;
-                    }
-                }
-                // Process aggregate results
-                let aggregateResults = undefined;
-                let aggregateExecutionTime = undefined;
-                if (params.Aggregates && params.Aggregates.length > 0) {
-                    aggregateExecutionTime = Date.now() - aggregateStartTime;
-                    if (resultMap['aggregate']) {
-                        // Map raw aggregate results back to original expressions
-                        const rawAggregateResult = resultMap['aggregate'];
-                        if (rawAggregateResult && rawAggregateResult.length > 0) {
-                            const row = rawAggregateResult[0];
-                            aggregateResults = [];
-                            let validExprIndex = 0;
-                            for (let i = 0; i < params.Aggregates.length; i++) {
-                                const agg = params.Aggregates[i];
-                                const alias = agg.alias || agg.expression;
-                                // Check if this expression had a validation error
-                                const validationError = aggregateValidationErrors.find(e => e.expression === agg.expression);
-                                if (validationError) {
-                                    aggregateResults.push(validationError);
-                                }
-                                else {
-                                    // Get the value from the result using the numbered alias
-                                    const rawValue = row[`Agg_${validExprIndex}`];
-                                    // Cast to AggregateValue - SQL Server returns numbers, strings, dates, or null
-                                    const value = rawValue === undefined ? null : rawValue;
-                                    aggregateResults.push({
-                                        expression: agg.expression,
-                                        alias: alias,
-                                        value: value,
-                                        error: undefined
-                                    });
-                                    validExprIndex++;
-                                }
-                            }
-                        }
-                    }
-                    else if (aggregateValidationErrors.length > 0) {
-                        // All expressions had validation errors
-                        aggregateResults = aggregateValidationErrors;
-                    }
-                }
-                const stopTime = new Date();
-                if (params.ForceAuditLog ||
-                    (viewEntity?.ID && (extraFilter === undefined || extraFilter === null || extraFilter?.trim().length === 0) && entityInfo.AuditViewRuns)) {
-                    // ONLY LOG TOP LEVEL VIEW EXECUTION - this would be for views with an ID, and don't have ExtraFilter as ExtraFilter
-                    // is only used in the system on a tab or just for ad hoc view execution
-                    // we do NOT want to wait for this, so no await,
-                    this.CreateAuditLogRecord(user, 'Run View', 'Run View', 'Success', JSON.stringify({
-                        ViewID: viewEntity?.ID,
-                        ViewName: viewEntity?.Name,
-                        Description: params.AuditLogDescription,
-                        RowCount: retData.length,
-                        SQL: viewSQL,
-                    }), entityInfo.ID, null, params.AuditLogDescription, null);
-                }
-                const result = {
-                    RowCount: params.ResultType === 'count_only'
-                        ? rowCount
-                        : retData.length /*this property should be total row count if the ResultType='count_only' otherwise it should be the row count of the returned rows */,
-                    TotalRowCount: rowCount ? rowCount : retData.length,
-                    Results: retData,
-                    UserViewRunID: userViewRunID,
-                    ExecutionTime: stopTime.getTime() - startTime.getTime(),
-                    Success: true,
-                    ErrorMessage: null,
-                    AggregateResults: aggregateResults,
-                    AggregateExecutionTime: aggregateExecutionTime,
-                };
-                return result;
-            }
-            else {
-                return null;
-            }
-        }
-        catch (e) {
-            const exceptionStopTime = new Date();
-            LogError(e);
-            return {
-                RowCount: 0,
-                TotalRowCount: 0,
-                Results: [],
-                UserViewRunID: '',
-                ExecutionTime: exceptionStopTime.getTime() - startTime.getTime(),
-                Success: false,
-                ErrorMessage: e.message,
-            };
-        }
-    }
-    async InternalRunViews(params, contextUser) {
-        // This is the internal implementation - pre/post processing is handled by ProviderBase.RunViews()
-        // Note: We call InternalRunView directly since we're already inside the internal flow
-        const promises = params.map((p) => this.InternalRunView(p, contextUser));
-        const results = await Promise.all(promises);
-        return results;
-    }
-    /**
-     * RunViewsWithCacheCheck - Smart cache validation for batch RunViews.
-     * For each view request, if cacheStatus is provided, first checks if the cache is current
-     * by comparing MAX(__mj_UpdatedAt) and COUNT(*) with client's values.
-     * Returns 'current' if cache is valid (no data), or 'stale' with fresh data if cache is outdated.
-     *
-     * Optimized to batch all cache status checks into a single SQL call with multiple result sets.
-     */
-    async RunViewsWithCacheCheck(params, contextUser) {
-        try {
-            const user = contextUser || this.CurrentUser;
-            if (!user) {
-                return {
-                    success: false,
-                    results: [],
-                    errorMessage: 'No user context available',
-                };
-            }
-            // Separate items that need cache check from those that don't
-            const itemsNeedingCacheCheck = [];
-            const itemsWithoutCacheCheck = [];
-            const errorResults = [];
-            // Pre-process all items to build WHERE clauses and validate
-            for (let i = 0; i < params.length; i++) {
-                const item = params[i];
-                if (!item.cacheStatus) {
-                    // No cache status - will run full query
-                    itemsWithoutCacheCheck.push({ index: i, item });
-                    continue;
-                }
-                // Get entity info
-                const entityInfo = this.Entities.find((e) => e.Name.trim().toLowerCase() === item.params.EntityName?.trim().toLowerCase());
-                if (!entityInfo) {
-                    errorResults.push({
-                        viewIndex: i,
-                        status: 'error',
-                        errorMessage: `Entity ${item.params.EntityName} not found in metadata`,
-                    });
-                    continue;
-                }
-                try {
-                    // Check permissions
-                    this.CheckUserReadPermissions(entityInfo.Name, user);
-                    // Build WHERE clause
-                    const whereSQL = await this.buildWhereClauseForCacheCheck(item.params, entityInfo, user);
-                    itemsNeedingCacheCheck.push({ index: i, item, entityInfo, whereSQL });
-                }
-                catch (e) {
-                    errorResults.push({
-                        viewIndex: i,
-                        status: 'error',
-                        errorMessage: e instanceof Error ? e.message : String(e),
-                    });
-                }
-            }
-            // Execute batched cache status check for all items that need it
-            const cacheStatusResults = await this.getBatchedServerCacheStatus(itemsNeedingCacheCheck, contextUser);
-            // Determine which items are current vs stale, and whether they support differential updates
-            const differentialItems = [];
-            const staleItemsNoTracking = [];
-            const currentResults = [];
-            for (const { index, item, entityInfo, whereSQL } of itemsNeedingCacheCheck) {
-                const serverStatus = cacheStatusResults.get(index);
-                if (!serverStatus || !serverStatus.success) {
-                    errorResults.push({
-                        viewIndex: index,
-                        status: 'error',
-                        errorMessage: serverStatus?.errorMessage || 'Failed to get cache status',
-                    });
-                    continue;
-                }
-                const isCurrent = this.isCacheCurrent(item.cacheStatus, serverStatus);
-                if (isCurrent) {
-                    currentResults.push({
-                        viewIndex: index,
-                        status: 'current',
-                    });
-                }
-                else {
-                    // Cache is stale - check if entity supports differential updates
-                    if (entityInfo.TrackRecordChanges) {
-                        // Entity tracks record changes - we can do differential update
-                        differentialItems.push({
-                            index,
-                            params: item.params,
-                            entityInfo,
-                            whereSQL,
-                            clientMaxUpdatedAt: item.cacheStatus.maxUpdatedAt,
-                            clientRowCount: item.cacheStatus.rowCount,
-                            serverStatus,
-                        });
-                    }
-                    else {
-                        // Entity doesn't track record changes - fall back to full refresh
-                        staleItemsNoTracking.push({ index, params: item.params });
-                    }
-                }
-            }
-            // Run queries in parallel:
-            // 1. Items without cache status (no fingerprint from client) - full query
-            // 2. Items with stale cache but no tracking - full query
-            // 3. Items with stale cache and tracking - differential query
-            const queryPromises = [
-                // Full queries for items without cache status
-                ...itemsWithoutCacheCheck.map(({ index, item }) => this.runFullQueryAndReturn(item.params, index, contextUser)),
-                // Full queries for entities that don't track record changes
-                ...staleItemsNoTracking.map(({ index, params: viewParams }) => this.runFullQueryAndReturn(viewParams, index, contextUser)),
-                // Differential queries for entities that track record changes
-                ...differentialItems.map(({ index, params: viewParams, entityInfo, whereSQL, clientMaxUpdatedAt, clientRowCount, serverStatus }) => this.runDifferentialQueryAndReturn(viewParams, entityInfo, clientMaxUpdatedAt, clientRowCount, serverStatus, whereSQL, index, contextUser)),
-            ];
-            const fullQueryResults = await Promise.all(queryPromises);
-            // Combine all results and sort by viewIndex
-            const allResults = [...errorResults, ...currentResults, ...fullQueryResults];
-            allResults.sort((a, b) => a.viewIndex - b.viewIndex);
-            return {
-                success: true,
-                results: allResults,
-            };
-        }
-        catch (e) {
-            LogError(e);
-            return {
-                success: false,
-                results: [],
-                errorMessage: e instanceof Error ? e.message : String(e),
-            };
-        }
-    }
-    /**
-     * Executes a batched cache status check for multiple views in a single SQL call.
-     * Uses multiple result sets to return status for each view efficiently.
-     */
-    async getBatchedServerCacheStatus(items, contextUser) {
-        const results = new Map();
-        if (items.length === 0) {
-            return results;
-        }
-        // Build array of SQL statements for batch execution
-        const sqlStatements = [];
-        for (const { entityInfo, whereSQL } of items) {
-            const statusSQL = `SELECT COUNT(*) AS TotalRows, MAX(__mj_UpdatedAt) AS MaxUpdatedAt FROM [${entityInfo.SchemaName}].${entityInfo.BaseView}${whereSQL ? ' WHERE ' + whereSQL : ''}`;
-            sqlStatements.push(statusSQL);
-        }
-        try {
-            // Execute the batched SQL using existing ExecuteSQLBatch method
-            const resultSets = await this.ExecuteSQLBatch(sqlStatements, undefined, undefined, contextUser);
-            // Process each result set and map to the corresponding item index
-            for (let i = 0; i < items.length; i++) {
-                const { index } = items[i];
-                const resultSet = resultSets[i];
-                if (resultSet && resultSet.length > 0) {
-                    const row = resultSet[0];
-                    results.set(index, {
-                        success: true,
-                        rowCount: row.TotalRows,
-                        maxUpdatedAt: row.MaxUpdatedAt ? new Date(row.MaxUpdatedAt).toISOString() : undefined,
-                    });
-                }
-                else {
-                    results.set(index, { success: true, rowCount: 0, maxUpdatedAt: undefined });
-                }
-            }
-        }
-        catch (e) {
-            // If batch fails, mark all items as failed
-            const errorMessage = e instanceof Error ? e.message : String(e);
-            for (const { index } of items) {
-                results.set(index, { success: false, errorMessage });
-            }
-        }
-        return results;
-    }
-    /**
-     * Builds the WHERE clause for cache status check, using same logic as InternalRunView.
-     */
-    async buildWhereClauseForCacheCheck(params, entityInfo, user) {
-        let whereSQL = '';
-        let bHasWhere = false;
-        // Extra filter
-        if (params.ExtraFilter && params.ExtraFilter.length > 0) {
-            if (!this.validateUserProvidedSQLClause(params.ExtraFilter)) {
-                throw new Error(`Invalid Extra Filter: ${params.ExtraFilter}`);
-            }
-            whereSQL = `(${params.ExtraFilter})`;
-            bHasWhere = true;
-        }
-        // User search string
-        if (params.UserSearchString && params.UserSearchString.length > 0) {
-            if (!this.validateUserProvidedSQLClause(params.UserSearchString)) {
-                throw new Error(`Invalid User Search SQL clause: ${params.UserSearchString}`);
-            }
-            const sUserSearchSQL = this.createViewUserSearchSQL(entityInfo, params.UserSearchString);
-            if (sUserSearchSQL.length > 0) {
-                if (bHasWhere) {
-                    whereSQL += ` AND (${sUserSearchSQL})`;
-                }
-                else {
-                    whereSQL = `(${sUserSearchSQL})`;
-                    bHasWhere = true;
-                }
-            }
-        }
-        // Row Level Security
-        if (!entityInfo.UserExemptFromRowLevelSecurity(user, EntityPermissionType.Read)) {
-            const rlsWhereClause = entityInfo.GetUserRowLevelSecurityWhereClause(user, EntityPermissionType.Read, '');
-            if (rlsWhereClause && rlsWhereClause.length > 0) {
-                if (bHasWhere) {
-                    whereSQL += ` AND (${rlsWhereClause})`;
-                }
-                else {
-                    whereSQL = `(${rlsWhereClause})`;
-                }
-            }
-        }
-        return whereSQL;
-    }
-    /**
-     * Compares client cache status with server status to determine if cache is current.
-     */
-    isCacheCurrent(clientStatus, serverStatus) {
-        // Row count must match
-        if (clientStatus.rowCount !== serverStatus.rowCount) {
-            return false;
-        }
-        // Compare maxUpdatedAt dates
-        const clientDate = new Date(clientStatus.maxUpdatedAt);
-        const serverDate = serverStatus.maxUpdatedAt ? new Date(serverStatus.maxUpdatedAt) : null;
-        if (!serverDate) {
-            // No records on server, so if client has any, it's stale
-            return clientStatus.rowCount === 0;
-        }
-        // Dates must match (compare as ISO strings for precision)
-        return clientDate.toISOString() === serverDate.toISOString();
-    }
-    /**
-     * Runs the full query and returns results with cache metadata.
-     */
-    async runFullQueryAndReturn(params, viewIndex, contextUser) {
-        const result = await this.InternalRunView(params, contextUser);
-        if (!result.Success) {
-            return {
-                viewIndex,
-                status: 'error',
-                errorMessage: result.ErrorMessage || 'Unknown error executing view',
-            };
-        }
-        // Extract maxUpdatedAt from results
-        const maxUpdatedAt = this.extractMaxUpdatedAt(result.Results);
-        return {
-            viewIndex,
-            status: 'stale',
-            results: result.Results,
-            maxUpdatedAt,
-            rowCount: result.Results.length,
-        };
-    }
-    /**
-     * Extracts the maximum __mj_UpdatedAt value from a result set.
-     * @param results - Array of result objects that may contain __mj_UpdatedAt
-     * @returns ISO string of the max timestamp, or current time if none found
-     */
-    extractMaxUpdatedAt(results) {
-        if (!results || results.length === 0) {
-            return new Date().toISOString();
-        }
-        let maxDate = null;
-        for (const row of results) {
-            const rowObj = row;
-            const updatedAt = rowObj['__mj_UpdatedAt'];
-            if (updatedAt) {
-                const date = new Date(updatedAt);
-                if (!isNaN(date.getTime()) && (!maxDate || date > maxDate)) {
-                    maxDate = date;
-                }
-            }
-        }
-        return maxDate ? maxDate.toISOString() : new Date().toISOString();
-    }
-    /**
-     * Gets the IDs of records that have been deleted since a given timestamp.
-     * Uses the RecordChange table which tracks all deletions for entities with TrackRecordChanges enabled.
-     * @param entityID - The entity ID to check deletions for
-     * @param sinceTimestamp - ISO timestamp to check deletions since
-     * @param contextUser - Optional user context for permissions
-     * @returns Array of record IDs (in CompositeKey concatenated string format)
-     */
-    async getDeletedRecordIDsSince(entityID, sinceTimestamp, contextUser) {
-        try {
-            const sql = `
-        SELECT DISTINCT RecordID
-        FROM [${this.MJCoreSchemaName}].vwRecordChanges
-        WHERE EntityID = '${entityID}'
-          AND Type = 'Delete'
-          AND ChangedAt > '${sinceTimestamp}'
-      `;
-            const results = await this.ExecuteSQL(sql, undefined, undefined, contextUser);
-            return results.map(r => r.RecordID);
-        }
-        catch (e) {
-            LogError(e);
-            return [];
-        }
-    }
-    /**
-     * Gets rows that have been created or updated since a given timestamp.
-     * @param params - RunView parameters (used for entity, filter, etc.)
-     * @param entityInfo - Entity metadata
-     * @param sinceTimestamp - ISO timestamp to check updates since
-     * @param whereSQL - Pre-built WHERE clause from the original query
-     * @param contextUser - Optional user context for permissions
-     * @returns Array of updated/created rows
-     */
-    async getUpdatedRowsSince(params, entityInfo, sinceTimestamp, whereSQL, contextUser) {
-        try {
-            // Add the timestamp filter to the existing WHERE clause
-            const timestampFilter = `__mj_UpdatedAt > '${sinceTimestamp}'`;
-            const combinedWhere = whereSQL
-                ? `(${whereSQL}) AND ${timestampFilter}`
-                : timestampFilter;
-            // Build field list
-            const fields = params.Fields && params.Fields.length > 0
-                ? params.Fields.map(f => `[${f}]`).join(', ')
-                : '*';
-            // Build the query
-            let sql = `SELECT ${fields} FROM [${entityInfo.SchemaName}].${entityInfo.BaseView} WHERE ${combinedWhere}`;
-            // Add ORDER BY if specified
-            if (params.OrderBy && params.OrderBy.length > 0) {
-                if (!this.validateUserProvidedSQLClause(params.OrderBy)) {
-                    throw new Error(`Invalid OrderBy clause: ${params.OrderBy}`);
-                }
-                sql += ` ORDER BY ${params.OrderBy}`;
-            }
-            const results = await this.ExecuteSQL(sql, undefined, undefined, contextUser);
-            return results;
-        }
-        catch (e) {
-            LogError(e);
-            return [];
-        }
-    }
-    /**
-     * Runs a differential query and returns only changes since the client's cached state.
-     * This includes updated/created rows and deleted record IDs.
-     *
-     * Validates that the differential can be safely applied by checking for "hidden" deletes
-     * (rows deleted outside of MJ's RecordChanges tracking, e.g., direct SQL deletes).
-     * If hidden deletes are detected, falls back to a full query with 'stale' status.
-     *
-     * @param params - RunView parameters
-     * @param entityInfo - Entity metadata
-     * @param clientMaxUpdatedAt - Client's cached maxUpdatedAt timestamp
-     * @param clientRowCount - Client's cached row count
-     * @param serverStatus - Current server status (for new row count)
-     * @param whereSQL - Pre-built WHERE clause
-     * @param viewIndex - Index for correlation in batch operations
-     * @param contextUser - Optional user context
-     * @returns RunViewWithCacheCheckResult with differential data, or falls back to full query if unsafe
-     */
-    async runDifferentialQueryAndReturn(params, entityInfo, clientMaxUpdatedAt, clientRowCount, serverStatus, whereSQL, viewIndex, contextUser) {
-        try {
-            // Get updated/created rows since client's timestamp
-            const updatedRows = await this.getUpdatedRowsSince(params, entityInfo, clientMaxUpdatedAt, whereSQL, contextUser);
-            // Get deleted record IDs since client's timestamp
-            const deletedRecordIDs = await this.getDeletedRecordIDsSince(entityInfo.ID, clientMaxUpdatedAt, contextUser);
-            // === VALIDATION: Detect "hidden" deletes not tracked in RecordChanges ===
-            // Count how many returned rows are NEW (created after client's cache timestamp)
-            // vs rows that already existed and were just updated
-            const clientMaxUpdatedDate = new Date(clientMaxUpdatedAt);
-            const newInserts = updatedRows.filter(row => {
-                const createdAt = row['__mj_CreatedAt'];
-                if (!createdAt)
-                    return false;
-                return new Date(String(createdAt)) > clientMaxUpdatedDate;
-            }).length;
-            // Calculate implied deletes using the algebra:
-            // serverRowCount = clientRowCount - deletes + inserts
-            // Therefore: impliedDeletes = clientRowCount + newInserts - serverRowCount
-            const serverRowCount = serverStatus.rowCount ?? 0;
-            const impliedDeletes = clientRowCount + newInserts - serverRowCount;
-            const actualDeletes = deletedRecordIDs.length;
-            // Validate: if impliedDeletes < 0, there are unexplained rows on the server
-            // This could happen with direct SQL inserts that bypassed MJ's tracking
-            if (impliedDeletes < 0) {
-                LogStatus(`Differential validation failed for ${entityInfo.Name}: impliedDeletes=${impliedDeletes} (negative). ` +
-                    `clientRowCount=${clientRowCount}, newInserts=${newInserts}, serverRowCount=${serverRowCount}. ` +
-                    `Falling back to full refresh.`);
-                return this.runFullQueryAndReturn(params, viewIndex, contextUser);
-            }
-            // Validate: if impliedDeletes > actualDeletes, there are "hidden" deletes
-            // not tracked in RecordChanges (e.g., direct SQL deletes)
-            if (impliedDeletes > actualDeletes) {
-                LogStatus(`Differential validation failed for ${entityInfo.Name}: hidden deletes detected. ` +
-                    `impliedDeletes=${impliedDeletes}, actualDeletes=${actualDeletes}. ` +
-                    `clientRowCount=${clientRowCount}, newInserts=${newInserts}, serverRowCount=${serverRowCount}. ` +
-                    `Falling back to full refresh.`);
-                return this.runFullQueryAndReturn(params, viewIndex, contextUser);
-            }
-            // Validation passed - safe to apply differential
-            // Extract maxUpdatedAt from the updated rows (or use server status)
-            const newMaxUpdatedAt = updatedRows.length > 0
-                ? this.extractMaxUpdatedAt(updatedRows)
-                : serverStatus.maxUpdatedAt || new Date().toISOString();
-            return {
-                viewIndex,
-                status: 'differential',
-                differentialData: {
-                    updatedRows,
-                    deletedRecordIDs,
-                },
-                maxUpdatedAt: newMaxUpdatedAt,
-                rowCount: serverStatus.rowCount,
-            };
-        }
-        catch (e) {
-            LogError(e);
-            return {
-                viewIndex,
-                status: 'error',
-                errorMessage: e instanceof Error ? e.message : String(e),
-            };
-        }
-    }
-    validateUserProvidedSQLClause(clause) {
-        // First, remove all string literals from the clause to avoid false positives
-        // This regex matches both single and double quoted strings, handling escaped quotes
-        const stringLiteralPattern = /(['"])(?:(?=(\\?))\2[\s\S])*?\1/g;
-        // Replace all string literals with empty strings for validation purposes
-        const clauseWithoutStrings = clause.replace(stringLiteralPattern, '');
-        // convert the clause to lower case to make the keyword search case-insensitive
-        const lowerClause = clauseWithoutStrings.toLowerCase();
-        // Define forbidden keywords and characters as whole words using regular expressions
-        const forbiddenPatterns = [
-            /\binsert\b/,
-            /\bupdate\b/,
-            /\bdelete\b/,
-            /\bexec\b/,
-            /\bexecute\b/,
-            /\bdrop\b/,
-            /--/,
-            /\/\*/,
-            /\*\//,
-            /\bunion\b/,
-            /\bcast\b/,
-            /\bxp_/,
-            /;/,
-        ];
-        // Check for forbidden patterns
-        for (const pattern of forbiddenPatterns) {
-            if (pattern.test(lowerClause)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Validates and builds an aggregate SQL query from the provided aggregate expressions.
-     * Uses the SQLExpressionValidator to ensure expressions are safe from SQL injection.
-     *
-     * @param aggregates - Array of aggregate expressions to validate and build
-     * @param entityInfo - Entity metadata for field reference validation
-     * @param schemaName - Schema name for the table
-     * @param baseView - Base view name for the table
-     * @param whereSQL - WHERE clause to apply (without the WHERE keyword)
-     * @returns Object with aggregateSQL string and any validation errors
-     */
-    buildAggregateSQL(aggregates, entityInfo, schemaName, baseView, whereSQL) {
-        if (!aggregates || aggregates.length === 0) {
-            return { aggregateSQL: null, validationErrors: [] };
-        }
-        const validator = SQLExpressionValidator.Instance;
-        const validationErrors = [];
-        const validExpressions = [];
-        const fieldNames = entityInfo.Fields.map(f => f.Name);
-        for (let i = 0; i < aggregates.length; i++) {
-            const agg = aggregates[i];
-            const alias = agg.alias || agg.expression;
-            // Validate the expression using SQLExpressionValidator
-            const result = validator.validate(agg.expression, {
-                context: 'aggregate',
-                entityFields: fieldNames
-            });
-            if (!result.valid) {
-                // Record the error but continue processing other expressions
-                validationErrors.push({
-                    expression: agg.expression,
-                    alias: alias,
-                    value: null,
-                    error: result.error || 'Validation failed'
-                });
-            }
-            else {
-                // Expression is valid, add to the query with an alias
-                // Use a numbered alias for the SQL to make result mapping easier
-                validExpressions.push(`${agg.expression} AS [Agg_${i}]`);
-            }
-        }
-        if (validExpressions.length === 0) {
-            return { aggregateSQL: null, validationErrors };
-        }
-        // Build the aggregate SQL query
-        let aggregateSQL = `SELECT ${validExpressions.join(', ')} FROM [${schemaName}].${baseView}`;
-        if (whereSQL && whereSQL.length > 0) {
-            aggregateSQL += ` WHERE ${whereSQL}`;
-        }
-        return { aggregateSQL, validationErrors };
-    }
-    /**
-     * Executes the aggregate query and maps results back to the original expressions.
-     *
-     * @param aggregateSQL - The aggregate SQL query to execute
-     * @param aggregates - Original aggregate expressions (for result mapping)
-     * @param validationErrors - Any validation errors from buildAggregateSQL
-     * @param contextUser - User context for query execution
-     * @returns Array of AggregateResult objects
-     */
-    async executeAggregateQuery(aggregateSQL, aggregates, validationErrors, contextUser) {
-        const startTime = Date.now();
-        if (!aggregateSQL) {
-            // No valid expressions to execute, return only validation errors
-            return { results: validationErrors, executionTime: 0 };
-        }
-        try {
-            const queryResult = await this.ExecuteSQL(aggregateSQL, undefined, undefined, contextUser);
-            const executionTime = Date.now() - startTime;
-            if (!queryResult || queryResult.length === 0) {
-                // Query returned no results, which shouldn't happen for aggregates
-                // Return validation errors plus null values for valid expressions
-                const nullResults = aggregates
-                    .filter((_, i) => !validationErrors.some(e => e.expression === aggregates[i].expression))
-                    .map(agg => ({
-                    expression: agg.expression,
-                    alias: agg.alias || agg.expression,
-                    value: null,
-                    error: undefined
-                }));
-                return { results: [...validationErrors, ...nullResults], executionTime };
-            }
-            // Map query results back to original expressions
-            const row = queryResult[0];
-            const results = [];
-            let validExprIndex = 0;
-            for (let i = 0; i < aggregates.length; i++) {
-                const agg = aggregates[i];
-                const alias = agg.alias || agg.expression;
-                // Check if this expression had a validation error
-                const validationError = validationErrors.find(e => e.expression === agg.expression);
-                if (validationError) {
-                    results.push(validationError);
-                }
-                else {
-                    // Get the value from the result using the numbered alias
-                    const value = row[`Agg_${validExprIndex}`];
-                    results.push({
-                        expression: agg.expression,
-                        alias: alias,
-                        value: value ?? null,
-                        error: undefined
-                    });
-                    validExprIndex++;
-                }
-            }
-            return { results, executionTime };
-        }
-        catch (error) {
-            const executionTime = Date.now() - startTime;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Return all expressions with the error
-            const errorResults = aggregates.map(agg => ({
-                expression: agg.expression,
-                alias: agg.alias || agg.expression,
-                value: null,
-                error: errorMessage
-            }));
-            return { results: errorResults, executionTime };
-        }
-    }
-    getRunTimeViewFieldString(params, viewEntity) {
-        const fieldList = this.getRunTimeViewFieldArray(params, viewEntity);
-        // pass this back as a comma separated list, put square brackets around field names to make sure if they are reserved words or have spaces, that they'll still work.
-        if (fieldList.length === 0)
-            return '*';
-        else
-            return fieldList
-                .map((f) => {
-                const asString = f.CodeName === f.Name ? '' : ` AS [${f.CodeName}]`;
-                return `[${f.Name}]${asString}`;
-            })
-                .join(',');
-    }
-    getRunTimeViewFieldArray(params, viewEntity) {
-        const fieldList = [];
-        try {
-            let entityInfo = null;
-            if (viewEntity) {
-                entityInfo = viewEntity.ViewEntityInfo;
-            }
-            else {
-                entityInfo = this.Entities.find((e) => e.Name === params.EntityName);
-                if (!entityInfo)
-                    throw new Error(`Entity ${params.EntityName} not found in metadata`);
-            }
-            if (params.Fields) {
-                // fields provided, if primary key isn't included, add it first
-                for (const ef of entityInfo.PrimaryKeys) {
-                    if (params.Fields.find((f) => f.trim().toLowerCase() === ef.Name.toLowerCase()) === undefined)
-                        fieldList.push(ef); // always include the primary key fields in view run time field list
-                }
-                // now add the rest of the param.Fields to fields
-                params.Fields.forEach((f) => {
-                    const field = entityInfo.Fields.find((field) => field.Name.trim().toLowerCase() === f.trim().toLowerCase());
-                    if (field)
-                        fieldList.push(field);
-                    else
-                        LogError(`Field ${f} not found in entity ${entityInfo.Name}`);
-                });
-            }
-            else {
-                // fields weren't provided by the caller. So, let's do the following
-                // * if this is a defined view, using a View Name or View ID, we use the fields that are used wtihin the View and always return the ID
-                // * if this is an dynamic view, we return ALL fields in the entity using *
-                if (viewEntity) {
-                    // saved view, figure out it's field list
-                    viewEntity.Columns.forEach((c) => {
-                        if (!c.hidden) {
-                            // only return the non-hidden fields
-                            if (c.EntityField) {
-                                fieldList.push(c.EntityField);
-                            }
-                            else {
-                                LogError(`View Field ${c.Name} doesn't match an Entity Field in entity ${entityInfo.Name}. This can happen if the view was saved with a field that no longer exists in the entity. It is best to update the view to remove this field.`);
-                            }
-                        }
-                    });
-                    // the below shouldn't happen as the pkey fields should always be included by now, but make SURE...
-                    for (const ef of entityInfo.PrimaryKeys) {
-                        if (fieldList.find((f) => f.Name?.trim().toLowerCase() === ef.Name?.toLowerCase()) === undefined)
-                            fieldList.push(ef); // always include the primary key fields in view run time field list
-                    }
-                }
-            }
-        }
-        catch (e) {
-            LogError(e);
-        }
-        finally {
-            return fieldList;
-        }
-    }
-    async executeSQLForUserViewRunLogging(viewId, entityBaseView, whereSQL, orderBySQL, user) {
-        const entityInfo = this.Entities.find((e) => e.BaseView.trim().toLowerCase() === entityBaseView.trim().toLowerCase());
-        const sSQL = `
-            DECLARE @ViewIDList TABLE ( ID NVARCHAR(255) );
-            INSERT INTO @ViewIDList (ID) (SELECT ${entityInfo.FirstPrimaryKey.Name} FROM [${entityInfo.SchemaName}].${entityBaseView} WHERE (${whereSQL}))
-            EXEC [${this.MJCoreSchemaName}].spCreateUserViewRunWithDetail(${viewId},${user.Email}, @ViewIDLIst)
-            `;
-        const runIDResult = await this.ExecuteSQL(sSQL, undefined, undefined, user);
-        const runID = runIDResult[0].UserViewRunID;
-        const sRetSQL = `SELECT * FROM [${entityInfo.SchemaName}].${entityBaseView} WHERE ${entityInfo.FirstPrimaryKey.Name} IN
-                                    (SELECT RecordID FROM [${this.MJCoreSchemaName}].vwUserViewRunDetails WHERE UserViewRunID=${runID})
-                                 ${orderBySQL && orderBySQL.length > 0 ? ` ORDER BY ${orderBySQL}` : ''}`;
-        return { executeViewSQL: sRetSQL, runID };
-    }
-    createViewUserSearchSQL(entityInfo, userSearchString) {
-        // we have a user search string.
-        // if we have full text search, we use that.
-        // Otherwise, we need to manually construct the additional filter associated with this. The user search string is just text from the user
-        // we need to apply it to one or more fields that are part of the entity that support being part of a user search.
-        // we need to get the list of fields that are part of the entity that support being part of a user search.
-        let sUserSearchSQL = '';
-        if (entityInfo.FullTextSearchEnabled) {
-            // we have full text search, so we use that, do as subquery but that gets optimized into JOIN by SQL Server, so we can keep our situation logially simpler
-            // in the context of overall filtering by doing as a SUBQUERY here.
-            // if we have a user search string that includes AND, OR, or NOT, we leave it alone
-            // otherwise, we check to see if the userSearchString is a single word, if so, we also leave it alone
-            // if the userSearchString doesn't have AND OR or NOT in it, and has multiple words, we convert the spaces to
-            // AND so that we can do a full text search on all the words
-            let u = userSearchString;
-            const uUpper = u.toUpperCase();
-            if (uUpper.includes(' AND ') || uUpper.includes(' OR ') || uUpper.includes(' NOT ')) {
-                //replace all spaces with %, but add spaces inbetween the original and, or and not keywords
-                u = uUpper.replace(/ /g, '%').replace(/%AND%/g, ' AND ').replace(/%OR%/g, ' OR ').replace(/%NOT%/g, ' NOT ');
-            }
-            else if (uUpper.includes('AND') || uUpper.includes('OR') || uUpper.includes('NOT')) {
-                //leave the string alone, except replacing spaces with %
-                u = u.replace(/ /g, '%');
-            }
-            else if (u.includes(' ')) {
-                if (u.startsWith('"') && u.endsWith('"')) {
-                    // do nothing because we start AND end with a quote, so we have a phrase search
-                }
-                else {
-                    // we have multiple words, so we need to convert the spaces to AND
-                    // but first, let's strip the stopwords out of the string
-                    u = StripStopWords(userSearchString);
-                    // next, include "AND" between all the words so that we have a full text search on all the words
-                    u = u.replace(/ /g, ' AND ');
-                }
-            }
-            sUserSearchSQL = `${entityInfo.FirstPrimaryKey.Name} IN (SELECT ${entityInfo.FirstPrimaryKey.Name} FROM ${entityInfo.SchemaName}.${entityInfo.FullTextSearchFunction}('${u}'))`;
-        }
-        else {
-            const entityFields = entityInfo.Fields;
-            for (const field of entityFields) {
-                if (field.IncludeInUserSearchAPI) {
-                    let sParam = '';
-                    if (sUserSearchSQL.length > 0)
-                        sUserSearchSQL += ' OR ';
-                    if (field.UserSearchParamFormatAPI && field.UserSearchParamFormatAPI.length > 0)
-                        // we have a search param format. we need to apply it to the user search string
-                        sParam = field.UserSearchParamFormatAPI.replace('{0}', userSearchString);
-                    else
-                        sParam = ` LIKE '%${userSearchString}%'`;
-                    sUserSearchSQL += `(${field.Name} ${sParam})`;
-                }
-            }
-            if (sUserSearchSQL.length > 0)
-                sUserSearchSQL = '(' + sUserSearchSQL + ')'; // wrap the entire search string in parens
-        }
-        return sUserSearchSQL;
-    }
-    async CreateAuditLogRecord(user, authorizationName, auditLogTypeName, status, details, entityId, recordId, auditLogDescription, saveOptions) {
-        try {
-            const authorization = authorizationName
-                ? this.Authorizations.find((a) => a?.Name?.trim().toLowerCase() === authorizationName.trim().toLowerCase())
-                : null;
-            const auditLogType = auditLogTypeName ? this.AuditLogTypes.find((a) => a?.Name?.trim().toLowerCase() === auditLogTypeName.trim().toLowerCase()) : null;
-            if (!user)
-                throw new Error(`User is a required parameter`);
-            if (!auditLogType) {
-                throw new Error(`Audit Log Type ${auditLogTypeName} not found in metadata`);
-            }
-            const auditLog = await this.GetEntityObject('MJ: Audit Logs', user); // must pass user context on back end as we're not authenticated the same way as the front end
-            auditLog.NewRecord();
-            auditLog.UserID = user.ID;
-            auditLog.AuditLogTypeID = auditLogType.ID;
-            if (status?.trim().toLowerCase() === 'success')
-                auditLog.Status = 'Success';
-            else
-                auditLog.Status = 'Failed';
-            auditLog.EntityID = entityId;
-            auditLog.RecordID = recordId;
-            if (authorization)
-                auditLog.AuthorizationID = authorization.ID;
-            if (details)
-                auditLog.Details = details;
-            if (auditLogDescription)
-                auditLog.Description = auditLogDescription;
-            if (await auditLog.Save(saveOptions)) {
-                return auditLog;
-            }
-            else
-                throw new Error(`Error saving audit log record`);
-        }
-        catch (err) {
-            LogError(err);
-            return null;
-        }
-    }
-    CheckUserReadPermissions(entityName, contextUser) {
-        const entityInfo = this.Entities.find((e) => e.Name === entityName);
-        if (!contextUser)
-            throw new Error(`contextUser is null`);
-        // first check permissions, the logged in user must have read permissions on the entity to run the view
-        if (entityInfo) {
-            const userPermissions = entityInfo.GetUserPermisions(contextUser);
-            if (!userPermissions.CanRead)
-                throw new Error(`User ${contextUser.Email} does not have read permissions on ${entityInfo.Name}`);
-        }
-        else
-            throw new Error(`Entity not found in metadata`);
-    }
-    /**************************************************************************/
-    // END ---- IRunViewProvider
+    // END ---- IRunViewProvider
     /**************************************************************************/
     /**************************************************************************/
     // START ---- IEntityDataProvider
@@ -2310,67 +795,6 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
     get ProviderType() {
         return ProviderType.Database;
     }
-    async GetRecordFavoriteStatus(userId, entityName, CompositeKey, contextUser) {
-        const id = await this.GetRecordFavoriteID(userId, entityName, CompositeKey, contextUser);
-        return id !== null;
-    }
-    async GetRecordFavoriteID(userId, entityName, CompositeKey, contextUser) {
-        try {
-            const sSQL = `SELECT ID FROM [${this.MJCoreSchemaName}].vwUserFavorites WHERE UserID='${userId}' AND Entity='${entityName}' AND RecordID='${CompositeKey.Values()}'`;
-            const result = await this.ExecuteSQL(sSQL, null, undefined, contextUser);
-            if (result && result.length > 0)
-                return result[0].ID;
-            else
-                return null;
-        }
-        catch (e) {
-            LogError(e);
-            throw e;
-        }
-    }
-    async SetRecordFavoriteStatus(userId, entityName, CompositeKey, isFavorite, contextUser) {
-        try {
-            const currentFavoriteId = await this.GetRecordFavoriteID(userId, entityName, CompositeKey);
-            if ((currentFavoriteId === null && isFavorite === false) || (currentFavoriteId !== null && isFavorite === true))
-                return; // no change
-            // if we're here that means we need to invert the status, which either means creating a record or deleting a record
-            const e = this.Entities.find((e) => e.Name === entityName);
-            const ufEntity = await this.GetEntityObject('MJ: User Favorites', contextUser || this.CurrentUser);
-            if (currentFavoriteId !== null) {
-                // delete the record since we are setting isFavorite to FALSE
-                await ufEntity.Load(currentFavoriteId);
-                if (await ufEntity.Delete())
-                    return;
-                else
-                    throw new Error(`Error deleting user favorite`);
-            }
-            else {
-                // create the record since we are setting isFavorite to TRUE
-                ufEntity.NewRecord();
-                ufEntity.Set('EntityID', e.ID);
-                ufEntity.Set('RecordID', CompositeKey.Values()); // this is a comma separated list of primary key values, which is fine as the primary key is a string
-                ufEntity.Set('UserID', userId);
-                if (await ufEntity.Save())
-                    return;
-                else
-                    throw new Error(`Error saving user favorite`);
-            }
-        }
-        catch (e) {
-            LogError(e);
-            throw e;
-        }
-    }
-    async GetRecordChanges(entityName, compositeKey, contextUser) {
-        try {
-            const sSQL = `SELECT * FROM [${this.MJCoreSchemaName}].vwRecordChanges WHERE Entity='${entityName}' AND RecordID='${compositeKey.ToConcatenatedString()}' ORDER BY ChangedAt DESC`;
-            return this.ExecuteSQL(sSQL, undefined, undefined, contextUser);
-        }
-        catch (e) {
-            LogError(e);
-            throw e;
-        }
-    }
     /**
      * This function will generate SQL statements for all of the possible soft links that are not traditional foreign keys but exist in entities
      * where there is a column that has the EntityIDFieldName set to a column name (not null). We need to get a list of all such soft link fields across ALL entities
@@ -2378,7 +802,7 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
      * @param entityName
      * @param compositeKey
      */
-    GetSoftLinkDependencySQL(entityName, compositeKey) {
+    BuildSoftLinkDependencySQL(entityName, compositeKey) {
         // we need to go through ALL of the entities in the system and find all of the EntityFields that have a non-null EntityIDFieldName
         // for each of these, we generate a SQL Statement that will return the EntityName, RelatedEntityName, FieldName, and the primary key values of the related entity
         let sSQL = '';
@@ -2410,7 +834,7 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         });
         return sSQL;
     }
-    GetHardLinkDependencySQL(entityDependencies, compositeKey) {
+    BuildHardLinkDependencySQL(entityDependencies, compositeKey) {
         let sSQL = '';
         for (const entityDependency of entityDependencies) {
             const entityInfo = this.Entities.find((e) => e.Name.trim().toLowerCase() === entityDependency.EntityName?.trim().toLowerCase());
@@ -2431,67 +855,6 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         }
         return sSQL;
     }
-    /**
-     * Returns a list of dependencies - records that are linked to the specified Entity/RecordID combination. A dependency is as defined by the relationships in the database. The MemberJunction metadata that is used
-     * for this simply reflects the foreign key relationships that exist in the database. The CodeGen tool is what detects all of the relationships and generates the metadata that is used by MemberJunction. The metadata in question
-     * is within the EntityField table and specifically the RelatedEntity and RelatedEntityField columns. In turn, this method uses that metadata and queries the database to determine the dependencies. To get the list of entity dependencies
-     * you can use the utility method GetEntityDependencies(), which doesn't check for dependencies on a specific record, but rather gets the metadata in one shot that can be used for dependency checking.
-     * @param entityName the name of the entity to check
-     * @param KeyValuePairs the primary key(s) to check - only send multiple if you have an entity with a composite primary key
-     */
-    async GetRecordDependencies(entityName, compositeKey, contextUser) {
-        try {
-            const recordDependencies = [];
-            // first, get the entity dependencies for this entity
-            const entityDependencies = await this.GetEntityDependencies(entityName);
-            if (entityDependencies.length === 0) {
-                // no dependencies, exit early
-                return recordDependencies;
-            }
-            // now, we have to construct a query that will return the dependencies for this record, both hard and soft links
-            const sSQL = this.GetHardLinkDependencySQL(entityDependencies, compositeKey) + '\n' + this.GetSoftLinkDependencySQL(entityName, compositeKey);
-            // now, execute the query
-            const result = await this.ExecuteSQL(sSQL, null, undefined, contextUser);
-            if (!result || result.length === 0) {
-                return recordDependencies;
-            }
-            // now we go through the results and create the RecordDependency objects
-            for (const r of result) {
-                const entityInfo = this.Entities.find((e) => e.Name.trim().toLowerCase() === r.EntityName?.trim().toLowerCase());
-                if (!entityInfo) {
-                    throw new Error(`Entity ${r.EntityName} not found in metadata`);
-                }
-                // future, if we support foreign keys that are composite keys, we'll need to enable this code
-                // const pkeyValues: KeyValuePair[] = [];
-                // entityInfo.PrimaryKeys.forEach((pk) => {
-                //     pkeyValues.push({FieldName: pk.Name, Value: r[pk.Name]}) // add all of the primary keys, which often is as simple as just "ID", but this is generic way to do it
-                // })
-                const compositeKey = new CompositeKey();
-                // the row r will have a PrimaryKeyValue field that is a string that is a concatenation of the primary key field names and values
-                // we need to parse that out so that we can then pass it to the CompositeKey object
-                const pkeys = {};
-                const keyValues = r.PrimaryKeyValue.split(CompositeKey.DefaultFieldDelimiter);
-                keyValues.forEach((kv) => {
-                    const parts = kv.split(CompositeKey.DefaultValueDelimiter);
-                    pkeys[parts[0]] = parts[1];
-                });
-                compositeKey.LoadFromEntityInfoAndRecord(entityInfo, pkeys);
-                const recordDependency = {
-                    EntityName: r.EntityName,
-                    RelatedEntityName: r.RelatedEntityName,
-                    FieldName: r.FieldName,
-                    PrimaryKey: compositeKey,
-                };
-                recordDependencies.push(recordDependency);
-            }
-            return recordDependencies;
-        }
-        catch (e) {
-            // log and throw
-            LogError(e);
-            throw e;
-        }
-    }
     GetRecordDependencyLinkSQL(dep, entity, relatedEntity, CompositeKey) {
         const f = relatedEntity.Fields.find((f) => f.Name.trim().toLowerCase() === dep.FieldName?.trim().toLowerCase());
         const quotes = entity.FirstPrimaryKey.NeedsQuotes ? "'" : '';
@@ -2509,185 +872,6 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
             return `(SELECT ${f.RelatedEntityFieldName} FROM [${entity.SchemaName}].${entity.BaseView} WHERE ${entity.FirstPrimaryKey.Name}=${quotes}${CompositeKey.GetValueByIndex(0)}${quotes})`;
         }
     }
-    async GetRecordDuplicates(params, contextUser) {
-        if (!contextUser) {
-            throw new Error('User context is required to get record duplicates.');
-        }
-        const listEntity = await this.GetEntityObject('MJ: Lists');
-        listEntity.ContextCurrentUser = contextUser;
-        const success = await listEntity.Load(params.ListID);
-        if (!success) {
-            throw new Error(`List with ID ${params.ListID} not found.`);
-        }
-        const duplicateRun = await this.GetEntityObject('MJ: Duplicate Runs');
-        duplicateRun.NewRecord();
-        duplicateRun.EntityID = params.EntityID;
-        duplicateRun.StartedByUserID = contextUser.ID;
-        duplicateRun.StartedAt = new Date();
-        duplicateRun.ProcessingStatus = 'In Progress';
-        duplicateRun.ApprovalStatus = 'Pending';
-        duplicateRun.SourceListID = listEntity.ID;
-        duplicateRun.ContextCurrentUser = contextUser;
-        const saveResult = await duplicateRun.Save();
-        if (!saveResult) {
-            throw new Error(`Failed to save Duplicate Run Entity`);
-        }
-        const response = {
-            Status: 'Inprogress',
-            PotentialDuplicateResult: [],
-        };
-        return response;
-    }
-    async MergeRecords(request, contextUser, options) {
-        const e = this.Entities.find((e) => e.Name.trim().toLowerCase() === request.EntityName.trim().toLowerCase());
-        if (!e || !e.AllowRecordMerge)
-            throw new Error(`Entity ${request.EntityName} does not allow record merging, check the AllowRecordMerge property in the entity metadata`);
-        const result = {
-            Success: false,
-            RecordMergeLogID: null,
-            RecordStatus: [],
-            Request: request,
-            OverallStatus: null,
-        };
-        const mergeRecordLog = await this.StartMergeLogging(request, result, contextUser);
-        try {
-            /*
-                      we will follow this process...
-                      * 1. Begin Transaction
-                      * 2. The surviving record is loaded and fields are updated from the field map, if provided, and the record is saved. If a FieldMap not provided within the request object, this step is skipped.
-                      * 3. For each of the records that will be merged INTO the surviving record, we call the GetEntityDependencies() method and get a list of all other records in the database are linked to the record to be deleted. We then go through each of those dependencies and update the link to point to the SurvivingRecordID and save the record.
-                      * 4. The record to be deleted is then deleted.
-                      * 5. Commit or Rollback Transaction
-                   */
-            // Step 1 - begin transaction
-            await this.BeginTransaction();
-            // Step 2 - update the surviving record, but only do this if we were provided a field map
-            if (request.FieldMap && request.FieldMap.length > 0) {
-                const survivor = await this.GetEntityObject(request.EntityName, contextUser);
-                await survivor.InnerLoad(request.SurvivingRecordCompositeKey);
-                for (const fieldMap of request.FieldMap) {
-                    survivor.Set(fieldMap.FieldName, fieldMap.Value);
-                }
-                if (!(await survivor.Save())) {
-                    result.OverallStatus = 'Error saving survivor record with values from provided field map.';
-                    throw new Error(result.OverallStatus);
-                }
-            }
-            // Step 3 - update the dependencies for each of the records we will delete
-            for (const pksToDelete of request.RecordsToMerge) {
-                const newRecStatus = {
-                    CompositeKey: pksToDelete,
-                    Success: false,
-                    RecordMergeDeletionLogID: null,
-                    Message: null,
-                };
-                result.RecordStatus.push(newRecStatus);
-                const dependencies = await this.GetRecordDependencies(request.EntityName, pksToDelete);
-                // now, loop through the dependencies and update the link to point to the surviving record
-                for (const dependency of dependencies) {
-                    const reInfo = this.Entities.find((e) => e.Name.trim().toLowerCase() === dependency.RelatedEntityName.trim().toLowerCase());
-                    const relatedEntity = await this.GetEntityObject(dependency.RelatedEntityName, contextUser);
-                    await relatedEntity.InnerLoad(dependency.PrimaryKey);
-                    relatedEntity.Set(dependency.FieldName, request.SurvivingRecordCompositeKey.GetValueByIndex(0)); // only support single field foreign keys for now
-                    /*
-                              if we later support composite foreign keys, we'll need to do this instead, at the moment this code will break as dependency.KeyValuePair is a single value, not an array
-          
-                              for (let pkv of dependency.KeyValuePairs) {
-                                  relatedEntity.Set(dependency.FieldName, pkv.Value);
-                              }
-                               */
-                    if (!(await relatedEntity.Save())) {
-                        newRecStatus.Success = false;
-                        newRecStatus.Message = `Error updating dependency record ${dependency.PrimaryKey.ToString} for entity ${dependency.RelatedEntityName} to point to surviving record ${request.SurvivingRecordCompositeKey.ToString()}`;
-                        throw new Error(newRecStatus.Message);
-                    }
-                }
-                // if we get here, that means that all of the dependencies were updated successfully, so we can now delete the records to be merged
-                const recordToDelete = await this.GetEntityObject(request.EntityName, contextUser);
-                await recordToDelete.InnerLoad(pksToDelete);
-                if (!(await recordToDelete.Delete())) {
-                    newRecStatus.Message = `Error deleting record ${pksToDelete.ToString()} for entity ${request.EntityName}`;
-                    throw new Error(newRecStatus.Message);
-                }
-                else
-                    newRecStatus.Success = true;
-            }
-            result.Success = true;
-            await this.CompleteMergeLogging(mergeRecordLog, result, contextUser);
-            // Step 5 - commit transaction
-            await this.CommitTransaction();
-            result.Success = true;
-            return result;
-        }
-        catch (e) {
-            LogError(e);
-            await this.RollbackTransaction();
-            // attempt to persist the status to the DB, although that might fail
-            await this.CompleteMergeLogging(mergeRecordLog, result, contextUser);
-            throw e;
-        }
-    }
-    async StartMergeLogging(request, result, contextUser) {
-        try {
-            // create records in the Record Merge Logs entity and Record Merge Deletion Logs entity
-            const recordMergeLog = await this.GetEntityObject('MJ: Record Merge Logs', contextUser);
-            const entity = this.Entities.find((e) => e.Name === request.EntityName);
-            if (!entity)
-                throw new Error(`Entity ${result.Request.EntityName} not found in metadata`);
-            if (!contextUser && !this.CurrentUser)
-                throw new Error(`contextUser is null and no CurrentUser is set`);
-            recordMergeLog.NewRecord();
-            recordMergeLog.EntityID = entity.ID;
-            recordMergeLog.SurvivingRecordID = request.SurvivingRecordCompositeKey.Values(); // this would join together all of the primary key values, which is fine as the primary key is a string
-            recordMergeLog.InitiatedByUserID = contextUser ? contextUser.ID : this.CurrentUser?.ID;
-            recordMergeLog.ApprovalStatus = 'Approved';
-            recordMergeLog.ApprovedByUserID = contextUser ? contextUser.ID : this.CurrentUser?.ID;
-            recordMergeLog.ProcessingStatus = 'Started';
-            recordMergeLog.ProcessingStartedAt = new Date();
-            if (await recordMergeLog.Save()) {
-                result.RecordMergeLogID = recordMergeLog.ID;
-                return recordMergeLog;
-            }
-            else
-                throw new Error(`Error saving record merge log`);
-        }
-        catch (e) {
-            LogError(e);
-            throw e;
-        }
-    }
-    async CompleteMergeLogging(recordMergeLog, result, contextUser) {
-        try {
-            // create records in the Record Merge Logs entity and Record Merge Deletion Logs entity
-            if (!contextUser && !this.CurrentUser)
-                throw new Error(`contextUser is null and no CurrentUser is set`);
-            recordMergeLog.ProcessingStatus = result.Success ? 'Complete' : 'Error';
-            recordMergeLog.ProcessingEndedAt = new Date();
-            if (!result.Success)
-                // only create the log record if the merge failed, otherwise it is wasted space
-                recordMergeLog.ProcessingLog = result.OverallStatus;
-            if (await recordMergeLog.Save()) {
-                // top level saved, now let's create the deletion detail records for each of the records that were merged
-                for (const d of result.RecordStatus) {
-                    const recordMergeDeletionLog = await this.GetEntityObject('MJ: Record Merge Deletion Logs', contextUser);
-                    recordMergeDeletionLog.NewRecord();
-                    recordMergeDeletionLog.RecordMergeLogID = recordMergeLog.ID;
-                    recordMergeDeletionLog.DeletedRecordID = d.CompositeKey.Values(); // this would join together all of the primary key values, which is fine as the primary key is a string
-                    recordMergeDeletionLog.Status = d.Success ? 'Complete' : 'Error';
-                    recordMergeDeletionLog.ProcessingLog = d.Success ? null : d.Message; // only save the message if it failed
-                    if (!(await recordMergeDeletionLog.Save()))
-                        throw new Error(`Error saving record merge deletion log`);
-                }
-            }
-            else
-                throw new Error(`Error saving record merge log`);
-        }
-        catch (e) {
-            // do nothing here because we often will get here since some conditions lead to no DB updates possible...
-            LogError(e);
-            // don't bubble up the error here as we're sometimes already in an exception block in caller
-        }
-    }
     /**
      * Generates the SQL Statement that will Save a record to the database.
      *
@@ -2802,311 +986,17 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         return { fullSQL: sSQL, simpleSQL: sSimpleSQL, overlappingChangeData };
     }
     /**
-     * Gets AI actions configured for an entity based on trigger timing
-     *
-     * @param entityInfo - The entity to get AI actions for
-     * @param before - True to get before-save actions, false for after-save
-     * @returns Array of AI action entities
-     * @internal
-     */
-    GetEntityAIActions(entityInfo, before) {
-        return AIEngine.Instance.EntityAIActions.filter((a) => a.EntityID === entityInfo.ID && a.TriggerEvent.toLowerCase().trim() === (before ? 'before save' : 'after save'));
-    }
-    /**
-     * Handles entity actions (non-AI) for save, delete, or validate operations
-     *
-     * @param entity - The entity being operated on
-     * @param baseType - The type of operation
-     * @param before - Whether this is before or after the operation
-     * @param user - The user performing the operation
-     * @returns Array of action results
-     * @internal
+     * Override to defer AI action tasks when a transaction is active.
+     * When inside a transaction, tasks are queued to _deferredTasks and
+     * processed after transaction commit (see processDeferredTasks).
      */
-    async HandleEntityActions(entity, baseType, before, user) {
-        // use the EntityActionEngine for this
-        try {
-            const engine = EntityActionEngineServer.Instance;
-            await engine.Config(false, user);
-            const newRecord = entity.IsSaved ? false : true;
-            const baseTypeType = baseType === 'save' ? (newRecord ? 'Create' : 'Update') : 'Delete';
-            const invocationType = baseType === 'validate' ? 'Validate' : before ? 'Before' + baseTypeType : 'After' + baseTypeType;
-            const invocationTypeEntity = engine.InvocationTypes.find((i) => i.Name === invocationType);
-            if (!invocationTypeEntity) {
-                LogError(`Invocation Type ${invocationType} not found in metadata`);
-                return [];
-                //            throw new Error(`Invocation Type ${invocationType} not found in metadata`);
-            }
-            const activeActions = engine.GetActionsByEntityNameAndInvocationType(entity.EntityInfo.Name, invocationType, 'Active');
-            const results = [];
-            for (const a of activeActions) {
-                const result = await engine.RunEntityAction({
-                    EntityAction: a,
-                    EntityObject: entity,
-                    InvocationType: invocationTypeEntity,
-                    ContextUser: user,
-                });
-                results.push(result);
-            }
-            return results;
-        }
-        catch (e) {
-            LogError(e);
-            return [];
-        }
-    }
-    /**
-     * Handles Entity AI Actions. Parameters are setup for a future support of delete actions, but currently that isn't supported so the baseType parameter
-     * isn't fully functional. If you pass in delete, the function will just exit for now, and in the future calling code will start working when we support
-     * Delete as a trigger event for Entity AI Actions...
-     * @param entity
-     * @param baseType
-     * @param before
-     * @param user
-     */
-    async HandleEntityAIActions(entity, baseType, before, user) {
-        try {
-            // TEMP while we don't support delete
-            if (baseType === 'delete')
-                return;
-            // Make sure AI Metadata is loaded here...
-            await AIEngine.Instance.Config(false, user);
-            const actions = this.GetEntityAIActions(entity.EntityInfo, before); // get the actions we need to do for this entity
-            if (actions && actions.length > 0) {
-                const ai = AIEngine.Instance;
-                for (let i = 0; i < actions.length; i++) {
-                    const a = actions[i];
-                    if ((a.TriggerEvent === 'before save' && before) || (a.TriggerEvent === 'after save' && !before)) {
-                        const p = {
-                            entityAIActionId: a.ID,
-                            entityRecord: entity,
-                            actionId: a.AIActionID,
-                            modelId: a.AIModelID,
-                        };
-                        if (before) {
-                            // do it with await so we're blocking, as it needs to complete before the record save continues
-                            await ai.ExecuteEntityAIAction(p);
-                        }
-                        else {
-                            // just add a task and move on, we are doing 'after save' so we don't wait
-                            try {
-                                if (this.isTransactionActive) {
-                                    // Defer the task until after the transaction completes
-                                    this._deferredTasks.push({ type: 'Entity AI Action', data: p, options: null, user });
-                                }
-                                else {
-                                    // No transaction active, add the task immediately
-                                    QueueManager.AddTask('Entity AI Action', p, null, user);
-                                }
-                            }
-                            catch (e) {
-                                LogError(e.message);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) {
-            LogError(e);
-        }
-    }
-    async Save(entity, user, options) {
-        const entityResult = new BaseEntityResult();
-        try {
-            entity.RegisterTransactionPreprocessing();
-            const bNewRecord = !entity.IsSaved;
-            if (!options)
-                options = new EntitySaveOptions();
-            const bReplay = !!options.ReplayOnly;
-            if (!bReplay && !bNewRecord && !entity.EntityInfo.AllowUpdateAPI) {
-                // existing record and not allowed to update
-                throw new Error(`UPDATE not allowed for entity ${entity.EntityInfo.Name}`);
-            }
-            else if (!bReplay && bNewRecord && !entity.EntityInfo.AllowCreateAPI) {
-                // new record and not allowed to create
-                throw new Error(`CREATE not allowed for entity ${entity.EntityInfo.Name}`);
-            }
-            else {
-                // getting here means we are good to save, now check to see if we're dirty and need to save
-                // REMEMBER - this is the provider and the BaseEntity/subclasses handle user-level permission checking already, we just make sure API was turned on for the operation
-                if (entity.Dirty || options.IgnoreDirtyState || options.ReplayOnly) {
-                    entityResult.StartedAt = new Date();
-                    entityResult.Type = bNewRecord ? 'create' : 'update';
-                    entityResult.OriginalValues = entity.Fields.map((f) => {
-                        const tempStatus = f.ActiveStatusAssertions;
-                        f.ActiveStatusAssertions = false; // turn off warnings for this operation
-                        const ret = {
-                            FieldName: f.Name,
-                            Value: f.Value
-                        };
-                        f.ActiveStatusAssertions = tempStatus; // restore the status assertions
-                        return ret;
-                    }); // save the original values before we start the process
-                    entity.ResultHistory.push(entityResult); // push the new result as we have started a process
-                    // The assumption is that Validate() has already been called by the BaseEntity object that is invoking this provider.
-                    // However, we have an extra responsibility in this situation which is to fire off the EntityActions for the Validate invocation type and
-                    // make sure they clear. If they don't clear we throw an exception with the message provided.
-                    if (!bReplay) {
-                        const validationResult = await this.HandleEntityActions(entity, 'validate', false, user);
-                        if (validationResult && validationResult.length > 0) {
-                            // one or more actions executed, see the reults and if any failed, concat their messages and return as exception being thrown
-                            const message = validationResult
-                                .filter((v) => !v.Success)
-                                .map((v) => v.Message)
-                                .join('\n\n');
-                            if (message) {
-                                entityResult.Success = false;
-                                entityResult.EndedAt = new Date();
-                                entityResult.Message = message;
-                                return false;
-                            }
-                        }
-                    }
-                    else {
-                        // we are in replay mode we so do NOT need to do the validation stuff, skipping it...
-                    }
-                    const spName = this.GetCreateUpdateSPName(entity, bNewRecord);
-                    if (options.SkipEntityActions !== true /*options set, but not set to skip entity actions*/) {
-                        await this.HandleEntityActions(entity, 'save', true, user);
-                    }
-                    if (options.SkipEntityAIActions !== true /*options set, but not set to skip entity AI actions*/) {
-                        // process any Entity AI actions that are set to trigger BEFORE the save, these are generally a really bad idea to do before save
-                        // but they are supported (for now)
-                        await this.HandleEntityAIActions(entity, 'save', true, user);
-                    }
-                    // Generate the SQL for the save operation
-                    // This is async because it may need to encrypt field values
-                    const sqlDetails = await this.GetSaveSQLWithDetails(entity, bNewRecord, spName, user);
-                    const sSQL = sqlDetails.fullSQL;
-                    if (entity.TransactionGroup && !bReplay /*we never participate in a transaction if we're in replay mode*/) {
-                        // we have a transaction group, need to play nice and be part of it
-                        entity.RaiseReadyForTransaction(); // let the entity know we're ready to be part of the transaction
-                        // we are part of a transaction group, so just add our query to the list
-                        // and when the transaction is committed, we will send all the queries at once
-                        this._bAllowRefresh = false; // stop refreshes of metadata while we're doing work
-                        entity.TransactionGroup.AddTransaction(new TransactionItem(entity, entityResult.Type === 'create' ? 'Create' : 'Update', sSQL, null, {
-                            dataSource: this._pool,
-                            simpleSQLFallback: entity.EntityInfo.TrackRecordChanges ? sqlDetails.simpleSQL : undefined,
-                            entityName: entity.EntityInfo.Name
-                        }, (transactionResult, success) => {
-                            // we get here whenever the transaction group does gets around to committing
-                            // our query.
-                            this._bAllowRefresh = true; // allow refreshes again
-                            entityResult.EndedAt = new Date();
-                            if (success && transactionResult) {
-                                // process any Entity AI actions that are set to trigger AFTER the save
-                                // these are fired off but are NOT part of the transaction group, so if they fail,
-                                // the transaction group will still commit, but the AI action will not be executed
-                                if (options.SkipEntityAIActions !== true /*options set, but not set to skip entity AI actions*/) {
-                                    this.HandleEntityAIActions(entity, 'save', false, user); // NO AWAIT INTENTIONALLY
-                                }
-                                // Same approach to Entity Actions as Entity AI Actions
-                                if (options.SkipEntityActions !== true) {
-                                    this.HandleEntityActions(entity, 'save', false, user); // NO AWAIT INTENTIONALLY
-                                }
-                                entityResult.Success = true;
-                                entityResult.NewValues = this.MapTransactionResultToNewValues(transactionResult);
-                            }
-                            else {
-                                // the transaction failed, nothing to update, but we need to call Reject so the
-                                // promise resolves with a rejection so our outer caller knows
-                                entityResult.Success = false;
-                                entityResult.Message = 'Transaction Failed';
-                            }
-                        }));
-                        return true; // we're part of a transaction group, so we're done here
-                    }
-                    else {
-                        // no transaction group, just execute this immediately...
-                        this._bAllowRefresh = false; // stop refreshes of metadata while we're doing work
-                        let result;
-                        if (bReplay) {
-                            result = [entity.GetAll()]; // just return the entity as it was before the save as we are NOT saving anything as we are in replay mode
-                        }
-                        else {
-                            try {
-                                // Execute SQL with optional simple SQL fallback for loggers
-                                // IS-A: use entity's ProviderTransaction when available for shared transaction
-                                const rawResult = await this.ExecuteSQL(sSQL, null, {
-                                    isMutation: true,
-                                    description: `Save ${entity.EntityInfo.Name}`,
-                                    simpleSQLFallback: entity.EntityInfo.TrackRecordChanges ? sqlDetails.simpleSQL : undefined,
-                                    connectionSource: entity.ProviderTransaction ?? undefined
-                                }, user);
-                                // Process rows with user context for decryption
-                                result = await this.ProcessEntityRows(rawResult, entity.EntityInfo, user);
-                            }
-                            catch (e) {
-                                throw e; // rethrow
-                            }
-                        }
-                        this._bAllowRefresh = true; // allow refreshes now
-                        entityResult.EndedAt = new Date();
-                        if (result && result.length > 0) {
-                            // Entity AI Actions - fired off async, NO await on purpose
-                            if (options.SkipEntityAIActions !== true /*options set, but not set to skip entity AI actions*/)
-                                this.HandleEntityAIActions(entity, 'save', false, user); // fire off any AFTER SAVE AI actions, but don't wait for them
-                            // Entity Actions - fired off async, NO await on purpose
-                            if (options.SkipEntityActions !== true)
-                                this.HandleEntityActions(entity, 'save', false, user); // NO AWAIT INTENTIONALLY
-                            entityResult.Success = true;
-                            // IS-A overlapping subtypes: propagate Record Change entries to sibling branches.
-                            // Runs after this entity's save succeeds. Skips the active child branch (if this
-                            // is a parent save in a chain) so siblings don't get duplicate entries.
-                            if (sqlDetails.overlappingChangeData
-                                && entity.EntityInfo.AllowMultipleSubtypes
-                                && entity.EntityInfo.TrackRecordChanges) {
-                                await this.PropagateRecordChangesToSiblings(entity.EntityInfo, sqlDetails.overlappingChangeData, entity.PrimaryKey.Values(), user?.ID ?? '', options.ISAActiveChildEntityName, entity.ProviderTransaction ?? undefined);
-                            }
-                            return result[0];
-                        }
-                        else {
-                            if (bNewRecord) {
-                                throw new Error(`SQL Error: Error creating new record, no rows returned from SQL: ` + sSQL);
-                            }
-                            else {
-                                // if we get here that means that SQL did NOT find a matching row to update in the DB, so we need to throw an error
-                                throw new Error(`SQL Error: Error updating record, no MATCHING rows found within the database: ` + sSQL);
-                            }
-                        }
-                    }
-                }
-                else {
-                    return entity; // nothing to save, just return the entity
-                }
-            }
-        }
-        catch (e) {
-            this._bAllowRefresh = true; // allow refreshes again if we get a failure here
-            entityResult.EndedAt = new Date();
-            entityResult.Message = e.message;
-            LogError(e);
-            throw e; // rethrow the error
+    EnqueueAfterSaveAIAction(params, user) {
+        if (this.isTransactionActive) {
+            this._deferredTasks.push({ type: 'Entity AI Action', data: params, options: null, user });
+        }
+        else {
+            QueueManager.AddTask('Entity AI Action', params, null, user);
         }
-    }
-    MapTransactionResultToNewValues(transactionResult) {
-        return Object.keys(transactionResult).map((k) => {
-            return {
-                FieldName: k,
-                Value: transactionResult[k],
-            };
-        }); // transform the result into a list of field/value pairs
-    }
-    /**
-     * Returns the stored procedure name to use for the given entity based on if it is a new record or an existing record.
-     * @param entity
-     * @param bNewRecord
-     * @returns
-     */
-    GetCreateUpdateSPName(entity, bNewRecord) {
-        const spName = bNewRecord
-            ? entity.EntityInfo.spCreate?.length > 0
-                ? entity.EntityInfo.spCreate
-                : 'spCreate' + entity.EntityInfo.BaseTableCodeName
-            : entity.EntityInfo.spUpdate?.length > 0
-                ? entity.EntityInfo.spUpdate
-                : 'spUpdate' + entity.EntityInfo.BaseTableCodeName;
-        return spName;
     }
     getAllEntityColumnsSQL(entityInfo) {
         let sRet = '', outputCount = 0;
@@ -3373,7 +1263,7 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         return unicodePrefix + quoteString + pVal + quoteString;
     }
     GetLogRecordChangeSQL(newData, oldData, entityName, recordID, entityInfo, type, user, wrapRecordIdInQuotes) {
-        const fullRecordJSON = JSON.stringify(this.escapeQuotesInProperties(newData ? newData : oldData, "'")); // stringify old data if we don't have new - means we are DELETING A RECORD
+        const fullRecordJSON = JSON.stringify(this.EscapeQuotesInProperties(newData ? newData : oldData, "'")); // stringify old data if we don't have new - means we are DELETING A RECORD
         const changes = this.DiffObjects(oldData, newData, entityInfo, "'");
         const changesKeys = changes ? Object.keys(changes) : [];
         if (changesKeys.length > 0 || oldData === null /*new record*/ || newData === null /*deleted record*/) {
@@ -3393,280 +1283,14 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         else
             return null;
     }
-    async LogRecordChange(newData, oldData, entityName, recordID, entityInfo, type, user) {
-        const sSQL = this.GetLogRecordChangeSQL(newData, oldData, entityName, recordID, entityInfo, type, user, true);
-        if (sSQL) {
-            const result = await this.ExecuteSQL(sSQL, undefined, undefined, user);
-            return result;
-        }
-    }
-    /**
-     * This method will create a human-readable string that describes the changes object that was created using the DiffObjects() method
-     * @param changesObject JavaScript object that has properties for each changed field that in turn have field, oldValue and newValue as sub-properties
-     * @param maxValueLength If not specified, default value of 200 characters applies where any values after the maxValueLength is cut off. The actual values are stored in the ChangesJSON and FullRecordJSON in the RecordChange table, this is only for the human-display
-     * @param cutOffText If specified, and if maxValueLength applies to any of the values being included in the description, this cutOffText param will be appended to the end of the cut off string to indicate to the human reader that the value is partial.
-     * @returns
-     */
-    CreateUserDescriptionOfChanges(changesObject, maxValueLength = 200, cutOffText = '...') {
-        let sRet = '';
-        const keys = Object.keys(changesObject);
-        for (let i = 0; i < keys.length; i++) {
-            const change = changesObject[keys[i]];
-            if (sRet.length > 0) {
-                sRet += '\n';
-            }
-            if (change.oldValue && change.newValue)
-                // both old and new values set, show change
-                sRet += `${change.field} changed from ${this.trimString(change.oldValue, maxValueLength, cutOffText)} to ${this.trimString(change.newValue, maxValueLength, cutOffText)}`;
-            else if (change.newValue)
-                // old value was blank, new value isn't
-                sRet += `${change.field} set to ${this.trimString(change.newValue, maxValueLength, cutOffText)}`;
-            else if (change.oldValue)
-                // new value is blank, old value wasn't
-                sRet += `${change.field} cleared from ${this.trimString(change.oldValue, maxValueLength, cutOffText)}`;
-        }
-        return sRet.replace(/'/g, "''");
-    }
-    trimString(value, maxLength, trailingChars) {
-        if (value && typeof value === 'string' && value.length > maxLength) {
-            value = value.substring(0, maxLength) + trailingChars;
-        }
-        return value;
-    }
-    /**
-     * Recursively escapes quotes in all string properties of an object or array.
-     * This method traverses through nested objects and arrays, escaping the specified
-     * quote character in all string values to prevent SQL injection and syntax errors.
-     *
-     * @param obj - The object, array, or primitive value to process
-     * @param quoteToEscape - The quote character to escape (typically single quote "'")
-     * @returns A new object/array with all string values having quotes properly escaped.
-     *          Non-string values are preserved as-is.
-     *
-     * @example
-     * // Escaping single quotes in a nested object
-     * const input = {
-     *   name: "John's Company",
-     *   details: {
-     *     description: "It's the best",
-     *     tags: ["Won't fail", "Can't stop"]
-     *   }
-     * };
-     * const escaped = this.escapeQuotesInProperties(input, "'");
-     * // Result: {
-     * //   name: "John''s Company",
-     * //   details: {
-     * //     description: "It''s the best",
-     * //     tags: ["Won''t fail", "Can''t stop"]
-     * //   }
-     * // }
-     *
-     * @remarks
-     * This method is essential for preparing data to be embedded in SQL strings.
-     * It handles:
-     * - Nested objects of any depth
-     * - Arrays (including arrays of objects)
-     * - Mixed-type objects with strings, numbers, booleans, null values
-     * - Circular references are NOT handled and will cause stack overflow
-     */
-    escapeQuotesInProperties(obj, quoteToEscape) {
-        // Handle null/undefined
-        if (obj === null || obj === undefined) {
-            return obj;
-        }
-        // Handle arrays recursively
-        if (Array.isArray(obj)) {
-            return obj.map(item => this.escapeQuotesInProperties(item, quoteToEscape));
-        }
-        // Handle Date objects - convert to ISO string before they lose their value
-        if (obj instanceof Date) {
-            return obj.toISOString();
-        }
-        // Handle objects recursively
-        if (typeof obj === 'object') {
-            const sRet = {};
-            for (const key in obj) {
-                if (obj.hasOwnProperty(key)) {
-                    const element = obj[key];
-                    if (typeof element === 'string') {
-                        const reg = new RegExp(quoteToEscape, 'g');
-                        sRet[key] = element.replace(reg, quoteToEscape + quoteToEscape);
-                    }
-                    else if (typeof element === 'object') {
-                        // Recursively escape nested objects and arrays
-                        sRet[key] = this.escapeQuotesInProperties(element, quoteToEscape);
-                    }
-                    else {
-                        // Keep primitive values as-is (numbers, booleans, etc.)
-                        sRet[key] = element;
-                    }
-                }
-            }
-            return sRet;
-        }
-        // For non-object types (shouldn't normally happen), return as-is
-        return obj;
-    }
     /**
-     * Creates a changes object by comparing two javascript objects, identifying fields that have different values.
-     * Each property in the returned object represents a changed field, with the field name as the key.
-     *
-     * @param oldData - The original data object to compare from
-     * @param newData - The new data object to compare to
-     * @param entityInfo - Entity metadata used to validate fields and determine comparison logic
-     * @param quoteToEscape - The quote character to escape in string values (typically "'")
-     * @returns A Record mapping field names to FieldChange objects containing the field name, old value, and new value.
-     *          Returns null if either oldData or newData is null/undefined.
-     *          Only includes fields that have actually changed and are not read-only.
-     *
-     * @remarks
-     * - Read-only fields are never considered changed
-     * - null and undefined are treated as equivalent
-     * - Date fields are compared by timestamp
-     * - String and object values have quotes properly escaped for SQL
-     * - Objects/arrays are recursively escaped using escapeQuotesInProperties
-     *
-     * @example
-     * ```typescript
-     * const changes = provider.DiffObjects(
-     *   { name: "John's Co", revenue: 1000 },
-     *   { name: "John's Co", revenue: 2000 },
-     *   entityInfo,
-     *   "'"
-     * );
-     * // Returns: { revenue: { field: "revenue", oldValue: 1000, newValue: 2000 } }
-     * ```
+     * Implements the abstract BuildRecordChangeSQL from DatabaseProviderBase.
+     * Delegates to GetLogRecordChangeSQL for T-SQL generation.
      */
-    DiffObjects(oldData, newData, entityInfo, quoteToEscape) {
-        if (!oldData || !newData)
-            return null;
-        else {
-            const changes = {};
-            for (const key in newData) {
-                const f = entityInfo.Fields.find((f) => f.Name.toLowerCase() === key.toLowerCase());
-                if (!f) {
-                    continue; // skip if field not found in entity info, sometimes objects have extra properties that are not part of the entity
-                }
-                let bDiff = false;
-                if (f.ReadOnly)
-                    bDiff = false; // read only fields are never different, they can change in the database, but we don't consider them to be a change for record changes purposes.
-                else if ((oldData[key] == undefined || oldData[key] == null) && (newData[key] == undefined || newData[key] == null))
-                    bDiff = false; // this branch of logic ensures that undefined and null are treated the same
-                else {
-                    switch (f.TSType) {
-                        case EntityFieldTSType.String:
-                            bDiff = oldData[key] !== newData[key];
-                            break;
-                        case EntityFieldTSType.Date:
-                            bDiff = new Date(oldData[key]).getTime() !== new Date(newData[key]).getTime();
-                            break;
-                        case EntityFieldTSType.Number:
-                        case EntityFieldTSType.Boolean:
-                            bDiff = oldData[key] !== newData[key];
-                            break;
-                    }
-                }
-                if (bDiff) {
-                    // make sure we escape things properly
-                    let o = oldData[key];
-                    let n = newData[key];
-                    if (typeof o === 'string') {
-                        // Escape strings directly
-                        const r = new RegExp(quoteToEscape, 'g');
-                        o = o.replace(r, quoteToEscape + quoteToEscape);
-                    }
-                    else if (typeof o === 'object' && o !== null) {
-                        // For objects/arrays, recursively escape all string properties
-                        o = this.escapeQuotesInProperties(o, quoteToEscape);
-                    }
-                    if (typeof n === 'string') {
-                        // Escape strings directly
-                        const r = new RegExp(quoteToEscape, 'g');
-                        n = n.replace(r, quoteToEscape + quoteToEscape);
-                    }
-                    else if (typeof n === 'object' && n !== null) {
-                        // For objects/arrays, recursively escape all string properties
-                        n = this.escapeQuotesInProperties(n, quoteToEscape);
-                    }
-                    changes[key] = {
-                        field: key,
-                        oldValue: o,
-                        newValue: n,
-                    };
-                }
-            }
-            return changes;
-        }
-    }
-    async Load(entity, CompositeKey, EntityRelationshipsToLoad = null, user) {
-        const where = CompositeKey.KeyValuePairs.map((val) => {
-            const pk = entity.EntityInfo.PrimaryKeys.find((pk) => pk.Name.trim().toLowerCase() === val.FieldName.trim().toLowerCase());
-            if (!pk)
-                throw new Error(`Primary key ${val.FieldName} not found in entity ${entity.EntityInfo.Name}`);
-            const quotes = pk.NeedsQuotes ? "'" : '';
-            return `[${pk.CodeName}]=${quotes}${val.Value}${quotes}`;
-        }).join(' AND ');
-        const sql = `SELECT * FROM [${entity.EntityInfo.SchemaName}].${entity.EntityInfo.BaseView} WHERE ${where}`;
-        const rawData = await this.ExecuteSQL(sql, undefined, undefined, user);
-        // Process rows with user context for decryption
-        const d = await this.ProcessEntityRows(rawData, entity.EntityInfo, user);
-        if (d && d.length > 0) {
-            // got the record, now process the relationships if there are any
-            const ret = d[0];
-            // we need to post process the retrieval to see if we have any char or nchar fields and we need to remove their trailing spaces
-            for (const field of entity.EntityInfo.Fields) {
-                if (field.TSType === EntityFieldTSType.String &&
-                    field.Type.toLowerCase().includes('char') &&
-                    !field.Type.toLowerCase().includes('varchar')) {
-                    // trim trailing spaces for char and nchar fields
-                    ret[field.Name] = ret[field.Name] ? ret[field.Name].trimEnd() : ret[field.Name];
-                }
-            }
-            if (EntityRelationshipsToLoad && EntityRelationshipsToLoad.length > 0) {
-                for (let i = 0; i < EntityRelationshipsToLoad.length; i++) {
-                    const rel = EntityRelationshipsToLoad[i];
-                    const relInfo = entity.EntityInfo.RelatedEntities.find((r) => r.RelatedEntity == rel);
-                    if (relInfo) {
-                        let relSql = '';
-                        const relEntitySchemaName = this.Entities.find((e) => e.Name.trim().toLowerCase() === relInfo.RelatedEntity.trim().toLowerCase())?.SchemaName;
-                        const quotes = entity.FirstPrimaryKey.NeedsQuotes ? "'" : '';
-                        if (relInfo.Type.trim().toLowerCase() === 'one to many')
-                            // one to many - simple query
-                            relSql = `  SELECT
-                                            *
-                                        FROM
-                                            [${relEntitySchemaName}].[${relInfo.RelatedEntityBaseView}]
-                                        WHERE
-                                            [${relInfo.RelatedEntityJoinField}] = ${quotes}${ret[entity.FirstPrimaryKey.Name]}${quotes}`;
-                        // don't yet support composite foreign keys
-                        // many to many - need to use join view
-                        else
-                            relSql = `  SELECT
-                                            _theview.*
-                                        FROM
-                                            [${relEntitySchemaName}].[${relInfo.RelatedEntityBaseView}] _theview
-                                        INNER JOIN
-                                            [${relEntitySchemaName}].[${relInfo.JoinView}] _jv ON _theview.[${relInfo.RelatedEntityJoinField}] = _jv.[${relInfo.JoinEntityInverseJoinField}]
-                                        WHERE
-                                            _jv.${relInfo.JoinEntityJoinField} = ${quotes}${ret[entity.FirstPrimaryKey.Name]}${quotes}`; // don't yet support composite foreign keys
-                        const rawRelData = await this.ExecuteSQL(relSql, undefined, undefined, user);
-                        if (rawRelData && rawRelData.length > 0) {
-                            // Find the related entity info to process datetime fields correctly
-                            const relEntityInfo = this.Entities.find((e) => e.Name.trim().toLowerCase() === relInfo.RelatedEntity.trim().toLowerCase());
-                            if (relEntityInfo) {
-                                ret[rel] = await this.ProcessEntityRows(rawRelData, relEntityInfo, user);
-                            }
-                            else {
-                                // Fallback if we can't find entity info
-                                ret[rel] = rawRelData;
-                            }
-                        }
-                    }
-                }
-            }
-            return ret;
-        }
-        // if we get here, something didn't go right
+    BuildRecordChangeSQL(newData, oldData, entityName, recordID, entityInfo, type, user) {
+        const sql = this.GetLogRecordChangeSQL(newData, oldData, entityName, recordID, entityInfo, type, user, true);
+        if (sql)
+            return { sql };
         return null;
     }
     /**
@@ -3746,647 +1370,144 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
         }
         return { fullSQL: sSQL, simpleSQL: sSimpleSQL };
     }
-    async Delete(entity, options, user) {
-        const result = new BaseEntityResult();
-        try {
-            entity.RegisterTransactionPreprocessing();
-            if (!options)
-                options = new EntityDeleteOptions();
-            const bReplay = options.ReplayOnly;
-            if (!entity.IsSaved && !bReplay)
-                // existing record and not allowed to update
-                throw new Error(`Delete() isn't callable for records that haven't yet been saved - ${entity.EntityInfo.Name}`);
-            if (!entity.EntityInfo.AllowDeleteAPI && !bReplay)
-                // not allowed to delete
-                throw new Error(`Delete() isn't callable for ${entity.EntityInfo.Name} as AllowDeleteAPI is false`);
-            result.StartedAt = new Date();
-            result.Type = 'delete';
-            result.OriginalValues = entity.Fields.map((f) => {
-                return { FieldName: f.Name, Value: f.Value };
-            }); // save the original values before we start the process
-            entity.ResultHistory.push(result); // push the new result as we have started a process
-            // REMEMBER - this is the provider and the BaseEntity/subclasses handle user-level permission checking already, we just make sure API was turned on for the operation
-            // if we get here we can delete, so build the SQL and then handle appropriately either as part of TransGroup or directly...
-            const sqlDetails = this.GetDeleteSQLWithDetails(entity, user);
-            const sSQL = sqlDetails.fullSQL;
-            // Handle Entity and Entity AI Actions here w/ before and after handling
-            if (false === options?.SkipEntityActions)
-                await this.HandleEntityActions(entity, 'delete', true, user);
-            if (false === options?.SkipEntityAIActions)
-                await this.HandleEntityAIActions(entity, 'delete', true, user);
-            if (entity.TransactionGroup && !bReplay) {
-                // we have a transaction group, need to play nice and be part of it
-                entity.RaiseReadyForTransaction();
-                // we are part of a transaction group, so just add our query to the list
-                // and when the transaction is committed, we will send all the queries at once
-                entity.TransactionGroup.AddTransaction(new TransactionItem(entity, 'Delete', sSQL, null, {
-                    dataSource: this._pool,
-                    simpleSQLFallback: entity.EntityInfo.TrackRecordChanges ? sqlDetails.simpleSQL : undefined,
-                    entityName: entity.EntityInfo.Name
-                }, (transactionResult, success) => {
-                    // we get here whenever the transaction group does gets around to committing
-                    // our query.
-                    result.EndedAt = new Date();
-                    if (success && result) {
-                        // Entity AI Actions and Actions - fired off async, NO await on purpose
-                        if (false === options?.SkipEntityActions) {
-                            this.HandleEntityActions(entity, 'delete', false, user);
-                        }
-                        if (false === options?.SkipEntityAIActions) {
-                            this.HandleEntityAIActions(entity, 'delete', false, user);
-                        }
-                        // Make sure the return value matches up as that is how we know the SP was succesfully internally
-                        for (const key of entity.PrimaryKeys) {
-                            if (key.Value !== transactionResult[key.Name]) {
-                                result.Success = false;
-                                result.Message = 'Transaction failed to commit';
-                            }
-                        }
-                        result.NewValues = this.MapTransactionResultToNewValues(transactionResult);
-                        result.Success = true;
-                    }
-                    else {
-                        // the transaction failed, nothing to update, but we need to call Reject so the
-                        // promise resolves with a rejection so our outer caller knows
-                        result.Success = false;
-                        result.Message = 'Transaction failed to commit';
-                    }
-                }));
-                return true; // we're part of a transaction group, so we're done here
-            }
-            else {
-                let d;
-                if (bReplay) {
-                    d = [entity.GetAll()]; // just return the entity as it was before the save as we are NOT saving anything as we are in replay mode
-                }
-                else {
-                    // IS-A: use entity's ProviderTransaction when available for shared transaction
-                    d = await this.ExecuteSQL(sSQL, null, {
-                        isMutation: true,
-                        description: `Delete ${entity.EntityInfo.Name}`,
-                        simpleSQLFallback: entity.EntityInfo.TrackRecordChanges ? sqlDetails.simpleSQL : undefined,
-                        connectionSource: entity.ProviderTransaction ?? undefined
-                    }, user);
-                }
-                if (d && d.length > 0) {
-                    // SP executed, now make sure the return value matches up as that is how we know the SP was succesfully internally
-                    // Note: When CASCADE operations exist, multiple result sets are returned (d is array of arrays).
-                    // When no CASCADE operations exist, a single result set is returned (d is array of objects).
-                    // We need to handle both cases by checking if the first element is an array.
-                    const isMultipleResultSets = Array.isArray(d[0]);
-                    const deletedRecord = isMultipleResultSets
-                        ? d[d.length - 1][0] // Multiple result sets: get last result set, first row
-                        : d[0]; // Single result set: get first row directly
-                    for (const key of entity.PrimaryKeys) {
-                        if (key.Value !== deletedRecord[key.Name]) {
-                            // we can get here if the sp returns NULL for a given key. The reason that would be the case is if the record
-                            // was not found in the DB. This was the existing logic prior to the SP modifications in 2.68.0, just documenting
-                            // it here for clarity.
-                            result.Message = `Transaction failed to commit, record with primary key ${key.Name}=${key.Value} not found`;
-                            result.EndedAt = new Date();
-                            result.Success = false;
-                            return false;
-                        }
-                    }
-                    // Entity AI Actions and Actions - fired off async, NO await on purpose
-                    this.HandleEntityActions(entity, 'delete', false, user);
-                    this.HandleEntityAIActions(entity, 'delete', false, user);
-                    result.EndedAt = new Date();
-                    return true;
-                }
-                else {
-                    result.Message = 'No result returned from SQL';
-                    result.EndedAt = new Date();
-                    return false;
-                }
-            }
-        }
-        catch (e) {
-            LogError(e);
-            result.Message = e.message;
-            result.Success = false;
-            result.EndedAt = new Date();
-            return false;
-        }
-    }
-    /**************************************************************************/
-    // END ---- IEntityDataProvider
     /**************************************************************************/
+    // START ---- DatabaseProviderBase Override Hooks (Phase 2)
     /**************************************************************************/
-    // START ---- IMetadataProvider
-    /**************************************************************************/
-    async GetDatasetByName(datasetName, itemFilters, contextUser, providerToUse) {
-        const sSQL = `SELECT
-                        di.*,
-                        e.BaseView EntityBaseView,
-                        e.SchemaName EntitySchemaName,
-                        di.__mj_UpdatedAt AS DatasetItemUpdatedAt,
-                        d.__mj_UpdatedAt AS DatasetUpdatedAt
-                    FROM
-                        [${this.MJCoreSchemaName}].vwDatasets d
-                    INNER JOIN
-                        [${this.MJCoreSchemaName}].vwDatasetItems di
-                    ON
-                        d.ID = di.DatasetID
-                    INNER JOIN
-                        [${this.MJCoreSchemaName}].vwEntities e
-                    ON
-                        di.EntityID = e.ID
-                    WHERE
-                        d.Name = @p0`;
-        let items = [];
-        const useThisProvider = providerToUse ? providerToUse : this;
-        items = await useThisProvider.ExecuteSQL(sSQL, [datasetName], undefined, contextUser);
-        // now we have the dataset and the items, we need to get the update date from the items underlying entities
-        if (items && items.length > 0) {
-            // Optimization: Use batch SQL execution for multiple items
-            // Build SQL queries for all items
-            const queries = [];
-            const itemsWithSQL = [];
-            for (const item of items) {
-                const itemSQL = useThisProvider.GetDatasetItemSQL(item, itemFilters, datasetName);
-                if (itemSQL) {
-                    queries.push(itemSQL);
-                    itemsWithSQL.push(item);
-                }
-                else {
-                    // Handle invalid SQL case - add to results with error
-                    itemsWithSQL.push({ ...item, hasError: true });
-                }
-            }
-            // Execute all queries in a single batch
-            const batchResults = await useThisProvider.ExecuteSQLBatch(queries, undefined, undefined, contextUser);
-            // Process results for each item
-            const results = [];
-            let queryIndex = 0;
-            for (const item of itemsWithSQL) {
-                if (item.hasError) {
-                    // Handle error case for invalid columns
-                    results.push({
-                        EntityID: item.EntityID,
-                        EntityName: item.Entity,
-                        Code: item.Code,
-                        Results: null,
-                        LatestUpdateDate: null,
-                        Status: 'Invalid columns specified for dataset item',
-                        Success: false,
-                    });
-                }
-                else {
-                    // Process successful query result
-                    let itemData = batchResults[queryIndex] || [];
-                    // Process rows for datetime conversion and field-level decryption
-                    // This is critical for datasets that contain encrypted fields
-                    if (itemData.length > 0) {
-                        const entityInfo = useThisProvider.Entities.find(e => e.Name.trim().toLowerCase() === item.Entity.trim().toLowerCase());
-                        if (entityInfo) {
-                            itemData = await useThisProvider.ProcessEntityRows(itemData, entityInfo, contextUser);
-                        }
-                    }
-                    const itemUpdatedAt = new Date(item.DatasetItemUpdatedAt);
-                    const datasetUpdatedAt = new Date(item.DatasetUpdatedAt);
-                    const datasetMaxUpdatedAt = new Date(Math.max(itemUpdatedAt.getTime(), datasetUpdatedAt.getTime()));
-                    // get the latest update date
-                    let latestUpdateDate = new Date(1900, 1, 1);
-                    if (itemData && itemData.length > 0) {
-                        itemData.forEach((data) => {
-                            if (data[item.DateFieldToCheck] && new Date(data[item.DateFieldToCheck]) > latestUpdateDate) {
-                                latestUpdateDate = new Date(data[item.DateFieldToCheck]);
-                            }
-                        });
-                    }
-                    // finally, compare the latestUpdatedDate to the dataset max date, and use the latter if it is more recent
-                    if (datasetMaxUpdatedAt > latestUpdateDate) {
-                        latestUpdateDate = datasetMaxUpdatedAt;
-                    }
-                    results.push({
-                        EntityID: item.EntityID,
-                        EntityName: item.Entity,
-                        Code: item.Code,
-                        Results: itemData,
-                        LatestUpdateDate: latestUpdateDate,
-                        Success: itemData !== null && itemData !== undefined,
-                    });
-                    queryIndex++;
-                }
-            }
-            // determine overall success
-            const bSuccess = results.every((result) => result.Success);
-            // get the latest update date from all the results
-            const latestUpdateDate = results.reduce((acc, result) => {
-                if (result?.LatestUpdateDate) {
-                    const theDate = new Date(result.LatestUpdateDate);
-                    if (result.LatestUpdateDate && theDate.getTime() > acc.getTime()) {
-                        return theDate;
-                    }
-                }
-                return acc;
-            }, new Date(0));
-            return {
-                DatasetID: items[0].DatasetID,
-                DatasetName: datasetName,
-                Success: bSuccess,
-                Status: '',
-                LatestUpdateDate: latestUpdateDate,
-                Results: results,
-            };
-        }
-        else {
-            return {
-                DatasetID: '',
-                DatasetName: datasetName,
-                Success: false,
-                Status: 'No Dataset or Items found for DatasetName: ' + datasetName,
-                LatestUpdateDate: null,
-                Results: null,
-            };
-        }
-    }
-    /**
-     * Constructs the SQL query for a dataset item.
-     * @param item - The dataset item metadata
-     * @param itemFilters - Optional filters to apply
-     * @param datasetName - Name of the dataset (for error logging)
-     * @returns The SQL query string, or null if columns are invalid
-     */
-    GetDatasetItemSQL(item, itemFilters, datasetName) {
-        let filterSQL = '';
-        if (itemFilters && itemFilters.length > 0) {
-            const filter = itemFilters.find((f) => f.ItemCode === item.Code);
-            if (filter)
-                filterSQL = (item.WhereClause ? ' AND ' : ' WHERE ') + '(' + filter.Filter + ')';
-        }
-        const columns = this.GetColumnsForDatasetItem(item, datasetName);
-        if (!columns) {
-            return null; // Invalid columns
+    async GenerateSaveSQL(entity, isNew, user) {
+        const spName = this.GetCreateUpdateSPName(entity, isNew);
+        const sqlDetails = await this.GetSaveSQLWithDetails(entity, isNew, spName, user);
+        const result = {
+            fullSQL: sqlDetails.fullSQL,
+            simpleSQL: sqlDetails.simpleSQL,
+        };
+        if (sqlDetails.overlappingChangeData) {
+            result.extraData = { overlappingChangeData: sqlDetails.overlappingChangeData };
         }
-        return `SELECT ${columns} FROM [${item.EntitySchemaName}].[${item.EntityBaseView}] ${item.WhereClause ? 'WHERE ' + item.WhereClause : ''}${filterSQL}`;
+        return result;
     }
-    async GetDatasetItem(item, itemFilters, datasetName, contextUser) {
-        const itemUpdatedAt = new Date(item.DatasetItemUpdatedAt);
-        const datasetUpdatedAt = new Date(item.DatasetUpdatedAt);
-        const datasetMaxUpdatedAt = new Date(Math.max(itemUpdatedAt.getTime(), datasetUpdatedAt.getTime()));
-        const itemSQL = this.GetDatasetItemSQL(item, itemFilters, datasetName);
-        if (!itemSQL) {
-            // failure condition within columns, return a failed result
-            return {
-                EntityID: item.EntityID,
-                EntityName: item.Entity,
-                Code: item.Code,
-                Results: null,
-                LatestUpdateDate: null,
-                Status: 'Invalid columns specified for dataset item',
-                Success: false,
-            };
-        }
-        const itemData = await this.ExecuteSQL(itemSQL, undefined, undefined, contextUser);
-        // get the latest update date
-        let latestUpdateDate = new Date(1900, 1, 1);
-        if (itemData && itemData.length > 0) {
-            itemData.forEach((data) => {
-                if (data[item.DateFieldToCheck] && new Date(data[item.DateFieldToCheck]) > latestUpdateDate) {
-                    latestUpdateDate = new Date(data[item.DateFieldToCheck]);
-                }
-            });
-        }
-        // finally, compare the latestUpdatedDate to the dataset max date, and use the latter if it is more recent
-        if (datasetMaxUpdatedAt > latestUpdateDate) {
-            latestUpdateDate = datasetMaxUpdatedAt;
-        }
+    GenerateDeleteSQL(entity, user) {
+        const sqlDetails = this.GetDeleteSQLWithDetails(entity, user);
         return {
-            EntityID: item.EntityID,
-            EntityName: item.Entity,
-            Code: item.Code,
-            Results: itemData,
-            LatestUpdateDate: latestUpdateDate,
-            Success: itemData !== null && itemData !== undefined,
+            fullSQL: sqlDetails.fullSQL,
+            simpleSQL: sqlDetails.simpleSQL,
         };
     }
-    /**
-     * Gets column info for a dataset item, which might be * for all columns or if a Columns field was provided in the DatasetItem table,
-     * attempts to use those columns assuming they are valid.
-     * @param item
-     * @param datasetName
-     * @returns
-     */
-    GetColumnsForDatasetItem(item, datasetName) {
-        const specifiedColumns = item.Columns ? item.Columns.split(',').map((col) => col.trim()) : [];
-        if (specifiedColumns.length > 0) {
-            // validate that the columns specified are valid within the entity metadata
-            const entity = this.Entities.find((e) => e.ID === item.EntityID);
-            if (!entity && this.Entities.length > 0) {
-                // we have loaded entities (e.g. Entites.length > 0) but the entity wasn't found, log an error and return a failed result
-                // the reason we continue below if we have NOT loaded Entities is that when the system first bootstraps, DATASET gets loaded
-                // FIRST before Entities are loaded to load the entity metadata so this would ALWAYS fail :)
-                // entity not found, return a failed result, shouldn't ever get here  due to the foreign key constraint on the table
-                LogError(`Entity not found for dataset item ${item.Code} in dataset ${datasetName}`);
-                return null;
-            }
-            else {
-                if (entity) {
-                    // have a valid entity, now make sure that all of the columns specified are valid
-                    // only do the column validity check if we have an entity, we can get here if the entity wasn't found IF we haven't loaded entities yet per above comment
-                    const invalidColumns = [];
-                    specifiedColumns.forEach((col) => {
-                        if (!entity.Fields.find((f) => f.Name.trim().toLowerCase() === col.trim().toLowerCase())) {
-                            invalidColumns.push(col);
-                        }
-                    });
-                    if (invalidColumns.length > 0) {
-                        LogError(`Invalid columns specified for dataset item ${item.Code} in dataset ${datasetName}: ${invalidColumns.join(', ')}`);
-                        return null;
-                    }
-                }
-                // check to see if the specified columns include the DateFieldToCheck
-                // in the below we only check entity metadata if we have it, if we don't have it, we just add the special fields back in
-                if (item.DateFieldToCheck && item.DateFieldToCheck.trim().length > 0 && specifiedColumns.indexOf(item.DateFieldToCheck) === -1) {
-                    // we only check the entity if we have it, otherwise we just add it back in
-                    if (!entity || entity.Fields.find((f) => f.Name.trim().toLowerCase() === item.DateFieldToCheck.trim().toLowerCase()))
-                        specifiedColumns.push(item.DateFieldToCheck);
-                }
-            }
+    async OnSaveCompleted(entity, saveSQLResult, user, options) {
+        const overlappingChangeData = saveSQLResult.extraData?.overlappingChangeData;
+        if (overlappingChangeData &&
+            entity.EntityInfo.AllowMultipleSubtypes &&
+            entity.EntityInfo.TrackRecordChanges) {
+            const transaction = entity.ProviderTransaction ?? undefined;
+            await this.PropagateRecordChangesToSiblings(entity.EntityInfo, overlappingChangeData, entity.PrimaryKey.Values(), user?.ID ?? '', options.ISAActiveChildEntityName, transaction ? { connectionSource: transaction } : undefined);
         }
-        return specifiedColumns.length > 0 ? specifiedColumns.map((colName) => `[${colName.trim()}]`).join(',') : '*';
     }
-    async GetDatasetStatusByName(datasetName, itemFilters, contextUser, providerToUse) {
-        const sSQL = `
-            SELECT
-                di.*,
-                e.BaseView EntityBaseView,
-                e.SchemaName EntitySchemaName,
-                d.__mj_UpdatedAt AS DatasetUpdatedAt,
-                di.__mj_UpdatedAt AS DatasetItemUpdatedAt
-            FROM
-                [${this.MJCoreSchemaName}].vwDatasets d
-            INNER JOIN
-                [${this.MJCoreSchemaName}].vwDatasetItems di
-            ON
-                d.ID = di.DatasetID
-            INNER JOIN
-                [${this.MJCoreSchemaName}].vwEntities e
-            ON
-                di.EntityID = e.ID
-            WHERE
-                d.Name = @p0`;
-        let items = [];
-        const useThisProvider = providerToUse ? providerToUse : this;
-        items = await useThisProvider.ExecuteSQL(sSQL, [datasetName], undefined, contextUser);
-        // now we have the dataset and the items, we need to get the update date from the items underlying entities
-        if (items && items.length > 0) {
-            // loop through each of the items and get the update date from the underlying entity by building a combined UNION ALL SQL statement
-            let combinedSQL = '';
-            const updateDates = [];
-            items.forEach((item, index) => {
-                let filterSQL = '';
-                if (itemFilters && itemFilters.length > 0) {
-                    const filter = itemFilters.find((f) => f.ItemCode === item.Code);
-                    if (filter)
-                        filterSQL = ' WHERE ' + filter.Filter;
-                }
-                const itemUpdatedAt = new Date(item.DatasetItemUpdatedAt);
-                const datasetUpdatedAt = new Date(item.DatasetUpdatedAt);
-                const datasetMaxUpdatedAt = new Date(Math.max(itemUpdatedAt.getTime(), datasetUpdatedAt.getTime())).toISOString();
-                const itemSQL = `SELECT
-                                        CASE
-                                            WHEN MAX(${item.DateFieldToCheck}) > '${datasetMaxUpdatedAt}' THEN MAX(${item.DateFieldToCheck})
-                                            ELSE '${datasetMaxUpdatedAt}'
-                                        END AS UpdateDate,
-                                        COUNT(*) AS TheRowCount,
-                                        '${item.EntityID}' AS EntityID,
-                                        '${item.Entity}' AS EntityName
-                                 FROM
-                                    [${item.EntitySchemaName}].[${item.EntityBaseView}]${filterSQL}`;
-                combinedSQL += itemSQL;
-                if (index < items.length - 1) {
-                    combinedSQL += ' UNION ALL ';
-                }
-            });
-            const itemUpdateDates = await useThisProvider.ExecuteSQL(combinedSQL, null, undefined, contextUser);
-            if (itemUpdateDates && itemUpdateDates.length > 0) {
-                let latestUpdateDate = new Date(1900, 1, 1);
-                itemUpdateDates.forEach((itemUpdate) => {
-                    const updateDate = new Date(itemUpdate.UpdateDate);
-                    updateDates.push({
-                        EntityID: itemUpdate.EntityID,
-                        EntityName: itemUpdate.EntityName,
-                        RowCount: itemUpdate.TheRowCount,
-                        UpdateDate: updateDate,
-                    });
-                    if (updateDate > latestUpdateDate) {
-                        latestUpdateDate = updateDate;
-                    }
-                });
-                return {
-                    DatasetID: items[0].DatasetID,
-                    DatasetName: datasetName,
-                    Success: true,
-                    Status: '',
-                    LatestUpdateDate: latestUpdateDate,
-                    EntityUpdateDates: updateDates,
-                };
-            }
-            else {
-                return {
-                    DatasetID: items[0].DatasetID,
-                    DatasetName: datasetName,
-                    Success: false,
-                    Status: 'No update dates found for DatasetName: ' + datasetName,
-                    LatestUpdateDate: null,
-                    EntityUpdateDates: null,
-                };
-            }
-        }
-        else {
-            return {
-                DatasetID: '',
-                DatasetName: datasetName,
-                Success: false,
-                Status: 'No Dataset or Items found for DatasetName: ' + datasetName,
-                EntityUpdateDates: null,
-                LatestUpdateDate: null,
-            };
-        }
+    OnSuspendRefresh() {
+        this._bAllowRefresh = false;
     }
-    async GetApplicationMetadata(contextUser) {
-        const apps = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwApplications`, null, undefined, contextUser);
-        const appEntities = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwApplicationEntities ORDER BY ApplicationName`, undefined, undefined, contextUser);
-        const ret = [];
-        for (let i = 0; i < apps.length; i++) {
-            ret.push(new ApplicationInfo(this, {
-                ...apps[i],
-                ApplicationEntities: appEntities.filter((ae) => ae.ApplicationName.trim().toLowerCase() === apps[i].Name.trim().toLowerCase()),
-            }));
-        }
-        return ret;
+    OnResumeRefresh() {
+        this._bAllowRefresh = true;
     }
-    async GetAuditLogTypeMetadata(contextUser) {
-        const alts = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwAuditLogTypes`, null, undefined, contextUser);
-        const ret = [];
-        for (let i = 0; i < alts.length; i++) {
-            const alt = new AuditLogTypeInfo(alts[i]);
-            ret.push(alt);
-        }
-        return ret;
+    GetTransactionExtraData(_entity) {
+        return { dataSource: this._pool };
     }
-    async GetUserMetadata(contextUser) {
-        const users = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwUsers`, null, undefined, contextUser);
-        const userRoles = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwUserRoles ORDER BY UserID`, undefined, undefined, contextUser);
-        const ret = [];
-        for (let i = 0; i < users.length; i++) {
-            ret.push(new UserInfo(this, {
-                ...users[i],
-                UserRoles: userRoles.filter((ur) => ur.UserID === users[i].ID),
-            }));
-        }
-        return ret;
+    BuildSaveExecuteOptions(entity, sqlDetails) {
+        const opts = super.BuildSaveExecuteOptions(entity, sqlDetails);
+        opts.connectionSource =
+            entity.ProviderTransaction ?? undefined;
+        return opts;
     }
-    async GetAuthorizationMetadata(contextUser) {
-        const auths = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwAuthorizations`, null, undefined, contextUser);
-        const authRoles = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwAuthorizationRoles ORDER BY AuthorizationName`, undefined, undefined, contextUser);
-        const ret = [];
-        for (let i = 0; i < auths.length; i++) {
-            ret.push(new AuthorizationInfo(this, {
-                ...auths[i],
-                AuthorizationRoles: authRoles.filter((ar) => ar.AuthorizationName.trim().toLowerCase() === auths[i].Name.trim().toLowerCase()),
-            }));
+    BuildDeleteExecuteOptions(entity, sqlDetails) {
+        const opts = super.BuildDeleteExecuteOptions(entity, sqlDetails);
+        opts.connectionSource =
+            entity.ProviderTransaction ?? undefined;
+        return opts;
+    }
+    ValidateDeleteResult(entity, rawResult, entityResult) {
+        if (!rawResult || rawResult.length === 0)
+            return false;
+        // SQL Server CASCADE deletes can return multiple result sets (array of arrays)
+        const isMultipleResultSets = Array.isArray(rawResult[0]);
+        const deletedRecord = isMultipleResultSets
+            ? rawResult[rawResult.length - 1][0]
+            : rawResult[0];
+        for (const key of entity.PrimaryKeys) {
+            if (key.Value !== deletedRecord[key.Name]) {
+                entityResult.Message = `Transaction failed to commit, record with primary key ${key.Name}=${key.Value} not found`;
+                return false;
+            }
         }
-        return ret;
+        return true;
     }
+    /**************************************************************************/
+    // END ---- DatabaseProviderBase Override Hooks (Phase 2)
+    /**************************************************************************/
+    /**************************************************************************/
+    // END ---- IEntityDataProvider
+    /**************************************************************************/
+    /**************************************************************************/
+    // START ---- IMetadataProvider
+    /**************************************************************************/
     /**
-     * Processes entity rows returned from SQL Server to handle:
-     * 1. Timezone conversions for datetime fields
-     * 2. Field-level decryption for encrypted fields
-     *
-     * This method specifically handles the conversion of datetime2 fields (which SQL Server returns without timezone info)
-     * to proper UTC dates, preventing JavaScript from incorrectly interpreting them as local time.
+     * Public backward-compatible wrapper that delegates to PostProcessRows (inherited from GenericDP).
+     * Used by SQLServerTransactionGroup which needs a public entry point for row processing.
      *
-     * For encrypted fields, this method decrypts values at the data provider level.
-     * API-level filtering (AllowDecryptInAPI/SendEncryptedValue) is handled by the GraphQL layer.
-     *
-     * @param rows The raw result rows from SQL Server
-     * @param entityInfo The entity metadata to determine field types
-     * @param contextUser Optional user context for decryption operations
-     * @returns The processed rows with corrected datetime values and decrypted fields
-     *
-     * @security Encrypted fields are decrypted here for internal use.
-     *           The API layer handles response filtering based on AllowDecryptInAPI settings.
+     * PostProcessRows (GenericDP) handles: AdjustDatetimeFields → encryption decryption.
      */
     async ProcessEntityRows(rows, entityInfo, contextUser) {
-        if (!rows || rows.length === 0) {
-            return rows;
-        }
-        // Find all datetime fields in the entity
-        const datetimeFields = entityInfo.Fields.filter((field) => field.TSType === EntityFieldTSType.Date);
-        // Find all encrypted fields in the entity
-        const encryptedFields = entityInfo.Fields.filter((field) => field.Encrypt && field.EncryptionKeyID);
-        // If there are no fields requiring processing, return the rows as-is
-        if (datetimeFields.length === 0 && encryptedFields.length === 0) {
+        if (!rows || rows.length === 0)
             return rows;
-        }
-        // Check if we need datetimeoffset adjustment (lazy loaded on first use)
-        const needsAdjustment = datetimeFields.length > 0 ? await this.NeedsDatetimeOffsetAdjustment() : false;
-        // Get encryption engine instance (lazy - only if we have encrypted fields)
-        let encryptionEngine = null;
-        if (encryptedFields.length > 0) {
-            encryptionEngine = EncryptionEngine.Instance;
-            await encryptionEngine.Config(false, contextUser);
-        }
-        // Process each row - need to use Promise.all for async decryption
-        const processedRows = await Promise.all(rows.map(async (row) => {
+        return this.PostProcessRows(rows, entityInfo, contextUser);
+    }
+    /**
+     * SQL Server-specific datetime field adjustments.
+     *
+     * SQL Server's `datetime2` and `datetime` types store values without timezone info.
+     * The mssql driver creates Date objects using local timezone interpretation, which is
+     * incorrect when the server stores UTC. This method adjusts dates back to UTC.
+     *
+     * For `datetimeoffset`, the driver sometimes mishandles timezone info (detected via
+     * `NeedsDatetimeOffsetAdjustment()`), requiring similar correction.
+     */
+    async AdjustDatetimeFields(rows, datetimeFields, entityInfo) {
+        const needsAdjustment = await this.NeedsDatetimeOffsetAdjustment();
+        return rows.map((row) => {
             const processedRow = { ...row };
-            // ========================================================================
-            // DATETIME FIELD PROCESSING
-            // ========================================================================
             for (const field of datetimeFields) {
                 const fieldValue = processedRow[field.Name];
-                // Skip null/undefined values
-                if (fieldValue === null || fieldValue === undefined) {
+                if (fieldValue === null || fieldValue === undefined)
                     continue;
-                }
-                // Handle different datetime field types
                 if (field.Type.toLowerCase() === 'datetime2') {
                     if (typeof fieldValue === 'string') {
-                        // If it's still a string (rare case), convert to UTC
                         if (!fieldValue.includes('Z') && !fieldValue.includes('+') && !fieldValue.includes('-')) {
-                            const utcValue = fieldValue.replace(' ', 'T') + 'Z';
-                            processedRow[field.Name] = new Date(utcValue);
+                            processedRow[field.Name] = new Date(fieldValue.replace(' ', 'T') + 'Z');
                         }
                         else {
                             processedRow[field.Name] = new Date(fieldValue);
                         }
                     }
                     else if (fieldValue instanceof Date) {
-                        // DB driver has already converted to a Date object using local timezone
-                        // We need to adjust it back to UTC
-                        // SQL Server stores datetime2 as UTC, but DB Driver interprets it as local
-                        const localDate = fieldValue;
-                        const timezoneOffsetMs = localDate.getTimezoneOffset() * 60 * 1000;
-                        const utcDate = new Date(localDate.getTime() + timezoneOffsetMs);
-                        processedRow[field.Name] = utcDate;
+                        const timezoneOffsetMs = fieldValue.getTimezoneOffset() * 60 * 1000;
+                        processedRow[field.Name] = new Date(fieldValue.getTime() + timezoneOffsetMs);
                     }
                 }
                 else if (field.Type.toLowerCase() === 'datetimeoffset') {
-                    // Handle datetimeoffset based on empirical test results
                     if (typeof fieldValue === 'string') {
-                        // String format should include timezone offset, parse it correctly
                         processedRow[field.Name] = new Date(fieldValue);
                     }
                     else if (fieldValue instanceof Date && needsAdjustment) {
-                        // The database driver has incorrectly converted to a Date object using local timezone
-                        // For datetimeoffset, SQL Server provides the value with timezone info, but the driver
-                        // creates the Date as if it were in local time, ignoring the offset
-                        // We need to adjust it back to the correct UTC time
-                        const localDate = fieldValue;
-                        const timezoneOffsetMs = localDate.getTimezoneOffset() * 60 * 1000;
-                        const utcDate = new Date(localDate.getTime() + timezoneOffsetMs);
-                        processedRow[field.Name] = utcDate;
+                        const timezoneOffsetMs = fieldValue.getTimezoneOffset() * 60 * 1000;
+                        processedRow[field.Name] = new Date(fieldValue.getTime() + timezoneOffsetMs);
                     }
-                    // If it's already a Date object and no adjustment needed, leave as-is
                 }
                 else if (field.Type.toLowerCase() === 'datetime') {
-                    // Legacy datetime type - similar handling to datetime2
                     if (fieldValue instanceof Date) {
-                        const localDate = fieldValue;
-                        const timezoneOffsetMs = localDate.getTimezoneOffset() * 60 * 1000;
-                        const utcDate = new Date(localDate.getTime() + timezoneOffsetMs);
-                        processedRow[field.Name] = utcDate;
-                    }
-                }
-                // For other types (date, time), leave as-is
-            }
-            // ========================================================================
-            // ENCRYPTED FIELD PROCESSING (DECRYPTION)
-            // Decrypt at the data provider level for internal use.
-            // API-level filtering based on AllowDecryptInAPI is handled by GraphQL resolvers.
-            // ========================================================================
-            if (encryptionEngine && encryptedFields.length > 0) {
-                for (const field of encryptedFields) {
-                    const fieldValue = processedRow[field.Name];
-                    // Skip null/undefined/empty values
-                    if (fieldValue === null || fieldValue === undefined || fieldValue === '') {
-                        continue;
-                    }
-                    // Only decrypt if the value is actually encrypted
-                    const keyMarker = field.EncryptionKeyID ? encryptionEngine.GetKeyByID(field.EncryptionKeyID)?.Marker : undefined;
-                    if (typeof fieldValue === 'string' && encryptionEngine.IsEncrypted(fieldValue, keyMarker)) {
-                        try {
-                            const decryptedValue = await encryptionEngine.Decrypt(fieldValue, contextUser);
-                            processedRow[field.Name] = decryptedValue;
-                        }
-                        catch (decryptError) {
-                            // Log error but don't fail the entire operation
-                            // Return the encrypted value so the caller knows something is wrong
-                            const message = decryptError instanceof Error ? decryptError.message : String(decryptError);
-                            LogError(`Failed to decrypt field "${field.Name}" on entity "${entityInfo.Name}": ${message}. ` +
-                                'The encrypted value will be returned unchanged.');
-                            // Keep the encrypted value in the row - let the caller decide what to do
-                        }
+                        const timezoneOffsetMs = fieldValue.getTimezoneOffset() * 60 * 1000;
+                        processedRow[field.Name] = new Date(fieldValue.getTime() + timezoneOffsetMs);
                     }
                 }
             }
             return processedRow;
-        }));
-        return processedRows;
+        });
     }
     /**
      * Static method for executing SQL with proper handling of connections and logging.
@@ -4535,7 +1656,7 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
                 transaction: null,
                 logSqlStatement: async (q, p, d, i, m, s, u) => {
                     // Use static logging method
-                    await SQLServerDataProvider.LogSQLStatement(q, p, d || 'ExecuteSQLWithPool', m || false, s, u);
+                    await GenericDatabaseProvider.LogSQLStatement(q, p, d || 'ExecuteSQLWithPool', m || false, s, u);
                 }
             };
             // Create options
@@ -4628,7 +1749,7 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
                 pool: pool,
                 transaction: transaction,
                 logSqlStatement: async (q, p, d, i, m, s, u) => {
-                    await SQLServerDataProvider.LogSQLStatement(q, p, d || 'Batch execution', m || false, s, u);
+                    await GenericDatabaseProvider.LogSQLStatement(q, p, d || 'Batch execution', m || false, s, u);
                 }
             };
             // Use named parameters for batch SQL
@@ -4848,60 +1969,12 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
             await txn.rollback();
         }
     }
-    /**
-     * Discovers which IS-A child entity, if any, has a record with the given primary key.
-     * Executes a single UNION ALL query across all child entity tables for maximum efficiency.
-     * Each branch of the UNION is a PK lookup on a clustered index — effectively instant.
-     *
-     * @param entityInfo The parent entity whose children to search
-     * @param recordPKValue The primary key value to find in child tables
-     * @param contextUser Optional context user for audit/permission purposes
-     * @returns The child entity name if found, or null if no child record exists
-     */
-    async FindISAChildEntity(entityInfo, recordPKValue, contextUser) {
-        const childEntities = entityInfo.ChildEntities;
-        if (childEntities.length === 0)
-            return null;
-        const unionSQL = this.buildChildDiscoverySQL(childEntities, recordPKValue);
-        if (!unionSQL)
-            return null;
-        const results = await this.ExecuteSQL(unionSQL, undefined, undefined, contextUser);
-        if (results && results.length > 0 && results[0].EntityName) {
-            return { ChildEntityName: results[0].EntityName };
-        }
-        return null;
-    }
-    /**
-     * Discovers ALL IS-A child entities that have records with the given primary key.
-     * Used for overlapping subtype parents (AllowMultipleSubtypes = true) where multiple
-     * children can coexist. Same UNION ALL query as FindISAChildEntity, but returns all matches.
-     *
-     * @param entityInfo The parent entity whose children to search
-     * @param recordPKValue The primary key value to find in child tables
-     * @param contextUser Optional context user for audit/permission purposes
-     * @returns Array of child entity names found (empty if none)
-     */
-    async FindISAChildEntities(entityInfo, recordPKValue, contextUser) {
-        const childEntities = entityInfo.ChildEntities;
-        if (childEntities.length === 0)
-            return [];
-        const unionSQL = this.buildChildDiscoverySQL(childEntities, recordPKValue);
-        if (!unionSQL)
-            return [];
-        const results = await this.ExecuteSQL(unionSQL, undefined, undefined, contextUser);
-        if (results && results.length > 0) {
-            return results
-                .filter((r) => r.EntityName)
-                .map((r) => ({ ChildEntityName: r.EntityName }));
-        }
-        return [];
-    }
     /**
      * Builds a UNION ALL query that checks each child entity's base table for a record
      * with the given primary key. Returns the first match (disjoint subtypes guarantee
      * at most one result) unless used with overlapping subtypes.
      */
-    buildChildDiscoverySQL(childEntities, recordPKValue) {
+    BuildChildDiscoverySQL(childEntities, recordPKValue) {
         // Sanitize the PK value to prevent SQL injection
         const safePKValue = recordPKValue.replace(/'/g, "''");
         const unionParts = childEntities
@@ -4937,74 +2010,16 @@ export class SQLServerDataProvider extends DatabaseProviderBase {
      *        Undefined when saving the parent directly — all children get propagated to.
      * @param transaction The active IS-A transaction, or undefined for standalone saves
      */
-    async PropagateRecordChangesToSiblings(parentInfo, changeData, pkValue, userId, activeChildEntityName, transaction) {
-        const sqlParts = [];
-        let varIndex = 0;
-        const safePKValue = pkValue.replace(/'/g, "''");
-        const safeUserId = userId.replace(/'/g, "''");
-        const safeChangesJSON = changeData.changesJSON.replace(/'/g, "''");
-        const safeChangesDesc = changeData.changesDescription.replace(/'/g, "''");
-        for (const childInfo of parentInfo.ChildEntities) {
-            // Skip the active branch (the child that initiated the parent save).
-            // When activeChildEntityName is undefined (direct save on parent), propagate to ALL children.
-            if (activeChildEntityName && this.isEntityOrAncestorOf(childInfo, activeChildEntityName))
-                continue;
-            // Recursively enumerate this child's entire sub-tree from metadata
-            const subTree = this.getFullSubTree(childInfo);
-            for (const entityInTree of subTree) {
-                if (!entityInTree.TrackRecordChanges)
-                    continue;
-                const varName = `@_rc_prop_${varIndex++}`;
-                sqlParts.push(this.buildSiblingRecordChangeSQL(varName, entityInTree, safeChangesJSON, safeChangesDesc, safePKValue, safeUserId));
-            }
-        }
-        // Execute as single batch
-        if (sqlParts.length > 0) {
-            const batch = sqlParts.join('\n');
-            await this.ExecuteSQL(batch, undefined, {
-                connectionSource: transaction,
-                description: 'IS-A overlapping subtype Record Change propagation',
-                isMutation: true
-            });
-        }
-    }
-    /**
-     * Checks whether a given entity matches the target name, or is an ancestor
-     * of the target (i.e., the target is somewhere in its descendant sub-tree).
-     * Used to identify and skip the active branch during sibling propagation.
-     */
-    isEntityOrAncestorOf(entityInfo, targetName) {
-        if (entityInfo.Name === targetName)
-            return true;
-        for (const child of entityInfo.ChildEntities) {
-            if (this.isEntityOrAncestorOf(child, targetName))
-                return true;
-        }
-        return false;
-    }
-    /**
-     * Recursively enumerates an entity's entire sub-tree from metadata.
-     * No DB queries — uses EntityInfo.ChildEntities which is populated from metadata.
-     */
-    getFullSubTree(entityInfo) {
-        const result = [entityInfo];
-        for (const child of entityInfo.ChildEntities) {
-            result.push(...this.getFullSubTree(child));
-        }
-        return result;
-    }
     /**
-     * Generates a single block of SQL for one sibling entity in the Record Change
+     * Generates a single block of T-SQL for one sibling entity in the Record Change
      * propagation batch. Uses SELECT...FOR JSON to get the full record, then
-     * conditionally inserts a Record Change entry if the record exists.
+     * conditionally inserts a Record Change entry via spCreateRecordChange_Internal.
      */
-    buildSiblingRecordChangeSQL(varName, entityInfo, safeChangesJSON, safeChangesDesc, safePKValue, safeUserId) {
+    BuildSiblingRecordChangeSQL(varName, entityInfo, safeChangesJSON, safeChangesDesc, safePKValue, safeUserId) {
         const schema = entityInfo.SchemaName || '__mj';
         const view = entityInfo.BaseView;
         const pkName = entityInfo.PrimaryKeys[0]?.Name ?? 'ID';
         const safeEntityName = entityInfo.Name.replace(/'/g, "''");
-        // Build RecordID in CompositeKey format: "FieldCodeName|Value" (or "F1|V1||F2|V2" for composite PKs)
-        // Must match the format used by the main save flow (concatPKIDString in GetSaveSQLWithDetails)
         const recordID = entityInfo.PrimaryKeys
             .map(pk => `${pk.CodeName}${CompositeKey.DefaultValueDelimiter}${safePKValue}`)
             .join(CompositeKey.DefaultFieldDelimiter);
@@ -5187,64 +2202,6 @@ IF ${varName} IS NOT NULL
             this._fileSystemProvider = new NodeFileSystemProvider();
         return this._fileSystemProvider;
     }
-    async InternalGetEntityRecordNames(info, contextUser) {
-        const promises = info.map(async (item) => {
-            const r = await this.InternalGetEntityRecordName(item.EntityName, item.CompositeKey, contextUser);
-            return {
-                EntityName: item.EntityName,
-                CompositeKey: item.CompositeKey,
-                RecordName: r,
-                Success: r ? true : false,
-                Status: r ? 'Success' : 'Error',
-            };
-        });
-        return Promise.all(promises);
-    }
-    async InternalGetEntityRecordName(entityName, CompositeKey, contextUser) {
-        try {
-            const sql = this.GetEntityRecordNameSQL(entityName, CompositeKey);
-            if (sql) {
-                const data = await this.ExecuteSQL(sql, null, undefined, contextUser);
-                if (data && data.length === 1) {
-                    const fields = Object.keys(data[0]);
-                    return data[0][fields[0]]; // return first field
-                }
-                else {
-                    LogError(`Entity ${entityName} record ${CompositeKey.ToString()} not found, returning null`);
-                    return null;
-                }
-            }
-        }
-        catch (e) {
-            LogError(e);
-            return null;
-        }
-    }
-    GetEntityRecordNameSQL(entityName, CompositeKey) {
-        const e = this.Entities.find((e) => e.Name === entityName);
-        if (!e)
-            throw new Error(`Entity ${entityName} not found`);
-        else {
-            const f = e.NameField;
-            if (!f) {
-                LogError(`Entity ${entityName} does not have an IsNameField or a field with the column name of Name, returning null, use recordId`);
-                return null;
-            }
-            else {
-                // got our field, create a SQL Query
-                const sql = `SELECT [${f.Name}] FROM [${e.SchemaName}].[${e.BaseView}] WHERE `;
-                let where = '';
-                for (const pkv of CompositeKey.KeyValuePairs) {
-                    const pk = e.PrimaryKeys.find((pk) => pk.Name === pkv.FieldName);
-                    const quotes = pk.NeedsQuotes ? "'" : '';
-                    if (where.length > 0)
-                        where += ' AND ';
-                    where += `[${pkv.FieldName}]=${quotes}${pkv.Value}${quotes}`;
-                }
-                return sql + where;
-            }
-        }
-    }
     async CreateTransactionGroup() {
         return new SQLServerTransactionGroup();
     }