@memberjunction/sqlserver-dataprovider 2.53.0 → 2.54.0

package/dist/SQLServerDataProvider.js

@@ -51,6 +51,82 @@ const SQLServerTransactionGroup_1 = require("./SQLServerTransactionGroup");
 const SqlLogger_js_1 = require("./SqlLogger.js");
 const actions_1 = require("@memberjunction/actions");
 const uuid_1 = require("uuid");
+/**
+ * Core SQL execution function - handles the actual database query execution
+ * This is outside the class to allow both static and instance methods to use it
+ * without creating circular dependencies or forcing everything to be static
+ */
+async function executeSQLCore(query, parameters, context, options) {
+    // Determine which connection source to use
+    let connectionSource;
+    if (context.transaction) {
+        // Use the transaction if provided
+        // Note: We no longer test the transaction validity here because:
+        // 1. It could cause race conditions with concurrent queries
+        // 2. If the transaction is invalid, we'll get a proper error when trying to use it
+        // 3. We should never silently fall back to the pool when a transaction is expected
+        connectionSource = context.transaction;
+    }
+    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 (connectionSource instanceof sql.Transaction) {
+            request = new sql.Request(connectionSource);
+        }
+        else {
+            request = new sql.Request(connectionSource);
+        }
+        // Add parameters if provided
+        let processedQuery = query;
+        if (parameters) {
+            if (Array.isArray(parameters)) {
+                // Handle positional parameters (legacy TypeORM style)
+                parameters.forEach((value, index) => {
+                    request.input(`p${index}`, value);
+                });
+                // Replace ? with @p0, @p1, etc. in the query
+                let paramIndex = 0;
+                processedQuery = query.replace(/\?/g, () => `@p${paramIndex++}`);
+            }
+            else if (typeof parameters === 'object') {
+                // Handle named parameters
+                for (const [key, value] of Object.entries(parameters)) {
+                    request.input(key, value);
+                }
+            }
+        }
+        // Execute query and logging in parallel
+        const [result] = await Promise.all([
+            request.query(processedQuery),
+            logPromise
+        ]);
+        return result;
+    }
+    catch (error) {
+        // Log all errors
+        (0, core_1.LogError)(error);
+        // Re-throw all errors
+        throw error;
+    }
+}
 /**
  * SQL Server implementation of the MemberJunction data provider interfaces.
  *
@@ -70,13 +146,19 @@ const uuid_1 = require("uuid");
  * await provider.Config();
  * ```
  */
-class SQLServerDataProvider extends core_1.ProviderBase {
+class SQLServerDataProvider extends core_1.DatabaseProviderBase {
     constructor() {
         super(...arguments);
+        this._transactionDepth = 0;
+        this._savepointCounter = 0;
+        this._savepointStack = [];
         this._bAllowRefresh = true;
         this._needsDatetimeOffsetAdjustment = false;
         this._datetimeOffsetTestComplete = false;
         this._sqlLoggingSessions = new Map();
+        // Instance SQL execution queue for serializing transaction queries
+        // Non-transactional queries bypass this queue for maximum parallelism
+        this._sqlQueue$ = new rxjs_1.Subject();
         // Transaction state management
         this._transactionState$ = new rxjs_1.BehaviorSubject(false);
         this._deferredTasks = [];
@@ -92,6 +174,32 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     get transactionState$() {
         return this._transactionState$.asObservable();
     }
+    /**
+     * Gets the current transaction nesting depth
+     * 0 = no transaction, 1 = first level, 2+ = nested transactions
+     */
+    get transactionDepth() {
+        return this._transactionDepth;
+    }
+    /**
+     * Checks if we're currently in a transaction (at any depth)
+     */
+    get inTransaction() {
+        return this._transactionDepth > 0;
+    }
+    /**
+     * Checks if we're currently in a nested transaction (depth > 1)
+     */
+    get inNestedTransaction() {
+        return this._transactionDepth > 1;
+    }
+    /**
+     * Gets the current savepoint names in the stack (for debugging)
+     * Returns a copy to prevent external modification
+     */
+    get savepointStack() {
+        return [...this._savepointStack];
+    }
     /**
      * Gets whether a transaction is currently active
      */
@@ -113,6 +221,8 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     async Config(configData) {
         try {
             this._pool = configData.DataSource; // Now expects a ConnectionPool instead of DataSource
+            // Initialize the instance queue processor
+            this.initializeQueueProcessor();
             return super.Config(configData); // now parent class can do it's config
         }
         catch (e) {
@@ -120,6 +230,21 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             throw e;
         }
     }
+    /**
+     * Initialize the SQL queue processor for this instance
+     * This ensures all queries within a transaction execute sequentially
+     */
+    initializeQueueProcessor() {
+        // Each instance gets its own queue processor
+        this._queueSubscription = this._sqlQueue$.pipe((0, rxjs_1.concatMap)(item => (0, rxjs_1.from)(executeSQLCore(item.query, item.parameters, item.context, item.options)).pipe(
+        // Handle success
+        (0, rxjs_1.tap)(result => item.resolve(result)), 
+        // Handle errors
+        (0, rxjs_1.catchError)(error => {
+            item.reject(error);
+            return (0, rxjs_1.of)(null); // Continue processing queue even on errors
+        })))).subscribe();
+    }
     /**
      * Gets the underlying SQL Server connection pool
      * @returns The mssql ConnectionPool object
@@ -236,6 +361,25 @@ class SQLServerDataProvider extends core_1.ProviderBase {
         await Promise.all(disposePromises);
         this._sqlLoggingSessions.clear();
     }
+    /**
+     * Dispose of this provider instance and clean up resources.
+     * This should be called when the provider is no longer needed.
+     */
+    async Dispose() {
+        // Dispose all SQL logging sessions
+        await this.DisposeAllSqlLoggingSessions();
+        // Unsubscribe from the SQL queue
+        if (this._queueSubscription) {
+            this._queueSubscription.unsubscribe();
+            this._queueSubscription = null;
+        }
+        // Complete the queue subject
+        if (this._sqlQueue$) {
+            this._sqlQueue$.complete();
+        }
+        // Note: We don't close the pool here as it might be shared
+        // The caller is responsible for closing the pool when appropriate
+    }
     /**
      * Internal method to log SQL statement to all active logging sessions.
      * This is called automatically by ExecuteSQL methods.
@@ -2581,100 +2725,42 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      * @returns Promise<sql.IResult<any>> - Query result
      * @private
      */
+    /**
+     * Internal SQL execution method for instance calls - routes queries based on transaction state
+     * - Queries without transactions execute directly (allowing parallelism)
+     * - Queries within transactions go through the instance queue (ensuring serialization)
+     */
+    async _internalExecuteSQLInstance(query, parameters, context, options) {
+        // If no transaction is active, execute directly without queuing
+        // This allows maximum parallelism for non-transactional queries
+        if (!context.transaction) {
+            return executeSQLCore(query, parameters, context, options);
+        }
+        // For transactional queries, use the instance queue to ensure serialization
+        // This prevents EREQINPROG errors when multiple queries try to use the same transaction
+        return new Promise((resolve, reject) => {
+            this._sqlQueue$.next({
+                id: (0, uuid_1.v4)(),
+                query,
+                parameters,
+                context,
+                options,
+                resolve,
+                reject
+            });
+        });
+    }
+    /**
+     * Static SQL execution method - for static methods like ExecuteSQLWithPool
+     * Static methods don't have access to instance queues, so they execute directly
+     * Transactions are not supported in static context
+     */
     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 (connectionSource instanceof sql.Transaction) {
-                request = new sql.Request(connectionSource);
-            }
-            else {
-                request = new sql.Request(connectionSource);
-            }
-            // Add parameters if provided
-            let processedQuery = query;
-            if (parameters) {
-                if (Array.isArray(parameters)) {
-                    // Handle positional parameters (legacy TypeORM style)
-                    parameters.forEach((value, index) => {
-                        request.input(`p${index}`, value);
-                    });
-                    // Replace ? with @p0, @p1, etc. in the query
-                    let paramIndex = 0;
-                    processedQuery = query.replace(/\?/g, () => `@p${paramIndex++}`);
-                }
-                else if (typeof parameters === 'object') {
-                    // Handle named parameters
-                    for (const [key, value] of Object.entries(parameters)) {
-                        request.input(key, value);
-                    }
-                }
-            }
-            // 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;
+            throw new Error('Transactions are not supported in static SQL execution context. Use instance methods for transactional queries.');
         }
+        // Static calls always execute directly (no queue needed since no transactions)
+        return executeSQLCore(query, parameters, context, options);
     }
     /**
      * Internal centralized method for executing SQL queries with consistent transaction and connection handling.
@@ -2724,8 +2810,8 @@ class SQLServerDataProvider extends core_1.ProviderBase {
             simpleSQLFallback: loggingOptions.simpleSQLFallback,
             contextUser: loggingOptions.contextUser
         } : undefined;
-        // Delegate to static method
-        return SQLServerDataProvider._internalExecuteSQLStatic(query, parameters, context, options);
+        // Delegate to instance method
+        return this._internalExecuteSQLInstance(query, parameters, context, options);
     }
     /**
      * This method can be used to execute raw SQL statements outside of the MJ infrastructure.
@@ -2840,31 +2926,43 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     batchSQL += ';\n';
                 }
             });
-            // Execute the batch SQL directly (static method can't use instance _internalExecuteSQL)
-            let request;
+            // Create execution context for batch SQL
+            let pool;
+            let transaction = null;
             if (connectionSource instanceof sql.Request) {
-                request = connectionSource;
+                throw new Error('Request objects are not supported for batch execution. Use ConnectionPool or Transaction.');
             }
             else if (connectionSource instanceof sql.Transaction) {
-                request = new sql.Request(connectionSource);
+                transaction = connectionSource;
+                // Get pool from transaction's internal connection
+                pool = connectionSource._pool || connectionSource.parent;
+                if (!pool) {
+                    throw new Error('Unable to get connection pool from transaction');
+                }
             }
             else if (connectionSource instanceof sql.ConnectionPool) {
-                request = new sql.Request(connectionSource);
+                pool = 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
-            ]);
+            // Create context for executeSQLCore
+            const context = {
+                pool: pool,
+                transaction: transaction,
+                logSqlStatement: async (q, p, d, i, m, s, u) => {
+                    await SQLServerDataProvider.LogSQLStatement(q, p, d || 'Batch execution', m || false, s, u);
+                }
+            };
+            // Use named parameters for batch SQL
+            const namedParams = batchParameters;
+            // Execute using the centralized core function
+            const result = await executeSQLCore(batchSQL, namedParams, context, {
+                description: 'Batch execution',
+                ignoreLogging: false,
+                isMutation: false,
+                contextUser: contextUser
+            });
             // Return array of recordsets - one for each query
             // Handle both single and multiple recordsets
             if (result.recordsets && Array.isArray(result.recordsets)) {
@@ -2895,17 +2993,66 @@ class SQLServerDataProvider extends core_1.ProviderBase {
      */
     async ExecuteSQLBatch(queries, parameters, options, contextUser) {
         try {
-            let connectionSource;
-            if (this._transaction) {
-                // Use transaction if we have one
-                connectionSource = this._transaction;
+            // Build combined batch SQL and parameters (same as static method)
+            let batchSQL = '';
+            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, localIndex) => {
+                            const paramName = `p${globalParamIndex}`;
+                            batchParameters[paramName] = value;
+                            globalParamIndex++;
+                        });
+                        // 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}`;
+                            batchParameters[paramName] = value;
+                            // Replace parameter references in query
+                            processedQuery = processedQuery.replace(new RegExp(`@${key}\\b`, 'g'), `@${paramName}`);
+                        }
+                    }
+                }
+                batchSQL += processedQuery;
+                if (queryIndex < queries.length - 1) {
+                    batchSQL += ';\n';
+                }
+            });
+            // Create execution context
+            const context = {
+                pool: this._pool,
+                transaction: this._transaction,
+                logSqlStatement: this._logSqlStatement.bind(this),
+                clearTransaction: () => { this._transaction = null; }
+            };
+            // Execute using instance method (which handles queue for transactions)
+            const result = await this._internalExecuteSQLInstance(batchSQL, batchParameters, context, {
+                description: options?.description || 'Batch execution',
+                ignoreLogging: options?.ignoreLogging || false,
+                isMutation: options?.isMutation || false,
+                contextUser: contextUser
+            });
+            // 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 {
-                // Use pool for non-transactional queries
-                connectionSource = this._pool;
+                return [];
             }
-            // 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);
@@ -2995,29 +3142,57 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     }
     async BeginTransaction() {
         try {
-            // Create a new transaction from the pool
-            this._transaction = new sql.Transaction(this._pool);
-            await this._transaction.begin();
-            // Transaction created successfully
-            // Note: We create new Request objects for each query to avoid concurrency issues
-            // Emit transaction state change
-            this._transactionState$.next(true);
+            this._transactionDepth++;
+            if (this._transactionDepth === 1) {
+                // First transaction - actually begin using mssql Transaction object
+                this._transaction = new sql.Transaction(this._pool);
+                await this._transaction.begin();
+                // Emit transaction state change
+                this._transactionState$.next(true);
+            }
+            else {
+                // Nested transaction - create a savepoint
+                const savepointName = `SavePoint_${++this._savepointCounter}`;
+                this._savepointStack.push(savepointName);
+                // Create savepoint for nested transaction
+                await this.ExecuteSQL(`SAVE TRANSACTION ${savepointName}`, null, {
+                    description: `Creating savepoint ${savepointName} at depth ${this._transactionDepth}`,
+                    ignoreLogging: true
+                });
+            }
         }
         catch (e) {
+            this._transactionDepth--; // Restore depth on error
             (0, core_1.LogError)(e);
             throw e; // force caller to handle
         }
     }
     async CommitTransaction() {
         try {
-            if (this._transaction) {
+            if (!this._transaction) {
+                throw new Error('No active transaction to commit');
+            }
+            if (this._transactionDepth === 0) {
+                throw new Error('Transaction depth mismatch - no transaction to commit');
+            }
+            this._transactionDepth--;
+            if (this._transactionDepth === 0) {
+                // Outermost transaction - use mssql Transaction object to commit
                 await this._transaction.commit();
                 this._transaction = null;
+                // Clear savepoint tracking
+                this._savepointStack = [];
+                this._savepointCounter = 0;
                 // Emit transaction state change
                 this._transactionState$.next(false);
                 // Process any deferred tasks after successful commit
                 await this.processDeferredTasks();
             }
+            else {
+                // Nested transaction - just remove the savepoint from stack
+                // The savepoint remains valid in SQL Server until the outer transaction commits or rolls back
+                this._savepointStack.pop();
+            }
         }
         catch (e) {
             (0, core_1.LogError)(e);
@@ -3026,9 +3201,20 @@ class SQLServerDataProvider extends core_1.ProviderBase {
     }
     async RollbackTransaction() {
         try {
-            if (this._transaction) {
+            if (!this._transaction) {
+                throw new Error('No active transaction to rollback');
+            }
+            if (this._transactionDepth === 0) {
+                throw new Error('Transaction depth mismatch - no transaction to rollback');
+            }
+            if (this._transactionDepth === 1) {
+                // Outermost transaction - use mssql Transaction object to rollback everything
                 await this._transaction.rollback();
                 this._transaction = null;
+                this._transactionDepth = 0;
+                // Clear savepoint tracking
+                this._savepointStack = [];
+                this._savepointCounter = 0;
                 // Emit transaction state change
                 this._transactionState$.next(false);
                 // Clear deferred tasks after rollback (don't process them)
@@ -3038,8 +3224,33 @@ class SQLServerDataProvider extends core_1.ProviderBase {
                     (0, core_1.LogStatus)(`Cleared ${deferredCount} deferred tasks after transaction rollback`);
                 }
             }
+            else {
+                // Nested transaction - rollback to the last savepoint
+                const savepointName = this._savepointStack[this._savepointStack.length - 1];
+                if (!savepointName) {
+                    throw new Error('Savepoint stack mismatch - no savepoint to rollback to');
+                }
+                // Rollback to the savepoint (this preserves the outer transaction)
+                // Note: We use ROLLBACK TRANSACTION SavePointName (without TO) as per SQL Server syntax
+                await this.ExecuteSQL(`ROLLBACK TRANSACTION ${savepointName}`, null, {
+                    description: `Rolling back to savepoint ${savepointName}`,
+                    ignoreLogging: true
+                });
+                // Remove the savepoint from stack and decrement depth
+                this._savepointStack.pop();
+                this._transactionDepth--;
+            }
         }
         catch (e) {
+            // On error in nested transaction, maintain state
+            // On error in outer transaction, reset everything
+            if (this._transactionDepth === 1 || !this._transaction) {
+                this._transaction = null;
+                this._transactionDepth = 0;
+                this._savepointStack = [];
+                this._savepointCounter = 0;
+                this._transactionState$.next(false);
+            }
             (0, core_1.LogError)(e);
             throw e; // force caller to handle
         }