@memberjunction/sqlserver-dataprovider 2.50.0 → 2.51.0

package/dist/SQLServerDataProvider.js

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLServerDataProvider = exports.SQLServerProviderConfigData = void 0;
+exports.SQLServerDataProvider = void 0;
 /**************************************************************************************************************
  * The SQLServerDataProvider provides a data provider for the entities framework that uses SQL Server directly
  * In practice - this FILE will NOT exist in the entities library, we need to move to its own separate project
@@ -46,251 +46,11 @@ const core_entities_1 = require("@memberjunction/core-entities");
 const aiengine_1 = require("@memberjunction/aiengine");
 const queue_1 = require("@memberjunction/queue");
 const sql = __importStar(require("mssql"));
+const rxjs_1 = require("rxjs");
 const SQLServerTransactionGroup_1 = require("./SQLServerTransactionGroup");
-const UserCache_1 = require("./UserCache");
+const SqlLogger_js_1 = require("./SqlLogger.js");
 const actions_1 = require("@memberjunction/actions");
 const uuid_1 = require("uuid");
-const sql_formatter_1 = require("sql-formatter");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-/**
- * Configuration data specific to SQL Server provider
- */
-class SQLServerProviderConfigData extends core_1.ProviderConfigDataBase {
-    /**
-     * Gets the SQL Server data source configuration
-     */
-    get DataSource() {
-        return this.Data.DataSource;
-    }
-    /**
-     * Gets the current user's email address
-     */
-    get CurrentUserEmail() {
-        return this.Data.CurrentUserEmail;
-    }
-    /**
-     * Gets the interval in seconds for checking metadata refresh
-     */
-    get CheckRefreshIntervalSeconds() {
-        return this.Data.CheckRefreshIntervalSeconds;
-    }
-    constructor(dataSource, currentUserEmail, MJCoreSchemaName, checkRefreshIntervalSeconds = 0 /*default to disabling auto refresh */, includeSchemas, excludeSchemas) {
-        super({
-            DataSource: dataSource,
-            CurrentUserEmail: currentUserEmail,
-            CheckRefreshIntervalSeconds: checkRefreshIntervalSeconds,
-        }, MJCoreSchemaName, includeSchemas, excludeSchemas);
-    }
-}
-exports.SQLServerProviderConfigData = SQLServerProviderConfigData;
-/**
- * Internal implementation of SqlLoggingSession that handles SQL statement logging to files.
- * This class manages file I/O, SQL formatting, and filtering based on session options.
- *
- * @internal
- */
-class SqlLoggingSessionImpl {
-    constructor(id, filePath, options = {}) {
-        this._statementCount = 0;
-        this._emittedStatementCount = 0; // Track actually emitted statements
-        this._fileHandle = null;
-        this._disposed = false;
-        this.id = id;
-        this.filePath = filePath;
-        this.startTime = new Date();
-        this.options = options;
-    }
-    /**
-     * Gets the count of SQL statements actually written to the log file
-     * @returns The number of emitted statements (after filtering)
-     */
-    get statementCount() {
-        return this._emittedStatementCount; // Return actually emitted statements
-    }
-    /**
-     * Initializes the logging session by creating the log file and writing the header
-     * @throws Error if file creation fails
-     */
-    async initialize() {
-        // Ensure directory exists
-        const dir = path.dirname(this.filePath);
-        await fs.promises.mkdir(dir, { recursive: true });
-        // Open file for writing
-        this._fileHandle = await fs.promises.open(this.filePath, 'w');
-        // Write header comment
-        const header = this._generateHeader();
-        await this._fileHandle.writeFile(header);
-    }
-    /**
-     * Logs a SQL statement to the file, applying filtering and formatting based on session options
-     *
-     * @param query - The SQL query to log
-     * @param parameters - Optional 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 if logRecordChangeMetadata=false
-     */
-    async logSqlStatement(query, parameters, description, isMutation = false, simpleSQLFallback) {
-        if (this._disposed || !this._fileHandle) {
-            return;
-        }
-        // Filter statements based on statementTypes option
-        const statementTypes = this.options.statementTypes || 'both';
-        if (statementTypes === 'mutations' && !isMutation) {
-            return; // Skip logging non-mutation statements
-        }
-        if (statementTypes === 'queries' && isMutation) {
-            return; // Skip logging mutation statements
-        }
-        let logEntry = '';
-        // Add description comment if provided
-        if (description) {
-            logEntry += `-- ${description}\n`;
-        }
-        // Process the SQL statement
-        let processedQuery = query;
-        // Use simple SQL fallback if this session has logRecordChangeMetadata=false (default) and fallback is provided
-        if (this.options.logRecordChangeMetadata !== true && simpleSQLFallback) {
-            processedQuery = simpleSQLFallback;
-            // Update description to indicate we're using the simplified version
-            if (description && !description.includes('(core SP call only)')) {
-                logEntry = logEntry.replace(`-- ${description}\n`, `-- ${description} (core SP call only)\n`);
-            }
-        }
-        // Replace schema names with Flyway placeholders if migration format
-        if (this.options.formatAsMigration) {
-            processedQuery = processedQuery.replace(/\[(\w+)\]\./g, '[${flyway:defaultSchema}].');
-        }
-        // Apply pretty printing if enabled
-        if (this.options.prettyPrint) {
-            processedQuery = this._prettyPrintSql(processedQuery);
-        }
-        // Add the SQL statement
-        logEntry += `${processedQuery};\n`;
-        // Add parameter comment if parameters exist
-        if (parameters) {
-            if (Array.isArray(parameters)) {
-                if (parameters.length > 0) {
-                    logEntry += `-- Parameters: ${parameters.map((p, i) => `@p${i}='${p}'`).join(', ')}\n`;
-                }
-            }
-            else if (typeof parameters === 'object') {
-                const paramStr = Object.entries(parameters)
-                    .map(([key, value]) => `@${key}='${value}'`)
-                    .join(', ');
-                if (paramStr) {
-                    logEntry += `-- Parameters: ${paramStr}\n`;
-                }
-            }
-        }
-        // Add batch separator if specified
-        if (this.options.batchSeparator) {
-            logEntry += `\n${this.options.batchSeparator}\n`;
-        }
-        logEntry += '\n'; // Add blank line between statements
-        await this._fileHandle.writeFile(logEntry);
-        this._statementCount++;
-        this._emittedStatementCount++; // Track actually emitted statements
-    }
-    /**
-     * Disposes of the logging session, writes the footer, closes the file, and optionally deletes empty files
-     */
-    async dispose() {
-        if (this._disposed) {
-            return;
-        }
-        this._disposed = true;
-        if (this._fileHandle) {
-            // Write footer comment
-            const footer = this._generateFooter();
-            await this._fileHandle.writeFile(footer);
-            await this._fileHandle.close();
-            this._fileHandle = null;
-            // Check if we should delete empty log files
-            if (this._emittedStatementCount === 0 && !this.options.retainEmptyLogFiles) {
-                try {
-                    await fs.promises.unlink(this.filePath);
-                    // Log that we deleted the empty file (optional)
-                    console.log(`Deleted empty SQL log file: ${this.filePath}`);
-                }
-                catch (error) {
-                    // Ignore errors during deletion (file might already be deleted, etc.)
-                    console.error(`Failed to delete empty SQL log file: ${this.filePath}`, error);
-                }
-            }
-        }
-    }
-    _generateHeader() {
-        let header = `-- SQL Logging Session\n`;
-        header += `-- Session ID: ${this.id}\n`;
-        header += `-- Started: ${this.startTime.toISOString()}\n`;
-        if (this.options.description) {
-            header += `-- Description: ${this.options.description}\n`;
-        }
-        if (this.options.formatAsMigration) {
-            header += `-- Format: Migration-ready with Flyway schema placeholders\n`;
-        }
-        header += `-- Generated by MemberJunction SQLServerDataProvider\n`;
-        header += `\n`;
-        return header;
-    }
-    _generateFooter() {
-        const endTime = new Date();
-        const duration = endTime.getTime() - this.startTime.getTime();
-        let footer = `\n-- End of SQL Logging Session\n`;
-        footer += `-- Session ID: ${this.id}\n`;
-        footer += `-- Completed: ${endTime.toISOString()}\n`;
-        footer += `-- Duration: ${duration}ms\n`;
-        footer += `-- Total Statements: ${this._emittedStatementCount}\n`;
-        return footer;
-    }
-    /**
-     * Format SQL using sql-formatter library with SQL Server dialect
-     */
-    _prettyPrintSql(sql) {
-        if (!sql)
-            return sql;
-        try {
-            let formatted = (0, sql_formatter_1.format)(sql, {
-                language: 'tsql', // SQL Server Transact-SQL dialect
-                tabWidth: 2,
-                keywordCase: 'upper',
-                functionCase: 'upper',
-                dataTypeCase: 'upper',
-                linesBetweenQueries: 1,
-            });
-            // Post-process to fix BEGIN/END formatting
-            formatted = this._postProcessBeginEnd(formatted);
-            return formatted;
-        }
-        catch (error) {
-            // If formatting fails, return original SQL
-            console.warn('SQL formatting failed, returning original:', error);
-            return sql;
-        }
-    }
-    /**
-     * Post-process SQL to ensure BEGIN, END, and EXEC keywords are on their own lines
-     */
-    _postProcessBeginEnd(sql) {
-        if (!sql)
-            return sql;
-        // Fix BEGIN keyword - ensure it's on its own line
-        // Match: any non-whitespace followed by space(s) followed by BEGIN (word boundary)
-        sql = sql.replace(/(\S)\s+(BEGIN\b)/g, '$1\n$2');
-        // Fix BEGIN followed by other keywords - ensure what follows BEGIN is on a new line
-        // Match: BEGIN followed by space(s) followed by non-whitespace
-        sql = sql.replace(/(BEGIN\b)\s+(\S)/g, '$1\n$2');
-        // Fix END keyword - ensure it's on its own line
-        // Match: any non-whitespace followed by space(s) followed by END (word boundary)
-        sql = sql.replace(/(\S)\s+(END\b)/g, '$1\n$2');
-        // Fix EXEC keyword - ensure it's on its own line
-        // Match: any non-whitespace followed by space(s) followed by EXEC (word boundary)
-        sql = sql.replace(/(\S)\s+(EXEC\b)/g, '$1\n$2');
-        return sql;
-    }
-}
 /**
  * SQL Server implementation of the MemberJunction data provider interfaces.
  *
@@ -305,7 +65,7 @@ class SqlLoggingSessionImpl {
  *
  * @example
  * ```typescript
- * const config = new SQLServerProviderConfigData(dataSource, userEmail);
+ * const config = new SQLServerProviderConfigData(dataSource);
  * const provider = new SQLServerDataProvider(config);
  * await provider.Config();
  * ```
@@ -317,6 +77,26 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         this._needsDatetimeOffsetAdjustment = false;
         this._datetimeOffsetTestComplete = false;
         this._sqlLoggingSessions = new Map();
+        // Transaction state management
+        this._transactionState$ = new rxjs_1.BehaviorSubject(false);
+        this._deferredTasks = [];
+    }
+    /**
+     * Observable that emits the current transaction state (true when active, false when not)
+     * External code can subscribe to this to know when transactions start and end
+     * @example
+     * provider.transactionState$.subscribe(isActive => {
+     *   console.log('Transaction active:', isActive);
+     * });
+     */
+    get transactionState$() {
+        return this._transactionState$.asObservable();
+    }
+    /**
+     * Gets whether a transaction is currently active
+     */
+    get isTransactionActive() {
+        return this._transactionState$.value;
     }
     /**
      * Gets the current configuration data for this provider instance
@@ -333,7 +113,6 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     async Config(configData) {
         try {
             this._pool = configData.DataSource; // Now expects a ConnectionPool instead of DataSource
-            this._currentUserEmail = configData.CurrentUserEmail;
             return super.Config(configData); // now parent class can do it's config
         }
         catch (e) {
@@ -393,7 +172,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @example
      * ```typescript
      * // Basic usage
-     * const session = await provider.createSqlLogger('./logs/metadata-sync.sql');
+     * const session = await provider.CreateSqlLogger('./logs/metadata-sync.sql');
      * try {
      *   // Perform operations that will be logged
      *   await provider.ExecuteSQL('INSERT INTO ...');
@@ -402,15 +181,15 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * }
      *
      * // With migration formatting
-     * const session = await provider.createSqlLogger('./migrations/changes.sql', {
+     * const session = await provider.CreateSqlLogger('./migrations/changes.sql', {
      *   formatAsMigration: true,
      *   description: 'MetadataSync push operation'
      * });
      * ```
      */
-    async createSqlLogger(filePath, options) {
+    async CreateSqlLogger(filePath, options) {
         const sessionId = (0, uuid_1.v4)();
-        const session = new SqlLoggingSessionImpl(sessionId, filePath, options);
+        const session = new SqlLogger_js_1.SqlLoggingSessionImpl(sessionId, filePath, options);
         // Initialize the session (create file, write header)
         await session.initialize();
         // Store in active sessions map
@@ -430,13 +209,16 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             },
         };
     }
+    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() {
+    GetActiveSqlLoggingSessions() {
         return Array.from(this._sqlLoggingSessions.values()).map((session) => ({
             id: session.id,
             filePath: session.filePath,
@@ -449,7 +231,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * Disposes all active SQL logging sessions.
      * Useful for cleanup on provider shutdown.
      */
-    async disposeAllSqlLoggingSessions() {
+    async DisposeAllSqlLoggingSessions() {
         const disposePromises = Array.from(this._sqlLoggingSessions.values()).map((session) => session.dispose());
         await Promise.all(disposePromises);
         this._sqlLoggingSessions.clear();
@@ -465,13 +247,57 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @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) {
+    async _logSqlStatement(query, parameters, description, ignoreLogging = false, isMutation = false, simpleSQLFallback, contextUser) {
         if (ignoreLogging || this._sqlLoggingSessions.size === 0) {
             return;
         }
-        // Log to all active sessions in parallel
-        const logPromises = Array.from(this._sqlLoggingSessions.values()).map((session) => session.logSqlStatement(query, parameters, description, isMutation, simpleSQLFallback));
+        // 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
@@ -482,11 +308,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @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) {
+    static async LogSQLStatement(query, parameters, description, isMutation = false, simpleSQLFallback, contextUser) {
         // Get the current provider instance
         const provider = core_1.Metadata.Provider;
         if (provider && provider._sqlLoggingSessions.size > 0) {
-            await provider._logSqlStatement(query, parameters, description, false, isMutation, simpleSQLFallback);
+            await provider._logSqlStatement(query, parameters, description, false, isMutation, simpleSQLFallback, contextUser);
         }
     }
     /**************************************************************************/
@@ -499,11 +325,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         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);
+        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);
+            const result = await this.ExecuteSQL(sql, undefined, undefined, contextUser);
             const end = new Date().getTime();
             if (result)
                 return {
@@ -545,11 +371,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 filter += ` AND Category = '${params.CategoryName}'`; /* if CategoryName is provided, we add it to the filter */
             }
             const sqlQuery = `SELECT ID, Name, SQL FROM [${this.MJCoreSchemaName}].vwQueries WHERE ${filter}`;
-            const queryInfo = await this.ExecuteSQL(sqlQuery);
+            const queryInfo = await this.ExecuteSQL(sqlQuery, undefined, undefined, contextUser);
             if (queryInfo && queryInfo.length > 0) {
                 const start = new Date().getTime();
                 const sql = queryInfo[0].SQL;
-                const result = await this.ExecuteSQL(sql);
+                const result = await this.ExecuteSQL(sql, undefined, undefined, contextUser);
                 const end = new Date().getTime();
                 if (result)
                     return {
@@ -653,7 +479,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             if (params) {
                 const user = contextUser ? contextUser : this.CurrentUser;
                 if (!user)
-                    throw new Error(`User ${this._currentUserEmail} not found in metadata and no contextUser provided to RunView()`);
+                    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;
@@ -803,13 +629,13 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     viewSQL += ` OFFSET ${params.StartRow} ROWS FETCH NEXT ${params.MaxRows} ROWS ONLY`;
                 }
                 // now we can run the viewSQL, but only do this if the ResultType !== 'count_only', otherwise we don't need to run the viewSQL
-                const retData = params.ResultType === 'count_only' ? [] : await this.ExecuteSQL(viewSQL);
+                const retData = params.ResultType === 'count_only' ? [] : await this.ExecuteSQL(viewSQL, undefined, undefined, contextUser);
                 // finally, if we have a countSQL, we need to run that to get the row count
                 // but only do that if the # of rows returned is equal to the max rows, otherwise we know we have all the rows
                 // OR do that if we are doing a count_only
                 let rowCount = null;
                 if (countSQL && (params.ResultType === 'count_only' || retData.length === entityInfo.UserViewMaxRows)) {
-                    const countResult = await this.ExecuteSQL(countSQL);
+                    const countResult = await this.ExecuteSQL(countSQL, undefined, undefined, contextUser);
                     if (countResult && countResult.length > 0) {
                         rowCount = countResult[0].TotalRowCount;
                     }
@@ -820,7 +646,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     // 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({
+                    this.CreateAuditLogRecord(user, 'Run View', 'Run View', 'Success', JSON.stringify({
                         ViewID: viewEntity?.ID,
                         ViewName: viewEntity?.Name,
                         Description: params.AuditLogDescription,
@@ -967,7 +793,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             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);
+        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})
@@ -1032,7 +858,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         return sUserSearchSQL;
     }
-    async createAuditLogRecord(user, authorizationName, auditLogTypeName, status, details, entityId, recordId, auditLogDescription) {
+    async CreateAuditLogRecord(user, authorizationName, auditLogTypeName, status, details, entityId, recordId, auditLogDescription) {
         try {
             const authorization = authorizationName
                 ? this.Authorizations.find((a) => a?.Name?.trim().toLowerCase() === authorizationName.trim().toLowerCase())
@@ -1090,14 +916,14 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     get ProviderType() {
         return core_1.ProviderType.Database;
     }
-    async GetRecordFavoriteStatus(userId, entityName, CompositeKey) {
-        const id = await this.GetRecordFavoriteID(userId, entityName, CompositeKey);
+    async GetRecordFavoriteStatus(userId, entityName, CompositeKey, contextUser) {
+        const id = await this.GetRecordFavoriteID(userId, entityName, CompositeKey, contextUser);
         return id !== null;
     }
-    async GetRecordFavoriteID(userId, entityName, CompositeKey) {
+    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);
+            const result = await this.ExecuteSQL(sSQL, null, undefined, contextUser);
             if (result && result.length > 0)
                 return result[0].ID;
             else
@@ -1141,10 +967,10 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             throw e;
         }
     }
-    async GetRecordChanges(entityName, compositeKey) {
+    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);
+            return this.ExecuteSQL(sSQL, undefined, undefined, contextUser);
         }
         catch (e) {
             (0, core_1.LogError)(e);
@@ -1219,7 +1045,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @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) {
+    async GetRecordDependencies(entityName, compositeKey, contextUser) {
         try {
             const recordDependencies = [];
             // first, get the entity dependencies for this entity
@@ -1231,7 +1057,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             // 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);
+            const result = await this.ExecuteSQL(sSQL, null, undefined, contextUser);
             if (!result || result.length === 0) {
                 return recordDependencies;
             }
@@ -1610,7 +1436,14 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                         else {
                             // just add a task and move on, we are doing 'after save' so we don't wait
                             try {
-                                queue_1.QueueManager.AddTask('Entity AI Action', p, null, user);
+                                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
+                                    queue_1.QueueManager.AddTask('Entity AI Action', p, null, user);
+                                }
                             }
                             catch (e) {
                                 (0, core_1.LogError)(e.message);
@@ -1734,7 +1567,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                                 isMutation: true,
                                 description: `Save ${entity.EntityInfo.Name}`,
                                 simpleSQLFallback: entity.EntityInfo.TrackRecordChanges ? sqlDetails.simpleSQL : undefined
-                            });
+                            }, user);
                             result = await this.ProcessEntityRows(rawResult, entity.EntityInfo);
                         }
                         this._bAllowRefresh = true; // allow refreshes now
@@ -1925,7 +1758,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     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);
+            const result = await this.ExecuteSQL(sSQL, undefined, undefined, user);
             return result;
         }
     }
@@ -2035,7 +1868,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             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);
+        const rawData = await this.ExecuteSQL(sql, undefined, undefined, user);
         const d = await this.ProcessEntityRows(rawData, entity.EntityInfo);
         if (d && d.length > 0) {
             // got the record, now process the relationships if there are any
@@ -2076,7 +1909,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                                             [${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);
+                        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());
@@ -2252,7 +2085,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                         isMutation: true,
                         description: `Delete ${entity.EntityInfo.Name}`,
                         simpleSQLFallback: entity.EntityInfo.TrackRecordChanges ? sqlDetails.simpleSQL : undefined
-                    });
+                    }, user);
                 }
                 if (d && d[0]) {
                     // SP executed, now make sure the return value matches up as that is how we know the SP was succesfully internally
@@ -2288,7 +2121,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     /**************************************************************************/
     // START ---- IMetadataProvider
     /**************************************************************************/
-    async GetDatasetByName(datasetName, itemFilters) {
+    async GetDatasetByName(datasetName, itemFilters, contextUser) {
         const sSQL = `SELECT
                         di.*,
                         e.BaseView EntityBaseView,
@@ -2307,7 +2140,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                         di.EntityID = e.ID
                     WHERE
                         d.Name = @p0`;
-        const items = await this.ExecuteSQL(sSQL, [datasetName]);
+        const items = await this.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
@@ -2326,7 +2159,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 }
             }
             // Execute all queries in a single batch
-            const batchResults = await this.ExecuteSQLBatch(queries);
+            const batchResults = await this.ExecuteSQLBatch(queries, undefined, undefined, contextUser);
             // Process results for each item
             const results = [];
             let queryIndex = 0;
@@ -2425,7 +2258,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         return `SELECT ${columns} FROM [${item.EntitySchemaName}].[${item.EntityBaseView}] ${item.WhereClause ? 'WHERE ' + item.WhereClause : ''}${filterSQL}`;
     }
-    async GetDatasetItem(item, itemFilters, datasetName) {
+    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()));
@@ -2442,7 +2275,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 Success: false,
             };
         }
-        const itemData = await this.ExecuteSQL(itemSQL);
+        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) {
@@ -2511,7 +2344,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         return specifiedColumns.length > 0 ? specifiedColumns.map((colName) => `[${colName.trim()}]`).join(',') : '*';
     }
-    async GetDatasetStatusByName(datasetName, itemFilters) {
+    async GetDatasetStatusByName(datasetName, itemFilters, contextUser) {
         const sSQL = `
             SELECT
                 di.*,
@@ -2531,7 +2364,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 di.EntityID = e.ID
             WHERE
                 d.Name = @p0`;
-        const items = await this.ExecuteSQL(sSQL, [datasetName]);
+        const items = await this.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
@@ -2562,7 +2395,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     combinedSQL += ' UNION ALL ';
                 }
             });
-            const itemUpdateDates = await this.ExecuteSQL(combinedSQL);
+            const itemUpdateDates = await this.ExecuteSQL(combinedSQL, null, undefined, contextUser);
             if (itemUpdateDates && itemUpdateDates.length > 0) {
                 let latestUpdateDate = new Date(1900, 1, 1);
                 itemUpdateDates.forEach((itemUpdate) => {
@@ -2608,9 +2441,9 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             };
         }
     }
-    async GetApplicationMetadata() {
-        const apps = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwApplications`, null);
-        const appEntities = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwApplicationEntities ORDER BY ApplicationName`);
+    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 core_1.ApplicationInfo(this, {
@@ -2620,8 +2453,8 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         return ret;
     }
-    async GetAuditLogTypeMetadata() {
-        const alts = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwAuditLogTypes`, null);
+    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 core_1.AuditLogTypeInfo(alts[i]);
@@ -2629,9 +2462,9 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         return ret;
     }
-    async GetUserMetadata() {
-        const users = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwUsers`, null);
-        const userRoles = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwUserRoles ORDER BY UserID`);
+    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 core_1.UserInfo(this, {
@@ -2641,9 +2474,9 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         return ret;
     }
-    async GetAuthorizationMetadata() {
-        const auths = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwAuthorizations`, null);
-        const authRoles = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwAuthorizationRoles ORDER BY AuthorizationName`);
+    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 core_1.AuthorizationInfo(this, {
@@ -2653,56 +2486,6 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         return ret;
     }
-    async GetCurrentUser() {
-        if (this.CurrentUser)
-            return this.CurrentUser;
-        else if (this._currentUserEmail && this._currentUserEmail.length > 0) {
-            // attempt to lookup current user from email since this.CurrentUser is null for some reason (unexpected)
-            if (UserCache_1.UserCache && UserCache_1.UserCache.Users)
-                return UserCache_1.UserCache.Users.find((u) => u.Email.trim().toLowerCase() === this._currentUserEmail.trim().toLowerCase());
-        }
-        // if we get here we can't get the current user
-        return null;
-    }
-    async GetCurrentUserMetadata() {
-        const user = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwUsers WHERE Email='${this._currentUserEmail}'`);
-        if (user && user.length === 1) {
-            const userRoles = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwUserRoles WHERE UserID='${user[0].ID}'`);
-            return new core_1.UserInfo(this, {
-                ...user[0],
-                UserRoles: userRoles ? userRoles : [],
-            });
-        }
-        else
-            return null;
-    }
-    async GetRoleMetadata() {
-        const roles = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwRoles`, null);
-        const ret = [];
-        for (let i = 0; i < roles.length; i++) {
-            const ri = new core_1.RoleInfo(roles[i]);
-            ret.push(ri);
-        }
-        return ret;
-    }
-    async GetUserRoleMetadata() {
-        const userRoles = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwUserRoles`, null);
-        const ret = [];
-        for (let i = 0; i < userRoles.length; i++) {
-            const uri = new core_1.UserRoleInfo(userRoles[i]);
-            ret.push(uri);
-        }
-        return ret;
-    }
-    async GetRowLevelSecurityFilterMetadata() {
-        const filters = await this.ExecuteSQL(`SELECT * FROM [${this.MJCoreSchemaName}].vwRowLevelSecurityFilters`, null);
-        const ret = [];
-        for (let i = 0; i < filters.length; i++) {
-            const rlsfi = new core_1.RowLevelSecurityFilterInfo(filters[i]);
-            ret.push(rlsfi);
-        }
-        return ret;
-    }
     /**
      * Processes entity rows returned from SQL Server to handle timezone conversions for datetime fields.
      * This method specifically handles the conversion of datetime2 fields (which SQL Server returns without timezone info)
@@ -2788,38 +2571,72 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         });
     }
     /**
-     * This method can be used to execute raw SQL statements outside of the MJ infrastructure.
-     * *CAUTION* - use this method with great care.
-     * @param query
-     * @param parameters
-     * @returns
+     * Static method for executing SQL with proper handling of connections and logging.
+     * This is the single point where all SQL execution happens in the entire class.
+     *
+     * @param query - SQL query to execute
+     * @param parameters - Query parameters
+     * @param context - Execution context containing pool, transaction, and logging functions
+     * @param options - Options for SQL execution
+     * @returns Promise<sql.IResult<any>> - Query result
+     * @private
      */
-    async ExecuteSQL(query, parameters = null, options) {
+    static async _internalExecuteSQLStatic(query, parameters, context, options) {
+        // Determine which connection source to use
+        let connectionSource;
+        if (context.transaction) {
+            // Try to use the transaction if provided
+            try {
+                // Test if the transaction is still valid by creating a request
+                const testRequest = new sql.Request(context.transaction);
+                connectionSource = context.transaction;
+            }
+            catch (error) {
+                // Transaction is no longer valid, clear it and use the pool
+                if (context.clearTransaction) {
+                    context.clearTransaction();
+                }
+                connectionSource = context.pool;
+            }
+        }
+        else {
+            connectionSource = context.pool;
+        }
+        // Check if the pool is connected before attempting to execute
+        if (connectionSource === context.pool && !context.pool.connected) {
+            const errorMessage = 'Connection pool is closed. Cannot execute SQL query.';
+            const error = new Error(errorMessage);
+            error.code = 'POOL_CLOSED';
+            throw error;
+        }
+        // Handle logging
+        let logPromise;
+        if (options && !options.ignoreLogging && context.logSqlStatement) {
+            logPromise = context.logSqlStatement(query, parameters, options.description, options.ignoreLogging, options.isMutation, options.simpleSQLFallback, options.contextUser);
+        }
+        else {
+            logPromise = Promise.resolve();
+        }
         try {
+            // Create a new request object for this query
             let request;
-            if (this._transaction && this._transactionRequest) {
-                // Use transaction request if in a transaction
-                request = this._transactionRequest;
-            }
-            else if (this._transaction) {
-                // Create a new request for this transaction if we don't have one
-                request = new sql.Request(this._transaction);
+            if (connectionSource instanceof sql.Transaction) {
+                request = new sql.Request(connectionSource);
             }
             else {
-                // Use pool request for non-transactional queries
-                request = new sql.Request(this._pool);
+                request = new sql.Request(connectionSource);
             }
             // Add parameters if provided
+            let processedQuery = query;
             if (parameters) {
                 if (Array.isArray(parameters)) {
                     // Handle positional parameters (legacy TypeORM style)
-                    // Convert to named parameters for mssql
                     parameters.forEach((value, index) => {
                         request.input(`p${index}`, value);
                     });
                     // Replace ? with @p0, @p1, etc. in the query
                     let paramIndex = 0;
-                    query = query.replace(/\?/g, () => `@p${paramIndex++}`);
+                    processedQuery = query.replace(/\?/g, () => `@p${paramIndex++}`);
                 }
                 else if (typeof parameters === 'object') {
                     // Handle named parameters
@@ -2828,16 +2645,111 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     }
                 }
             }
-            // Log SQL statement to all active logging sessions (runs in parallel with execution)
-            const loggingPromise = this._logSqlStatement(query, parameters, options?.description, options?.ignoreLogging, options?.isMutation, options?.simpleSQLFallback);
-            // Execute SQL and logging in parallel, but wait for both to complete
-            const [result] = await Promise.all([request.query(query), loggingPromise]);
+            // Execute query and logging in parallel
+            const [result] = await Promise.all([
+                request.query(processedQuery),
+                logPromise
+            ]);
+            return result;
+        }
+        catch (error) {
+            // If we get an EREQINPROG error and we were using a transaction, retry with the pool
+            if (error?.code === 'EREQINPROG' && connectionSource === context.transaction) {
+                // Silently retry with pool connection - this is expected behavior during concurrent operations
+                // LogDebug('Transaction connection busy (EREQINPROG) - retrying with pool connection');
+                // Clear the transaction reference
+                if (context.clearTransaction) {
+                    context.clearTransaction();
+                }
+                // Retry using the pool connection
+                return SQLServerDataProvider._internalExecuteSQLStatic(query, parameters, {
+                    ...context,
+                    transaction: null // Force use of pool
+                }, options ? {
+                    ...options,
+                    description: options.description + ' (retry with pool)'
+                } : undefined);
+            }
+            // Log other errors
+            (0, core_1.LogError)(error);
+            // Re-throw all errors
+            throw error;
+        }
+    }
+    /**
+     * Internal centralized method for executing SQL queries with consistent transaction and connection handling.
+     * This method ensures proper request object creation and management to avoid concurrency issues,
+     * particularly when using transactions where multiple operations may execute in parallel.
+     *
+     * @private
+     * @param query - The SQL query to execute
+     * @param parameters - Optional parameters for the query (array for positional, object for named)
+     * @param connectionSource - Optional specific connection source (pool, transaction, or request)
+     * @param loggingOptions - Optional logging configuration
+     * @returns Promise<sql.IResult<any>> - The raw mssql result object
+     *
+     * @remarks
+     * - Always creates a new Request object for each query to avoid "EREQINPROG" errors
+     * - Handles both positional (?) and named (@param) parameter styles
+     * - Automatically uses active transaction if one exists, otherwise uses connection pool
+     * - Handles SQL logging in parallel with query execution
+     * - Provides automatic retry with pool connection if transaction fails
+     *
+     * @throws {Error} Rethrows any SQL execution errors after logging
+     */
+    async _internalExecuteSQL(query, parameters, connectionSource, loggingOptions) {
+        // Handle the connectionSource parameter for backwards compatibility
+        // If a specific source is provided, we'll pass it as the transaction (if it's a transaction)
+        // or ignore it if it's a pool/request (since we'll use our own pool)
+        let transaction = null;
+        if (connectionSource instanceof sql.Transaction) {
+            transaction = connectionSource;
+        }
+        else if (!connectionSource) {
+            // Use our transaction if available
+            transaction = this._transaction;
+        }
+        // Create the execution context
+        const context = {
+            pool: this._pool,
+            transaction: transaction,
+            logSqlStatement: this._logSqlStatement.bind(this),
+            clearTransaction: () => { this._transaction = null; }
+        };
+        // Convert logging options to internal format
+        const options = loggingOptions ? {
+            description: loggingOptions.description,
+            ignoreLogging: loggingOptions.ignoreLogging,
+            isMutation: loggingOptions.isMutation,
+            simpleSQLFallback: loggingOptions.simpleSQLFallback,
+            contextUser: loggingOptions.contextUser
+        } : undefined;
+        // Delegate to static method
+        return SQLServerDataProvider._internalExecuteSQLStatic(query, parameters, context, options);
+    }
+    /**
+     * This method can be used to execute raw SQL statements outside of the MJ infrastructure.
+     * *CAUTION* - use this method with great care.
+     * @param query
+     * @param parameters
+     * @returns
+     */
+    async ExecuteSQL(query, parameters = null, options, contextUser) {
+        try {
+            // Use internal method with logging options
+            const result = await this._internalExecuteSQL(query, parameters, undefined, {
+                description: options?.description,
+                ignoreLogging: options?.ignoreLogging,
+                isMutation: options?.isMutation,
+                simpleSQLFallback: options?.simpleSQLFallback,
+                contextUser: contextUser
+            });
             // Return recordset for consistency with TypeORM behavior
             // If multiple recordsets, return recordsets array
             return result.recordsets && Array.isArray(result.recordsets) && result.recordsets.length > 1 ? result.recordsets : result.recordset;
         }
         catch (e) {
-            (0, core_1.LogError)(e);
+            // Error already logged by _internalExecuteSQL
             throw e; // force caller to handle
         }
     }
@@ -2852,33 +2764,31 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @param parameters - Optional parameters for the query
      * @returns Promise<any[]> - Array of results (empty array if no results)
      */
-    static async ExecuteSQLWithPool(pool, query, parameters) {
+    static async ExecuteSQLWithPool(pool, query, parameters, contextUser) {
         try {
-            const request = new sql.Request(pool);
-            // Add parameters if provided
-            if (parameters) {
-                if (Array.isArray(parameters)) {
-                    // Handle positional parameters
-                    parameters.forEach((value, index) => {
-                        request.input(`p${index}`, value);
-                    });
-                    // Replace ? with @p0, @p1, etc. in the query
-                    let paramIndex = 0;
-                    query = query.replace(/\?/g, () => `@p${paramIndex++}`);
+            // Create the execution context for static method
+            const context = {
+                pool: pool,
+                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);
                 }
-                else if (typeof parameters === 'object') {
-                    // Handle named parameters
-                    for (const [key, value] of Object.entries(parameters)) {
-                        request.input(key, value);
-                    }
-                }
-            }
-            const result = await request.query(query);
+            };
+            // Create options
+            const options = {
+                description: 'ExecuteSQLWithPool',
+                ignoreLogging: false,
+                isMutation: false,
+                contextUser: contextUser
+            };
+            // Use the static execution method
+            const result = await SQLServerDataProvider._internalExecuteSQLStatic(query, parameters, context, options);
             // Always return array for consistency
             return result.recordset || [];
         }
         catch (e) {
-            (0, core_1.LogError)(e);
+            // Error already logged by _internalExecuteSQLStatic
             throw e;
         }
     }
@@ -2893,54 +2803,68 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @param parameters - Optional array of parameter arrays, one for each query
      * @returns Promise<any[][]> - Array of result arrays, one for each query
      */
-    static async ExecuteSQLBatchStatic(connectionSource, queries, parameters) {
+    static async ExecuteSQLBatchStatic(connectionSource, queries, parameters, contextUser) {
         try {
-            let request;
-            // Determine the request to use based on connection source type
-            if (connectionSource instanceof sql.Request) {
-                request = connectionSource;
-            }
-            else if (connectionSource instanceof sql.Transaction) {
-                request = new sql.Request(connectionSource);
-            }
-            else {
-                // Assume it's a ConnectionPool
-                request = new sql.Request(connectionSource);
-            }
-            // Build combined batch SQL
+            // Build combined batch SQL and parameters
             let batchSQL = '';
-            let paramIndex = 0;
+            const batchParameters = {};
+            let globalParamIndex = 0;
             queries.forEach((query, queryIndex) => {
+                let processedQuery = query;
                 // Add parameters for this query if provided
                 if (parameters && parameters[queryIndex]) {
                     const queryParams = parameters[queryIndex];
                     if (Array.isArray(queryParams)) {
                         // Handle positional parameters
-                        queryParams.forEach((value) => {
-                            request.input(`p${paramIndex}`, value);
-                            paramIndex++;
+                        queryParams.forEach((value, localIndex) => {
+                            const paramName = `p${globalParamIndex}`;
+                            batchParameters[paramName] = value;
+                            globalParamIndex++;
                         });
-                        // Replace @p0, @p1, etc. with actual parameter names
-                        let localParamIndex = paramIndex - queryParams.length;
-                        query = query.replace(/@p(\d+)/g, () => `@p${localParamIndex++}`);
+                        // Replace ? placeholders with parameter names
+                        let localParamIndex = globalParamIndex - queryParams.length;
+                        processedQuery = processedQuery.replace(/\?/g, () => `@p${localParamIndex++}`);
                     }
                     else if (typeof queryParams === 'object') {
                         // Handle named parameters - prefix with query index to avoid conflicts
                         for (const [key, value] of Object.entries(queryParams)) {
                             const paramName = `q${queryIndex}_${key}`;
-                            request.input(paramName, value);
+                            batchParameters[paramName] = value;
                             // Replace parameter references in query
-                            query = query.replace(new RegExp(`@${key}\\b`, 'g'), `@${paramName}`);
+                            processedQuery = processedQuery.replace(new RegExp(`@${key}\\b`, 'g'), `@${paramName}`);
                         }
                     }
                 }
-                batchSQL += query;
+                batchSQL += processedQuery;
                 if (queryIndex < queries.length - 1) {
                     batchSQL += ';\n';
                 }
             });
-            // Execute the batch SQL
-            const result = await request.query(batchSQL);
+            // Execute the batch SQL directly (static method can't use instance _internalExecuteSQL)
+            let request;
+            if (connectionSource instanceof sql.Request) {
+                request = connectionSource;
+            }
+            else if (connectionSource instanceof sql.Transaction) {
+                request = new sql.Request(connectionSource);
+            }
+            else if (connectionSource instanceof sql.ConnectionPool) {
+                request = new sql.Request(connectionSource);
+            }
+            else {
+                throw new Error('Invalid connection source type');
+            }
+            // Add all batch parameters to the request
+            for (const [key, value] of Object.entries(batchParameters)) {
+                request.input(key, value);
+            }
+            // Log the batch SQL
+            const logPromise = SQLServerDataProvider.LogSQLStatement(batchSQL, batchParameters, 'Batch execution', false, undefined, contextUser);
+            // Execute batch SQL and logging in parallel
+            const [result] = await Promise.all([
+                request.query(batchSQL),
+                logPromise
+            ]);
             // Return array of recordsets - one for each query
             // Handle both single and multiple recordsets
             if (result.recordsets && Array.isArray(result.recordsets)) {
@@ -2954,7 +2878,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             }
         }
         catch (e) {
-            (0, core_1.LogError)(e);
+            // Error already logged by _internalExecuteSQLStatic
             throw e;
         }
     }
@@ -2969,28 +2893,19 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @param options - Optional execution options for logging and description
      * @returns Promise<any[][]> - Array of result arrays, one for each query
      */
-    async ExecuteSQLBatch(queries, parameters, options) {
+    async ExecuteSQLBatch(queries, parameters, options, contextUser) {
         try {
             let connectionSource;
-            if (this._transaction && this._transactionRequest) {
-                // Use transaction request if in a transaction
-                connectionSource = this._transactionRequest;
-            }
-            else if (this._transaction) {
+            if (this._transaction) {
                 // Use transaction if we have one
                 connectionSource = this._transaction;
             }
             else {
-                // Use pool request for non-transactional queries
+                // Use pool for non-transactional queries
                 connectionSource = this._pool;
             }
-            // Log batch SQL statement to all active logging sessions
-            const description = options?.description ? `${options.description} (Batch: ${queries.length} queries)` : `Batch execution: ${queries.length} queries`;
-            const batchSQL = queries.join(';\n');
-            const loggingPromise = this._logSqlStatement(batchSQL, parameters, description, options?.ignoreLogging, options?.isMutation);
-            // Execute SQL and logging in parallel, but wait for both to complete
-            const [result] = await Promise.all([SQLServerDataProvider.ExecuteSQLBatchStatic(connectionSource, queries, parameters), loggingPromise]);
-            return result;
+            // ExecuteSQLBatchStatic handles its own logging, so we don't need to duplicate it here
+            return await SQLServerDataProvider.ExecuteSQLBatchStatic(connectionSource, queries, parameters, contextUser);
         }
         catch (e) {
             (0, core_1.LogError)(e);
@@ -3083,8 +2998,10 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             // Create a new transaction from the pool
             this._transaction = new sql.Transaction(this._pool);
             await this._transaction.begin();
-            // Create a request for this transaction that can be reused
-            this._transactionRequest = new sql.Request(this._transaction);
+            // Transaction created successfully
+            // Note: We create new Request objects for each query to avoid concurrency issues
+            // Emit transaction state change
+            this._transactionState$.next(true);
         }
         catch (e) {
             (0, core_1.LogError)(e);
@@ -3096,7 +3013,10 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             if (this._transaction) {
                 await this._transaction.commit();
                 this._transaction = null;
-                this._transactionRequest = null;
+                // Emit transaction state change
+                this._transactionState$.next(false);
+                // Process any deferred tasks after successful commit
+                await this.processDeferredTasks();
             }
         }
         catch (e) {
@@ -3109,7 +3029,14 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             if (this._transaction) {
                 await this._transaction.rollback();
                 this._transaction = null;
-                this._transactionRequest = null;
+                // Emit transaction state change
+                this._transactionState$.next(false);
+                // Clear deferred tasks after rollback (don't process them)
+                const deferredCount = this._deferredTasks.length;
+                this._deferredTasks = [];
+                if (deferredCount > 0) {
+                    (0, core_1.LogStatus)(`Cleared ${deferredCount} deferred tasks after transaction rollback`);
+                }
             }
         }
         catch (e) {
@@ -3117,14 +3044,56 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             throw e; // force caller to handle
         }
     }
+    /**
+     * Override RefreshIfNeeded to skip refresh when a transaction is active
+     * This prevents conflicts between metadata refresh operations and active transactions
+     * @returns Promise<boolean> - true if refresh was performed, false if skipped or no refresh needed
+     */
+    async RefreshIfNeeded() {
+        // Skip refresh if a transaction is active
+        if (this.isTransactionActive) {
+            (0, core_1.LogStatus)('Skipping metadata refresh - transaction is active');
+            return false;
+        }
+        // Call parent implementation if no transaction
+        return super.RefreshIfNeeded();
+    }
+    /**
+     * Process any deferred tasks that were queued during a transaction
+     * This is called after a successful transaction commit
+     * @private
+     */
+    async processDeferredTasks() {
+        if (this._deferredTasks.length === 0)
+            return;
+        (0, core_1.LogStatus)(`Processing ${this._deferredTasks.length} deferred tasks after transaction commit`);
+        // Copy and clear the deferred tasks array
+        const tasksToProcess = [...this._deferredTasks];
+        this._deferredTasks = [];
+        // Process each deferred task
+        for (const task of tasksToProcess) {
+            try {
+                if (task.type === 'Entity AI Action') {
+                    // Process the AI action now that we're outside the transaction
+                    await queue_1.QueueManager.AddTask('Entity AI Action', task.data, task.options, task.user);
+                }
+                // Add other task types here as needed
+            }
+            catch (error) {
+                (0, core_1.LogError)(`Failed to process deferred ${task.type} task: ${error}`);
+                // Continue processing other tasks even if one fails
+            }
+        }
+        (0, core_1.LogStatus)(`Completed processing deferred tasks`);
+    }
     get LocalStorageProvider() {
         if (!this._localStorageProvider)
             this._localStorageProvider = new NodeLocalStorageProvider();
         return this._localStorageProvider;
     }
-    async GetEntityRecordNames(info) {
+    async GetEntityRecordNames(info, contextUser) {
         const promises = info.map(async (item) => {
-            const r = await this.GetEntityRecordName(item.EntityName, item.CompositeKey);
+            const r = await this.GetEntityRecordName(item.EntityName, item.CompositeKey, contextUser);
             return {
                 EntityName: item.EntityName,
                 CompositeKey: item.CompositeKey,
@@ -3135,11 +3104,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         });
         return Promise.all(promises);
     }
-    async GetEntityRecordName(entityName, CompositeKey) {
+    async GetEntityRecordName(entityName, CompositeKey, contextUser) {
         try {
             const sql = this.GetEntityRecordNameSQL(entityName, CompositeKey);
             if (sql) {
-                const data = await this.ExecuteSQL(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
@@ -3198,7 +3167,7 @@ class NodeLocalStorageProvider {
     constructor() {
         this._localStorage = {};
     }
-    async getItem(key) {
+    async GetItem(key) {
         return new Promise((resolve) => {
             if (this._localStorage.hasOwnProperty(key))
                 resolve(this._localStorage[key]);
@@ -3206,13 +3175,13 @@ class NodeLocalStorageProvider {
                 resolve(null);
         });
     }
-    async setItem(key, value) {
+    async SetItem(key, value) {
         return new Promise((resolve) => {
             this._localStorage[key] = value;
             resolve();
         });
     }
-    async remove(key) {
+    async Remove(key) {
         return new Promise((resolve) => {
             if (this._localStorage.hasOwnProperty(key))
                 delete this._localStorage[key];