@memberjunction/sqlserver-dataprovider 2.48.0 → 2.50.0

package/dist/SQLServerDataProvider.js

@@ -1,25 +1,77 @@
 "use strict";
+/**
+ * @fileoverview SQL Server Data Provider for MemberJunction
+ *
+ * This module provides a comprehensive SQL Server implementation of the MemberJunction data provider interfaces.
+ * It handles all database operations including CRUD operations, metadata management, view execution, and
+ * advanced features like SQL logging, transaction management, and record change tracking.
+ *
+ * @module @memberjunction/sqlserver-dataprovider
+ * @author MemberJunction Team
+ * @version 2.0
+ * @since 1.0
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLServerDataProvider = exports.SQLServerProviderConfigData = 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
  * so it is only included by the consumer of the entities library if they want to use it.
  **************************************************************************************************************/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQLServerDataProvider = exports.SQLServerProviderConfigData = void 0;
 const core_1 = require("@memberjunction/core");
 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 SQLServerTransactionGroup_1 = require("./SQLServerTransactionGroup");
 const UserCache_1 = require("./UserCache");
 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;
     }
@@ -32,20 +84,255 @@ class SQLServerProviderConfigData extends core_1.ProviderConfigDataBase {
     }
 }
 exports.SQLServerProviderConfigData = SQLServerProviderConfigData;
-// Implements both the IEntityDataProvider and IMetadataProvider interfaces.
+/**
+ * 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.
+ *
+ * This class provides comprehensive database functionality including:
+ * - CRUD operations for entities
+ * - Metadata management and caching
+ * - View and query execution
+ * - Transaction support
+ * - SQL logging capabilities
+ * - Record change tracking
+ * - AI integration hooks
+ *
+ * @example
+ * ```typescript
+ * const config = new SQLServerProviderConfigData(dataSource, userEmail);
+ * const provider = new SQLServerDataProvider(config);
+ * await provider.Config();
+ * ```
+ */
 class SQLServerDataProvider extends core_1.ProviderBase {
     constructor() {
         super(...arguments);
         this._bAllowRefresh = true;
         this._needsDatetimeOffsetAdjustment = false;
         this._datetimeOffsetTestComplete = false;
+        this._sqlLoggingSessions = new Map();
     }
+    /**
+     * Gets the current configuration data for this provider instance
+     */
     get ConfigData() {
         return super.ConfigData;
     }
+    /**
+     * Configures the SQL Server data provider with connection settings and initializes the connection pool
+     *
+     * @param configData - Configuration data including connection string and options
+     * @returns Promise<boolean> - True if configuration succeeded
+     */
     async Config(configData) {
         try {
-            this._dataSource = configData.DataSource;
+            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
         }
@@ -55,34 +342,157 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
     }
     /**
-     * SQL Server Data Provider implementation of this getter returns a TypeORM DataSource object
+     * Gets the underlying SQL Server connection pool
+     * @returns The mssql ConnectionPool object
      */
     get DatabaseConnection() {
-        return this._dataSource;
+        return this._pool;
     }
     /**
      * For the SQLServerDataProvider the unique instance connection string which is used to identify, uniquely, a given connection is the following format:
-     * type://host:port/instanceName?/database
+     * mssql://host:port/instanceName?/database
      * instanceName is only inserted if it is provided in the options
      */
     get InstanceConnectionString() {
-        const dbOptions = this._dataSource.options;
+        // For mssql, we need to access the pool's internal connection options
+        // Since mssql v11 doesn't expose config directly, we'll construct from what we know
+        const pool = this._pool;
         const options = {
-            type: dbOptions.type || '',
-            host: dbOptions.host || '',
-            port: dbOptions.port || '',
-            instanceName: dbOptions.instanceName ? '/' + dbOptions.instanceName : '',
-            database: dbOptions.database || '',
+            type: 'mssql',
+            host: pool._config?.server || 'localhost',
+            port: pool._config?.port || 1433,
+            instanceName: pool._config?.options?.instanceName ? '/' + pool._config.options.instanceName : '',
+            database: pool._config?.database || '',
         };
         return options.type + '://' + options.host + ':' + options.port + options.instanceName + '/' + options.database;
     }
+    /**
+     * Gets whether metadata refresh is currently allowed
+     * @internal
+     */
     get AllowRefresh() {
         return this._bAllowRefresh;
     }
+    /**
+     * Gets the MemberJunction core schema name (defaults to __mj if not configured)
+     */
     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 = (0, uuid_1.v4)();
+        const session = new SqlLoggingSessionImpl(sessionId, filePath, options);
+        // 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);
+            },
+        };
+    }
+    /**
+     * 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,
+        }));
+    }
+    /**
+     * 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();
+    }
+    /**
+     * 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) {
+        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));
+        await Promise.all(logPromises);
+    }
+    /**
+     * 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) {
+        // 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);
+        }
+    }
+    /**************************************************************************/
+    // END ---- SQL Logging Methods
+    /**************************************************************************/
+    /**************************************************************************/
     // START ---- IRunReportProvider
     /**************************************************************************/
     async RunReport(params, contextUser) {
@@ -98,7 +508,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             if (result)
                 return {
                     Success: true,
-                    ReportID: ReportID,
+                    ReportID,
                     Results: result,
                     RowCount: result.length,
                     ExecutionTime: end - start,
@@ -107,7 +517,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             else
                 return {
                     Success: false,
-                    ReportID: ReportID,
+                    ReportID,
                     Results: [],
                     RowCount: 0,
                     ExecutionTime: end - start,
@@ -115,7 +525,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 };
         }
         else
-            return { Success: false, ReportID: ReportID, Results: [], RowCount: 0, ExecutionTime: 0, ErrorMessage: 'Report not found' };
+            return { Success: false, ReportID, Results: [], RowCount: 0, ExecutionTime: 0, ErrorMessage: 'Report not found' };
     }
     /**************************************************************************/
     // END ---- IRunReportProvider
@@ -167,7 +577,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 Results: [],
                 RowCount: 0,
                 ExecutionTime: 0,
-                ErrorMessage: e.message
+                ErrorMessage: e.message,
             };
         }
     }
@@ -393,22 +803,20 @@ 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._dataSource.query(viewSQL);
+                const retData = params.ResultType === 'count_only' ? [] : await this.ExecuteSQL(viewSQL);
                 // 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._dataSource.query(countSQL);
+                    const countResult = await this.ExecuteSQL(countSQL);
                     if (countResult && countResult.length > 0) {
                         rowCount = countResult[0].TotalRowCount;
                     }
                 }
                 const stopTime = new Date();
                 if (params.ForceAuditLog ||
-                    (viewEntity?.ID &&
-                        (extraFilter === undefined || extraFilter === null || extraFilter?.trim().length === 0) &&
-                        entityInfo.AuditViewRuns)) {
+                    (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,
@@ -450,7 +858,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
     }
     async RunViews(params, contextUser) {
-        const promises = params.map(p => this.RunView(p, contextUser));
+        const promises = params.map((p) => this.RunView(p, contextUser));
         return Promise.all(promises);
     }
     validateUserProvidedSQLClause(clause) {
@@ -559,12 +967,12 @@ 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._dataSource.query(sSQL);
+        const runIDResult = await this.ExecuteSQL(sSQL);
         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: runID };
+        return { executeViewSQL: sRetSQL, runID };
     }
     createViewUserSearchSQL(entityInfo, userSearchString) {
         // we have a user search string.
@@ -629,9 +1037,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             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;
+            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)
@@ -840,7 +1246,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 // 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
                 // })
-                let compositeKey = new core_1.CompositeKey();
+                const compositeKey = new core_1.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 = {};
@@ -889,11 +1295,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         const listEntity = await this.GetEntityObject('Lists');
         listEntity.ContextCurrentUser = contextUser;
-        let success = await listEntity.Load(params.ListID);
+        const success = await listEntity.Load(params.ListID);
         if (!success) {
             throw new Error(`List with ID ${params.ListID} not found.`);
         }
-        let duplicateRun = await this.GetEntityObject('Duplicate Runs');
+        const duplicateRun = await this.GetEntityObject('Duplicate Runs');
         duplicateRun.NewRecord();
         duplicateRun.EntityID = params.EntityID;
         duplicateRun.StartedByUserID = contextUser.ID;
@@ -906,7 +1312,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         if (!saveResult) {
             throw new Error(`Failed to save Duplicate Run Entity`);
         }
-        let response = {
+        const response = {
             Status: 'Inprogress',
             PotentialDuplicateResult: [],
         };
@@ -1043,7 +1449,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             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('Record Merge Deletion Logs', contextUser));
+                    const recordMergeDeletionLog = await this.GetEntityObject('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
@@ -1067,6 +1473,14 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * it is also used by the SQLServerTransactionGroup to regenerate Save SQL if any values were changed by the transaction group due to transaction variables being set into the object.
      */
     GetSaveSQL(entity, bNewRecord, spName, user) {
+        const result = this.GetSaveSQLWithDetails(entity, bNewRecord, spName, user);
+        return result.fullSQL;
+    }
+    /**
+     * This function generates both the full SQL (with record change metadata) and the simple stored procedure call
+     * @returns Object with fullSQL and simpleSQL properties
+     */
+    GetSaveSQLWithDetails(entity, bNewRecord, spName, user) {
         const sSimpleSQL = `EXEC [${entity.EntityInfo.SchemaName}].${spName} ${this.generateSPParams(entity, !bNewRecord)}`;
         const recordChangesEntityInfo = this.Entities.find((e) => e.Name === 'Record Changes');
         let sSQL = '';
@@ -1081,34 +1495,54 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             sSQL = `
                     DECLARE @ResultTable TABLE (
                         ${this.getAllEntityColumnsSQL(entity.EntityInfo)}
-                    )
+                    );
 
                     INSERT INTO @ResultTable
-                    ${sSimpleSQL}
+                    ${sSimpleSQL};
 
-                    DECLARE @ID NVARCHAR(MAX)
-                    SELECT @ID = ${concatPKIDString} FROM @ResultTable
+                    DECLARE @ID NVARCHAR(MAX);
+                    
+                    SELECT @ID = ${concatPKIDString} FROM @ResultTable;
+                    
                     IF @ID IS NOT NULL
                     BEGIN
                         DECLARE @ResultChangesTable TABLE (
                             ${this.getAllEntityColumnsSQL(recordChangesEntityInfo)}
-                        )
+                        );
 
                         INSERT INTO @ResultChangesTable
-                        ${this.GetLogRecordChangeSQL(entity.GetAll(false), oldData, entity.EntityInfo.Name, '@ID', entity.EntityInfo, bNewRecord ? 'Create' : 'Update', user, false)}
-                    END
+                        ${this.GetLogRecordChangeSQL(entity.GetAll(false), oldData, entity.EntityInfo.Name, '@ID', entity.EntityInfo, bNewRecord ? 'Create' : 'Update', user, false)};
+                    END;
 
-                    SELECT * FROM @ResultTable`; // NOTE - in the above, we call the T-SQL variable @ID for simplicity just as a variable name, even though for each entity the pkey could be something else. Entity pkeys are not always a field called ID could be something else including composite keys.
+                    SELECT * FROM @ResultTable;`; // NOTE - in the above, we call the T-SQL variable @ID for simplicity just as a variable name, even though for each entity the pkey could be something else. Entity pkeys are not always a field called ID could be something else including composite keys.
         }
         else {
             // not doing track changes for this entity, keep it simple
             sSQL = sSimpleSQL;
         }
-        return sSQL;
+        return { fullSQL: sSQL, simpleSQL: sSimpleSQL };
     }
+    /**
+     * 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_1.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
+     */
     async HandleEntityActions(entity, baseType, before, user) {
         // use the EntityActionEngine for this
         try {
@@ -1247,14 +1681,19 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                         // but they are supported (for now)
                         await this.HandleEntityAIActions(entity, 'save', true, user);
                     }
-                    const sSQL = this.GetSaveSQL(entity, bNewRecord, spName, user);
+                    const sqlDetails = 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 core_1.TransactionItem(entity, entityResult.Type === 'create' ? 'Create' : 'Update', sSQL, null, { dataSource: this._dataSource }, (transactionResult, success) => {
+                        entity.TransactionGroup.AddTransaction(new core_1.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
@@ -1290,7 +1729,12 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                             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 {
-                            const rawResult = await this.ExecuteSQL(sSQL);
+                            // Execute SQL with optional simple SQL fallback for loggers
+                            const rawResult = await this.ExecuteSQL(sSQL, null, {
+                                isMutation: true,
+                                description: `Save ${entity.EntityInfo.Name}`,
+                                simpleSQLFallback: entity.EntityInfo.TrackRecordChanges ? sqlDetails.simpleSQL : undefined
+                            });
                             result = await this.ProcessEntityRows(rawResult, entity.EntityInfo);
                         }
                         this._bAllowRefresh = true; // allow refreshes now
@@ -1324,10 +1768,10 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
     }
     MapTransactionResultToNewValues(transactionResult) {
-        return Object.keys(transactionResult).map(k => {
+        return Object.keys(transactionResult).map((k) => {
             return {
                 FieldName: k,
-                Value: transactionResult[k]
+                Value: transactionResult[k],
             };
         }); // transform the result into a list of field/value pairs
     }
@@ -1362,22 +1806,26 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         let sRet = '', bFirst = true;
         for (let i = 0; i < entity.EntityInfo.Fields.length; i++) {
             const f = entity.EntityInfo.Fields[i];
-            if (f.AllowUpdateAPI) {
-                if (!f.SkipValidation) {
+            // For CREATE operations, include primary keys that are not auto-increment and have actual values
+            const includePrimaryKeyForCreate = !isUpdate && f.IsPrimaryKey && !f.AutoIncrement && entity.Get(f.Name) !== null && entity.Get(f.Name) !== undefined;
+            if (f.AllowUpdateAPI || includePrimaryKeyForCreate) {
+                if (!f.SkipValidation || includePrimaryKeyForCreate) {
                     // DO NOT INCLUDE any fields where we skip validation, these are fields that are not editable by the user/object
                     // model/api because they're special fields like ID, CreatedAt, etc. or they're virtual or auto-increment, etc.
+                    // EXCEPTION: Include primary keys for CREATE when they have values and are not auto-increment
                     let value = entity.Get(f.Name);
                     if (value && f.Type.trim().toLowerCase() === 'datetimeoffset') {
                         // for non-null datetimeoffset fields, we need to convert the value to ISO format
                         value = new Date(value).toISOString();
                     }
-                    else if (!isUpdate && f.Type.trim().toLowerCase() === 'uniqueidentifier') {
+                    else if (!isUpdate && f.Type.trim().toLowerCase() === 'uniqueidentifier' && !includePrimaryKeyForCreate) {
                         // in the case of unique identifiers, for CREATE procs only,
                         // we need to check to see if the value we have in the entity object is a function like newid() or newsquentialid()
                         // in those cases we should just skip the parameter entirely because that means there is a default value that should be used
                         // and that will be handled by the database not by us
                         // instead of just checking for specific functions like newid(), we can instead check for any string that includes ()
                         // this way we can handle any function that the database might support in the future
+                        // EXCEPTION: Don't skip if we're including a primary key for create
                         if (typeof value === 'string' && value.includes('()')) {
                             continue; // skip this field entirely by going to the next iteration of the loop
                         }
@@ -1390,7 +1838,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         }
         if (isUpdate && bFirst === false) {
             // this is an update and we have other fields, so we need to add all of the pkeys to the end of the SP call
-            for (let pkey of entity.PrimaryKey.KeyValuePairs) {
+            for (const pkey of entity.PrimaryKey.KeyValuePairs) {
                 const f = entity.EntityInfo.Fields.find((f) => f.Name.trim().toLowerCase() === pkey.FieldName.trim().toLowerCase());
                 const pkeyQuotes = f.NeedsQuotes ? "'" : '';
                 sRet += `, @${f.CodeName} = ` + pkeyQuotes + pkey.Value + pkeyQuotes; // add pkey to update SP at end, but only if other fields included
@@ -1490,7 +1938,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      */
     CreateUserDescriptionOfChanges(changesObject, maxValueLength = 200, cutOffText = '...') {
         let sRet = '';
-        let keys = Object.keys(changesObject);
+        const keys = Object.keys(changesObject);
         for (let i = 0; i < keys.length; i++) {
             const change = changesObject[keys[i]];
             if (sRet.length > 0) {
@@ -1592,6 +2040,15 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         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 === core_1.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];
@@ -1622,7 +2079,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                         const rawRelData = await this.ExecuteSQL(relSql);
                         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());
+                            const relEntityInfo = this.Entities.find((e) => e.Name.trim().toLowerCase() === relInfo.RelatedEntity.trim().toLowerCase());
                             if (relEntityInfo) {
                                 ret[rel] = await this.ProcessEntityRows(rawRelData, relEntityInfo);
                             }
@@ -1639,7 +2096,23 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         // if we get here, something didn't go right
         return null;
     }
+    /**
+     * Generates the SQL statement for deleting an entity record
+     *
+     * @param entity - The entity to delete
+     * @param user - The user performing the delete
+     * @returns The full SQL statement for deletion
+     * @internal
+     */
     GetDeleteSQL(entity, user) {
+        const result = this.GetDeleteSQLWithDetails(entity, user);
+        return result.fullSQL;
+    }
+    /**
+     * This function generates both the full SQL (with record change metadata) and the simple stored procedure call for delete
+     * @returns Object with fullSQL and simpleSQL properties
+     */
+    GetDeleteSQLWithDetails(entity, user) {
         let sSQL = '';
         const spName = entity.EntityInfo.spDelete ? entity.EntityInfo.spDelete : `spDelete${entity.EntityInfo.ClassName}`;
         const sParams = entity.PrimaryKey.KeyValuePairs.map((kv) => {
@@ -1698,7 +2171,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             // just delete the record
             sSQL = sSimpleSQL;
         }
-        return sSQL;
+        return { fullSQL: sSQL, simpleSQL: sSimpleSQL };
     }
     async Delete(entity, options, user) {
         const result = new core_1.BaseEntityResult();
@@ -1721,7 +2194,8 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             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 sSQL = this.GetDeleteSQL(entity, user);
+            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);
@@ -1732,7 +2206,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 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 core_1.TransactionItem(entity, 'Delete', sSQL, null, { dataSource: this._dataSource }, (transactionResult, success) => {
+                entity.TransactionGroup.AddTransaction(new core_1.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();
@@ -1745,7 +2223,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                             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 (let key of entity.PrimaryKeys) {
+                        for (const key of entity.PrimaryKeys) {
                             if (key.Value !== transactionResult[key.Name]) {
                                 result.Success = false;
                                 result.Message = 'Transaction failed to commit';
@@ -1769,11 +2247,16 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     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 {
-                    d = await this.ExecuteSQL(sSQL);
+                    // Execute SQL with optional simple SQL fallback for loggers
+                    d = await this.ExecuteSQL(sSQL, null, {
+                        isMutation: true,
+                        description: `Delete ${entity.EntityInfo.Name}`,
+                        simpleSQLFallback: entity.EntityInfo.TrackRecordChanges ? sqlDetails.simpleSQL : undefined
+                    });
                 }
                 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
-                    for (let key of entity.PrimaryKeys) {
+                    for (const key of entity.PrimaryKeys) {
                         if (key.Value !== d[0][key.Name]) {
                             return false;
                         }
@@ -1823,16 +2306,73 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     ON
                         di.EntityID = e.ID
                     WHERE
-                        d.Name = @0`;
+                        d.Name = @p0`;
         const items = await this.ExecuteSQL(sSQL, [datasetName]);
         // 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) {
-            // fire off all of the item queries in parallel
-            const promises = items.map((item) => {
-                return this.GetDatasetItem(item, itemFilters, datasetName); // no await as Promise.All used below
-            });
-            // execute all promises in parallel
-            const results = await Promise.all(promises);
+            // 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 = this.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 this.ExecuteSQLBatch(queries);
+            // 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
+                    const itemData = batchResults[queryIndex] || [];
+                    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
@@ -1844,8 +2384,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     }
                 }
                 return acc;
-            }, new Date(0) // Unix epoch - lowest possible date to start with
-            );
+            }, new Date(0));
             return {
                 DatasetID: items[0].DatasetID,
                 DatasetName: datasetName,
@@ -1866,18 +2405,32 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             };
         }
     }
-    async GetDatasetItem(item, itemFilters, datasetName) {
+    /**
+     * 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
+        }
+        return `SELECT ${columns} FROM [${item.EntitySchemaName}].[${item.EntityBaseView}] ${item.WhereClause ? 'WHERE ' + item.WhereClause : ''}${filterSQL}`;
+    }
+    async GetDatasetItem(item, itemFilters, datasetName) {
         const itemUpdatedAt = new Date(item.DatasetItemUpdatedAt);
         const datasetUpdatedAt = new Date(item.DatasetUpdatedAt);
         const datasetMaxUpdatedAt = new Date(Math.max(itemUpdatedAt.getTime(), datasetUpdatedAt.getTime()));
-        const columns = this.GetColumnsForDatasetItem(item, datasetName);
-        if (!columns) {
+        const itemSQL = this.GetDatasetItemSQL(item, itemFilters, datasetName);
+        if (!itemSQL) {
             // failure condition within columns, return a failed result
             return {
                 EntityID: item.EntityID,
@@ -1889,7 +2442,6 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                 Success: false,
             };
         }
-        const itemSQL = `SELECT ${columns} FROM [${item.EntitySchemaName}].[${item.EntityBaseView}] ${item.WhereClause ? 'WHERE ' + item.WhereClause : ''}${filterSQL}`;
         const itemData = await this.ExecuteSQL(itemSQL);
         // get the latest update date
         let latestUpdateDate = new Date(1900, 1, 1);
@@ -1978,7 +2530,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             ON
                 di.EntityID = e.ID
             WHERE
-                d.Name = @0`;
+                d.Name = @p0`;
         const items = await this.ExecuteSQL(sSQL, [datasetName]);
         // 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) {
@@ -2165,7 +2717,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             return rows;
         }
         // Find all datetime fields in the entity
-        const datetimeFields = entityInfo.Fields.filter(field => field.TSType === core_1.EntityFieldTSType.Date);
+        const datetimeFields = entityInfo.Fields.filter((field) => field.TSType === core_1.EntityFieldTSType.Date);
         // If there are no datetime fields, return the rows as-is
         if (datetimeFields.length === 0) {
             return rows;
@@ -2173,7 +2725,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         // Check if we need datetimeoffset adjustment (lazy loaded on first use)
         const needsAdjustment = await this.NeedsDatetimeOffsetAdjustment();
         // Process each row
-        return rows.map(row => {
+        return rows.map((row) => {
             const processedRow = { ...row };
             for (const field of datetimeFields) {
                 const fieldValue = processedRow[field.Name];
@@ -2194,9 +2746,9 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                         }
                     }
                     else if (fieldValue instanceof Date) {
-                        // TypeORM has already converted to a Date object using local timezone
+                        // 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 TypeORM interprets it as local
+                        // 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);
@@ -2211,7 +2763,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     }
                     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 
+                        // 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;
@@ -2242,25 +2794,212 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @param parameters
      * @returns
      */
-    async ExecuteSQL(query, parameters = null) {
+    async ExecuteSQL(query, parameters = null, options) {
         try {
-            if (this._queryRunner) {
-                const data = await this._queryRunner.query(query, parameters);
-                return data;
+            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);
             }
             else {
-                const data = await this._dataSource.query(query, parameters);
-                return data;
+                // Use pool request for non-transactional queries
+                request = new sql.Request(this._pool);
+            }
+            // Add parameters if provided
+            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++}`);
+                }
+                else if (typeof parameters === 'object') {
+                    // Handle named parameters
+                    for (const [key, value] of Object.entries(parameters)) {
+                        request.input(key, value);
+                    }
+                }
             }
+            // 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]);
+            // 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);
             throw e; // force caller to handle
         }
     }
+    /**
+     * Static helper method for executing SQL queries on an external connection pool.
+     * This method is designed to be used by generated code where a connection pool
+     * is passed in from the context. It returns results as arrays for consistency
+     * with the expected behavior in generated resolvers.
+     *
+     * @param pool - The mssql ConnectionPool to execute the query on
+     * @param query - The SQL query to execute
+     * @param parameters - Optional parameters for the query
+     * @returns Promise<any[]> - Array of results (empty array if no results)
+     */
+    static async ExecuteSQLWithPool(pool, query, parameters) {
+        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++}`);
+                }
+                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);
+            // Always return array for consistency
+            return result.recordset || [];
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            throw e;
+        }
+    }
+    /**
+     * Static method to execute a batch of SQL queries using a provided connection source.
+     * This allows the batch logic to be reused from external contexts like TransactionGroup.
+     * All queries are combined into a single SQL statement and executed together within
+     * the same connection/transaction context for optimal performance.
+     *
+     * @param connectionSource - Either a sql.ConnectionPool, sql.Transaction, or sql.Request to use for execution
+     * @param queries - Array of SQL queries to execute
+     * @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) {
+        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
+            let batchSQL = '';
+            let paramIndex = 0;
+            queries.forEach((query, queryIndex) => {
+                // 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++;
+                        });
+                        // Replace @p0, @p1, etc. with actual parameter names
+                        let localParamIndex = paramIndex - queryParams.length;
+                        query = query.replace(/@p(\d+)/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);
+                            // Replace parameter references in query
+                            query = query.replace(new RegExp(`@${key}\\b`, 'g'), `@${paramName}`);
+                        }
+                    }
+                }
+                batchSQL += query;
+                if (queryIndex < queries.length - 1) {
+                    batchSQL += ';\n';
+                }
+            });
+            // Execute the batch SQL
+            const result = await request.query(batchSQL);
+            // Return array of recordsets - one for each query
+            // Handle both single and multiple recordsets
+            if (result.recordsets && Array.isArray(result.recordsets)) {
+                return result.recordsets;
+            }
+            else if (result.recordset) {
+                return [result.recordset];
+            }
+            else {
+                return [];
+            }
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            throw e;
+        }
+    }
+    /**
+     * Executes multiple SQL queries in a single batch for optimal performance.
+     * All queries are combined into a single SQL statement and executed together.
+     * This is particularly useful for bulk operations where you need to execute
+     * many similar queries and want to minimize round trips to the database.
+     *
+     * @param queries - Array of SQL queries to execute
+     * @param parameters - Optional array of parameter arrays, one for each query
+     * @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) {
+        try {
+            let connectionSource;
+            if (this._transaction && this._transactionRequest) {
+                // Use transaction request if in a transaction
+                connectionSource = this._transactionRequest;
+            }
+            else if (this._transaction) {
+                // Use transaction if we have one
+                connectionSource = this._transaction;
+            }
+            else {
+                // Use pool request 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;
+        }
+        catch (e) {
+            (0, core_1.LogError)(e);
+            throw e;
+        }
+    }
     /**
      * Determines whether the database driver requires adjustment for datetimeoffset fields.
-     * This method performs an empirical test on first use to detect if the driver (e.g., TypeORM)
+     * This method performs an empirical test on first use to detect if the driver (e.g., mssql)
      * incorrectly handles timezone information in datetimeoffset columns.
      *
      * @returns {Promise<boolean>} True if datetimeoffset values need timezone adjustment, false otherwise
@@ -2306,7 +3045,7 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         -- Select and return the row
         SELECT TestDateTime FROM @TestTable;
       `;
-            const result = await this.ExecuteSQL(testQuery);
+            const result = await this.ExecuteSQL(testQuery, null, { description: 'DatetimeOffset handling test' });
             if (result && result.length > 0) {
                 const testDate = result[0].TestDateTime;
                 // Expected: January 1, 1900 at 11:00 AM UTC
@@ -2341,9 +3080,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     }
     async BeginTransaction() {
         try {
-            if (!this._queryRunner)
-                this._queryRunner = this._dataSource.createQueryRunner();
-            await this._queryRunner.startTransaction();
+            // 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);
         }
         catch (e) {
             (0, core_1.LogError)(e);
@@ -2352,7 +3093,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     }
     async CommitTransaction() {
         try {
-            await this._queryRunner.commitTransaction();
+            if (this._transaction) {
+                await this._transaction.commit();
+                this._transaction = null;
+                this._transactionRequest = null;
+            }
         }
         catch (e) {
             (0, core_1.LogError)(e);
@@ -2361,7 +3106,11 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     }
     async RollbackTransaction() {
         try {
-            await this._queryRunner.rollbackTransaction();
+            if (this._transaction) {
+                await this._transaction.rollback();
+                this._transaction = null;
+                this._transactionRequest = null;
+            }
         }
         catch (e) {
             (0, core_1.LogError)(e);
@@ -2420,9 +3169,9 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             }
             else {
                 // got our field, create a SQL Query
-                let sql = `SELECT [${f.Name}] FROM [${e.SchemaName}].[${e.BaseView}] WHERE `;
+                const sql = `SELECT [${f.Name}] FROM [${e.SchemaName}].[${e.BaseView}] WHERE `;
                 let where = '';
-                for (let pkv of CompositeKey.KeyValuePairs) {
+                for (const pkv of CompositeKey.KeyValuePairs) {
                     const pk = e.PrimaryKeys.find((pk) => pk.Name === pkv.FieldName);
                     const quotes = pk.NeedsQuotes ? "'" : '';
                     if (where.length > 0)