@memberjunction/sqlserver-dataprovider 2.49.0 → 2.51.0

package/README.md

@@ -21,6 +21,8 @@ The `@memberjunction/sqlserver-dataprovider` package implements MemberJunction's
 - **Duplicate Detection**: Built-in support for duplicate record detection
 - **Audit Logging**: Comprehensive audit trail capabilities
 - **Row-Level Security**: Enforce data access controls at the database level
+- **SQL Logging**: Real-time SQL statement capture for debugging and migration generation
+- **Session Management**: Multiple concurrent SQL logging sessions with user filtering
 
 ## Installation
 
@@ -414,6 +416,10 @@ The main class that implements IEntityDataProvider, IMetadataProvider, IRunViewP
 - `RunReport(params: RunReportParams, contextUser?: UserInfo): Promise<RunReportResult>` - Execute a report
 - `RunQuery(params: RunQueryParams, contextUser?: UserInfo): Promise<RunQueryResult>` - Execute a query
 - `ExecuteSQL(sql: string, params?: any, maxRows?: number): Promise<any[]>` - Execute raw SQL
+- `createSqlLogger(filePath: string, options?: SqlLoggingOptions): Promise<SqlLoggingSession>` - Create a new SQL logging session
+- `getActiveSqlLoggingSessions(): SqlLoggingSession[]` - Get all active logging sessions
+- `disposeAllSqlLoggingSessions(): Promise<void>` - Stop and clean up all logging sessions
+- `isSqlLoggingEnabled(): boolean` - Check if SQL logging is available
 
 ### SQLServerProviderConfigData
 
@@ -458,24 +464,23 @@ Helper function to initialize and configure the SQL Server data provider.
 setupSQLServerClient(config: SQLServerProviderConfigData): Promise<SQLServerDataProvider>
 ```
 
-## SQL Output Logging
+## SQL Logging
 
-The SQL Server Data Provider includes built-in SQL output logging capabilities that allow you to capture all SQL statements executed during operations. This is particularly useful for:
-
-- **Creating migration files** from application operations
-- **Debugging database operations** by reviewing exact SQL statements
-- **Performance analysis** by examining query patterns
-- **Compliance and auditing** requirements
+The SQL Server Data Provider includes comprehensive SQL logging capabilities that allow you to capture SQL statements in real-time. This feature supports both programmatic access and runtime control through the MemberJunction UI.
 
 ### Key Features
 
-- **Session-based logging** with unique identifiers for each logging session
-- **Parallel execution support** - logging runs alongside SQL execution without impacting performance
-- **Multiple output formats** - standard SQL logs or migration-ready files with Flyway naming
-- **Disposable pattern** - automatic resource cleanup when logging session ends
-- **Parameter capture** - logs both SQL statements and their parameters
+- **Real-time SQL capture** - Monitor SQL statements as they execute
+- **Session-based logging** with unique identifiers and names
+- **User filtering** - Capture SQL from specific users only
+- **Multiple output formats** - Standard SQL logs or migration-ready files
+- **Runtime control** - Start/stop sessions through GraphQL API and UI
+- **Owner-level security** - Only users with Owner privileges can access SQL logging
+- **Automatic cleanup** - Sessions auto-expire and clean up empty files
+- **Concurrent sessions** - Support multiple active logging sessions
+- **Parameter capture** - Logs both SQL statements and their parameters
 
-### Basic Usage
+### Programmatic Usage
 
 ```typescript
 import { SQLServerDataProvider } from '@memberjunction/sqlserver-dataprovider';
@@ -484,9 +489,12 @@ const dataProvider = new SQLServerDataProvider(/* config */);
 await dataProvider.initialize();
 
 // Create a SQL logging session
-const logger = await dataProvider.createSqlLogger('./output/operations.sql', {
+const logger = await dataProvider.createSqlLogger('./logs/sql/operations.sql', {
   formatAsMigration: false,
-  description: 'User registration operations'
+  sessionName: 'User registration operations',
+  filterByUserId: 'user@example.com',  // Only log SQL from this user
+  prettyPrint: true,
+  statementTypes: 'both'  // Log both queries and mutations
 });
 
 // Perform your database operations - they will be automatically logged
@@ -495,26 +503,99 @@ await dataProvider.ExecuteSQL('INSERT INTO Users (Name, Email) VALUES (@name, @e
   email: 'john@example.com'
 });
 
+// Check session status
+console.log(`Session ${logger.id} has captured ${logger.statementCount} statements`);
+
 // Clean up the logging session
 await logger.dispose();
 ```
 
+### Runtime Control via GraphQL
+
+```typescript
+// Start a new logging session
+const mutation = `
+  mutation {
+    startSqlLogging(input: {
+      fileName: "debug-session.sql"
+      filterToCurrentUser: true
+      options: {
+        sessionName: "Debug Session"
+        prettyPrint: true
+        statementTypes: "both"
+        formatAsMigration: false
+      }
+    }) {
+      id
+      filePath
+      sessionName
+    }
+  }
+`;
+
+// List active sessions
+const query = `
+  query {
+    activeSqlLoggingSessions {
+      id
+      sessionName
+      startTime
+      statementCount
+      filterByUserId
+    }
+  }
+`;
+
+// Stop a session
+const stopMutation = `
+  mutation {
+    stopSqlLogging(sessionId: "session-id-here")
+  }
+`;
+```
+
+### UI Integration
+
+SQL logging can be controlled through the MemberJunction Explorer UI:
+
+1. **Settings Panel**: Navigate to Settings > SQL Logging (Owner access required)
+2. **Session Management**: Start/stop sessions with custom options
+3. **Real-time Monitoring**: View active sessions and statement counts
+4. **User Filtering**: Option to capture only your SQL statements
+5. **Log Viewing**: Preview log file contents (implementation dependent)
+
 ### Migration-Ready Format
 
 ```typescript
 // Create logger with migration formatting
 const migrationLogger = await dataProvider.createSqlLogger('./migrations/V20241215120000__User_Operations.sql', {
   formatAsMigration: true,
-  description: 'User management operations for deployment'
+  sessionName: 'User management operations for deployment',
+  batchSeparator: 'GO',
+  logRecordChangeMetadata: true
 });
 
 // Your operations are logged in Flyway-compatible format
 // with proper headers and schema placeholders
 ```
 
-For comprehensive examples and advanced usage patterns, see [EXAMPLE_SQL_LOGGING.md](./EXAMPLE_SQL_LOGGING.md).
+### Session Management Methods
 
-> **Note**: This SQL output logging is different from the query execution logging available through subclassing the SQLServerDataProvider. SQL output logging captures statements for external use (like creating migrations), while execution logging is for debugging and monitoring the provider itself.
+```typescript
+// Get all active sessions
+const activeSessions = dataProvider.getActiveSqlLoggingSessions();
+console.log(`${activeSessions.length} sessions currently active`);
+
+// Dispose all sessions
+await dataProvider.disposeAllSqlLoggingSessions();
+
+// Check if logging is enabled
+if (dataProvider.isSqlLoggingEnabled()) {
+  console.log('SQL logging is available');
+}
+```
+
+> **Security Note**: SQL logging requires Owner-level privileges in the MemberJunction system. Only users with `Type = 'Owner'` can create, manage, or access SQL logging sessions.
 
 ## Troubleshooting
 
@@ -559,4 +640,127 @@ export MJ_LOG_LEVEL=debug
 
 ## License
 
-ISC
+ISC
+
+## SQL Server Connection Pooling and Best Practices
+
+### Overview
+
+The MemberJunction SQL Server Data Provider is designed to support high-performance parallel database operations through proper connection pool management. The underlying `mssql` driver (node-mssql) is expressly designed to handle many concurrent database calls efficiently.
+
+### How MemberJunction Handles Parallelism
+
+1. **Single Shared Connection Pool**: MemberJunction creates one connection pool at server startup and reuses it throughout the application lifecycle. This pool is passed to the SQLServerDataProvider and used for all database operations.
+
+2. **Request-Per-Query Pattern**: Each database operation creates a new `sql.Request` object from the shared pool, allowing multiple queries to execute in parallel without blocking each other.
+
+3. **Configurable Pool Size**: The connection pool can be configured via `mj.config.cjs` to support your specific concurrency needs:
+
+```javascript
+// In your mj.config.cjs at the root level
+module.exports = {
+  databaseSettings: {
+    connectionPool: {
+      max: 50,              // Maximum connections (default: 50)
+      min: 5,               // Minimum connections (default: 5)
+      idleTimeoutMillis: 30000,    // Idle timeout (default: 30s)
+      acquireTimeoutMillis: 30000  // Acquire timeout (default: 30s)
+    }
+  }
+};
+```
+
+### Best Practices Implementation
+
+MemberJunction follows SQL Server connection best practices:
+
+#### ✅ What We Do Right
+
+1. **Create Pool Once**: The pool is created during server initialization and never recreated
+2. **Never Close Pool in Handlers**: The pool remains open for the server's lifetime
+3. **Fresh Request Per Query**: Each query gets its own `sql.Request` object
+4. **Proper Error Handling**: Connection failures are caught and logged appropriately
+5. **Read-Only Pool Option**: Separate pool for read operations if configured
+
+#### ❌ Anti-Patterns We Avoid
+
+1. We don't create new connections for each request
+2. We don't open/close the pool repeatedly
+3. We don't share Request objects between queries
+4. We don't use hardcoded pool limits
+
+### Recommended Pool Settings
+
+Based on your environment and load:
+
+#### Development Environment
+```javascript
+connectionPool: {
+  max: 10,
+  min: 2,
+  idleTimeoutMillis: 60000,
+  acquireTimeoutMillis: 15000
+}
+```
+
+#### Production - Standard Load
+```javascript
+connectionPool: {
+  max: 50,      // 2-4× CPU cores of your API server
+  min: 5,
+  idleTimeoutMillis: 30000,
+  acquireTimeoutMillis: 30000
+}
+```
+
+#### Production - High Load
+```javascript
+connectionPool: {
+  max: 100,     // Monitor SQL Server wait types to tune
+  min: 10,
+  idleTimeoutMillis: 30000,
+  acquireTimeoutMillis: 30000
+}
+```
+
+### Performance Considerations
+
+1. **Pool Size**: The practical concurrency limit equals your pool size. With default settings (max: 50), you can have up to 50 concurrent SQL operations.
+
+2. **Connection Reuse**: The mssql driver efficiently reuses connections from the pool, minimizing connection overhead.
+
+3. **Queue Management**: When all connections are busy, additional requests queue in FIFO order until a connection becomes available.
+
+4. **Monitoring**: Watch for these SQL Server wait types to identify if pool size is too large:
+   - `RESOURCE_SEMAPHORE`: Memory pressure
+   - `THREADPOOL`: Worker thread exhaustion
+
+### Troubleshooting Connection Pool Issues
+
+If you experience "connection pool exhausted" errors:
+
+1. **Increase Pool Size**: Adjust `max` in your configuration
+2. **Check for Leaks**: Ensure all queries complete properly
+3. **Monitor Long Queries**: Identify and optimize slow queries that hold connections
+4. **Review Concurrent Load**: Ensure pool size matches your peak concurrency needs
+
+### Technical Implementation Details
+
+The connection pool is created in `/packages/MJServer/src/index.ts`:
+
+```typescript
+const pool = new sql.ConnectionPool(createMSSQLConfig());
+await pool.connect();
+```
+
+And used in SQLServerDataProvider for each query:
+
+```typescript
+const request = new sql.Request(this._pool);
+const result = await request.query(sql);
+```
+
+#### **Important** 
+If you are using `SQLServerDataProvider` outside of the context of MJServer/MJAPI it is your responsibility to create connection pool in alignment with whatever practices make sense for your project and pass that along to the SQLServerDataProvider configuration process.
+
+This pattern ensures maximum parallelism while maintaining connection efficiency, allowing MemberJunction applications to scale to handle hundreds of concurrent database operations without blocking the Node.js event loop.

package/dist/SQLServerDataProvider.d.ts

@@ -15,89 +15,13 @@
  * In practice - this FILE will NOT exist in the entities library, we need to move to its own separate project
  * so it is only included by the consumer of the entities library if they want to use it.
  **************************************************************************************************************/
-import { BaseEntity, IEntityDataProvider, IMetadataProvider, IRunViewProvider, ProviderConfigDataBase, RunViewResult, EntityInfo, EntityFieldInfo, ApplicationInfo, RunViewParams, ProviderBase, ProviderType, UserInfo, RoleInfo, RecordChange, UserRoleInfo, ILocalStorageProvider, RowLevelSecurityFilterInfo, AuditLogTypeInfo, AuthorizationInfo, TransactionGroupBase, EntitySaveOptions, RunReportParams, DatasetItemFilterType, DatasetResultType, DatasetStatusResultType, EntityRecordNameInput, EntityRecordNameResult, IRunReportProvider, RunReportResult, RecordDependency, RecordMergeRequest, RecordMergeResult, EntityDependency, IRunQueryProvider, RunQueryResult, PotentialDuplicateRequest, PotentialDuplicateResponse, CompositeKey, EntityDeleteOptions, DatasetItemResultType } from '@memberjunction/core';
+import { BaseEntity, IEntityDataProvider, IMetadataProvider, IRunViewProvider, RunViewResult, EntityInfo, EntityFieldInfo, ApplicationInfo, RunViewParams, ProviderBase, ProviderType, UserInfo, RecordChange, ILocalStorageProvider, AuditLogTypeInfo, AuthorizationInfo, TransactionGroupBase, EntitySaveOptions, RunReportParams, DatasetItemFilterType, DatasetResultType, DatasetStatusResultType, EntityRecordNameInput, EntityRecordNameResult, IRunReportProvider, RunReportResult, RecordDependency, RecordMergeRequest, RecordMergeResult, EntityDependency, IRunQueryProvider, RunQueryResult, PotentialDuplicateRequest, PotentialDuplicateResponse, CompositeKey, EntityDeleteOptions, DatasetItemResultType } from '@memberjunction/core';
 import { AuditLogEntity, EntityAIActionEntity, RecordMergeLogEntity, UserViewEntityExtended } from '@memberjunction/core-entities';
 import * as sql from 'mssql';
+import { Observable } from 'rxjs';
+import { ExecuteSQLOptions, ExecuteSQLBatchOptions, SQLServerProviderConfigData, SqlLoggingOptions, SqlLoggingSession } from './types.js';
 import { RunQueryParams } from '@memberjunction/core/dist/generic/runQuery';
 import { ActionResult } from '@memberjunction/actions-base';
-/**
- * Configuration options for SQL execution with logging support
- */
-export interface ExecuteSQLOptions {
-    /** Optional description for this SQL operation */
-    description?: string;
-    /** If true, this statement will not be logged to any logging session */
-    ignoreLogging?: boolean;
-    /** Whether this is a data mutation operation (INSERT/UPDATE/DELETE) */
-    isMutation?: boolean;
-    /** Simple SQL fallback for loggers with logRecordChangeMetadata=false (only for Save/Delete operations) */
-    simpleSQLFallback?: string;
-}
-/**
- * Configuration options for batch SQL execution
- */
-export interface ExecuteSQLBatchOptions {
-    /** Optional description for this batch operation */
-    description?: string;
-    /** If true, this batch will not be logged to any logging session */
-    ignoreLogging?: boolean;
-    /** Whether this batch contains data mutation operations */
-    isMutation?: boolean;
-}
-/**
- * Configuration data specific to SQL Server provider
- */
-export declare class SQLServerProviderConfigData extends ProviderConfigDataBase {
-    /**
-     * Gets the SQL Server data source configuration
-     */
-    get DataSource(): any;
-    /**
-     * Gets the current user's email address
-     */
-    get CurrentUserEmail(): string;
-    /**
-     * Gets the interval in seconds for checking metadata refresh
-     */
-    get CheckRefreshIntervalSeconds(): number;
-    constructor(dataSource: any, currentUserEmail: string, MJCoreSchemaName?: string, checkRefreshIntervalSeconds?: number, includeSchemas?: string[], excludeSchemas?: string[]);
-}
-/**
- * Configuration options for SQL logging sessions
- */
-export interface SqlLoggingOptions {
-    /** Whether to format output as a migration file with schema placeholders */
-    formatAsMigration?: boolean;
-    /** Optional description to include as a comment at the start of the log */
-    description?: string;
-    /** Which types of statements to log: 'queries' (all), 'mutations' (only data changes), 'both' (default) */
-    statementTypes?: 'queries' | 'mutations' | 'both';
-    /** Optional batch separator to emit after each statement (e.g., "GO" for SQL Server) */
-    batchSeparator?: string;
-    /** Whether to pretty print SQL statements with proper formatting */
-    prettyPrint?: boolean;
-    /** Whether to log record change metadata wrapper SQL (default: false). When false, only core spCreate/spUpdate/spDelete calls are logged */
-    logRecordChangeMetadata?: boolean;
-    /** Whether to retain log files that contain no SQL statements (default: false). When false, empty log files are automatically deleted on dispose */
-    retainEmptyLogFiles?: boolean;
-}
-/**
- * Interface for SQL logging session with disposable pattern
- */
-export interface SqlLoggingSession {
-    /** Unique session ID */
-    readonly id: string;
-    /** File path where SQL is being logged */
-    readonly filePath: string;
-    /** Session start time */
-    readonly startTime: Date;
-    /** Number of statements logged so far */
-    readonly statementCount: number;
-    /** Configuration options for this session */
-    readonly options: SqlLoggingOptions;
-    /** Dispose method to stop logging and clean up resources */
-    dispose(): Promise<void>;
-}
 /**
  * SQL Server implementation of the MemberJunction data provider interfaces.
  *
@@ -112,7 +36,7 @@ export interface SqlLoggingSession {
  *
  * @example
  * ```typescript
- * const config = new SQLServerProviderConfigData(dataSource, userEmail);
+ * const config = new SQLServerProviderConfigData(dataSource);
  * const provider = new SQLServerDataProvider(config);
  * await provider.Config();
  * ```
@@ -121,14 +45,27 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
     private _pool;
     private _poolConfig;
     private _transaction;
-    private _transactionRequest;
-    private _currentUserEmail;
     private _localStorageProvider;
     private _bAllowRefresh;
     private _recordDupeDetector;
     private _needsDatetimeOffsetAdjustment;
     private _datetimeOffsetTestComplete;
     private _sqlLoggingSessions;
+    private _transactionState$;
+    private _deferredTasks;
+    /**
+     * Observable that emits the current transaction state (true when active, false when not)
+     * External code can subscribe to this to know when transactions start and end
+     * @example
+     * provider.transactionState$.subscribe(isActive => {
+     *   console.log('Transaction active:', isActive);
+     * });
+     */
+    get transactionState$(): Observable<boolean>;
+    /**
+     * Gets whether a transaction is currently active
+     */
+    get isTransactionActive(): boolean;
     /**
      * Gets the current configuration data for this provider instance
      */
@@ -173,7 +110,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @example
      * ```typescript
      * // Basic usage
-     * const session = await provider.createSqlLogger('./logs/metadata-sync.sql');
+     * const session = await provider.CreateSqlLogger('./logs/metadata-sync.sql');
      * try {
      *   // Perform operations that will be logged
      *   await provider.ExecuteSQL('INSERT INTO ...');
@@ -182,20 +119,21 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * }
      *
      * // With migration formatting
-     * const session = await provider.createSqlLogger('./migrations/changes.sql', {
+     * const session = await provider.CreateSqlLogger('./migrations/changes.sql', {
      *   formatAsMigration: true,
      *   description: 'MetadataSync push operation'
      * });
      * ```
      */
-    createSqlLogger(filePath: string, options?: SqlLoggingOptions): Promise<SqlLoggingSession>;
+    CreateSqlLogger(filePath: string, options?: SqlLoggingOptions): Promise<SqlLoggingSession>;
+    GetCurrentUser(): Promise<UserInfo>;
     /**
      * Gets information about all active SQL logging sessions.
      * Useful for monitoring and debugging.
      *
      * @returns Array of session information objects
      */
-    getActiveSqlLoggingSessions(): Array<{
+    GetActiveSqlLoggingSessions(): Array<{
         id: string;
         filePath: string;
         startTime: Date;
@@ -206,7 +144,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * Disposes all active SQL logging sessions.
      * Useful for cleanup on provider shutdown.
      */
-    disposeAllSqlLoggingSessions(): Promise<void>;
+    DisposeAllSqlLoggingSessions(): Promise<void>;
     /**
      * Internal method to log SQL statement to all active logging sessions.
      * This is called automatically by ExecuteSQL methods.
@@ -228,7 +166,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @param isMutation - Whether this is a data mutation operation
      * @param simpleSQLFallback - Optional simple SQL to use for loggers with logRecordChangeMetadata=false
      */
-    static LogSQLStatement(query: string, parameters?: any, description?: string, isMutation?: boolean, simpleSQLFallback?: string): Promise<void>;
+    static LogSQLStatement(query: string, parameters?: any, description?: string, isMutation?: boolean, simpleSQLFallback?: string, contextUser?: UserInfo): Promise<void>;
     /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
@@ -262,17 +200,17 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
         runID: string;
     }>;
     protected createViewUserSearchSQL(entityInfo: EntityInfo, userSearchString: string): string;
-    createAuditLogRecord(user: UserInfo, authorizationName: string | null, auditLogTypeName: string, status: string, details: string | null, entityId: string, recordId: any | null, auditLogDescription: string | null): Promise<AuditLogEntity>;
+    CreateAuditLogRecord(user: UserInfo, authorizationName: string | null, auditLogTypeName: string, status: string, details: string | null, entityId: string, recordId: any | null, auditLogDescription: string | null): Promise<AuditLogEntity>;
     protected CheckUserReadPermissions(entityName: string, contextUser: UserInfo): void;
     /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
     get ProviderType(): ProviderType;
-    GetRecordFavoriteStatus(userId: string, entityName: string, CompositeKey: CompositeKey): Promise<boolean>;
-    GetRecordFavoriteID(userId: string, entityName: string, CompositeKey: CompositeKey): Promise<string | null>;
+    GetRecordFavoriteStatus(userId: string, entityName: string, CompositeKey: CompositeKey, contextUser?: UserInfo): Promise<boolean>;
+    GetRecordFavoriteID(userId: string, entityName: string, CompositeKey: CompositeKey, contextUser?: UserInfo): Promise<string | null>;
     SetRecordFavoriteStatus(userId: string, entityName: string, CompositeKey: CompositeKey, isFavorite: boolean, contextUser: UserInfo): Promise<void>;
-    GetRecordChanges(entityName: string, compositeKey: CompositeKey): Promise<RecordChange[]>;
+    GetRecordChanges(entityName: string, compositeKey: CompositeKey, contextUser?: UserInfo): Promise<RecordChange[]>;
     /**
      * This function will generate SQL statements for all of the possible soft links that are not traditional foreign keys but exist in entities
      * where there is a column that has the EntityIDFieldName set to a column name (not null). We need to get a list of all such soft link fields across ALL entities
@@ -290,7 +228,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @param entityName the name of the entity to check
      * @param KeyValuePairs the primary key(s) to check - only send multiple if you have an entity with a composite primary key
      */
-    GetRecordDependencies(entityName: string, compositeKey: CompositeKey): Promise<RecordDependency[]>;
+    GetRecordDependencies(entityName: string, compositeKey: CompositeKey, contextUser?: UserInfo): Promise<RecordDependency[]>;
     protected GetRecordDependencyLinkSQL(dep: EntityDependency, entity: EntityInfo, relatedEntity: EntityInfo, CompositeKey: CompositeKey): string;
     GetRecordDuplicates(params: PotentialDuplicateRequest, contextUser?: UserInfo): Promise<PotentialDuplicateResponse>;
     MergeRecords(request: RecordMergeRequest, contextUser?: UserInfo): Promise<RecordMergeResult>;
@@ -393,7 +331,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
     /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
-    GetDatasetByName(datasetName: string, itemFilters?: DatasetItemFilterType[]): Promise<DatasetResultType>;
+    GetDatasetByName(datasetName: string, itemFilters?: DatasetItemFilterType[], contextUser?: UserInfo): Promise<DatasetResultType>;
     /**
      * Constructs the SQL query for a dataset item.
      * @param item - The dataset item metadata
@@ -402,7 +340,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @returns The SQL query string, or null if columns are invalid
      */
     protected GetDatasetItemSQL(item: any, itemFilters: any, datasetName: string): string | null;
-    protected GetDatasetItem(item: any, itemFilters: any, datasetName: any): Promise<DatasetItemResultType>;
+    protected GetDatasetItem(item: any, itemFilters: any, datasetName: any, contextUser: UserInfo): Promise<DatasetItemResultType>;
     /**
      * Gets column info for a dataset item, which might be * for all columns or if a Columns field was provided in the DatasetItem table,
      * attempts to use those columns assuming they are valid.
@@ -411,16 +349,11 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @returns
      */
     protected GetColumnsForDatasetItem(item: any, datasetName: string): string;
-    GetDatasetStatusByName(datasetName: string, itemFilters?: DatasetItemFilterType[]): Promise<DatasetStatusResultType>;
-    protected GetApplicationMetadata(): Promise<ApplicationInfo[]>;
-    protected GetAuditLogTypeMetadata(): Promise<AuditLogTypeInfo[]>;
-    protected GetUserMetadata(): Promise<UserInfo[]>;
-    protected GetAuthorizationMetadata(): Promise<AuthorizationInfo[]>;
-    protected GetCurrentUser(): Promise<UserInfo>;
-    protected GetCurrentUserMetadata(): Promise<UserInfo>;
-    protected GetRoleMetadata(): Promise<RoleInfo[]>;
-    protected GetUserRoleMetadata(): Promise<UserRoleInfo[]>;
-    protected GetRowLevelSecurityFilterMetadata(): Promise<RowLevelSecurityFilterInfo[]>;
+    GetDatasetStatusByName(datasetName: string, itemFilters?: DatasetItemFilterType[], contextUser?: UserInfo): Promise<DatasetStatusResultType>;
+    protected GetApplicationMetadata(contextUser: UserInfo): Promise<ApplicationInfo[]>;
+    protected GetAuditLogTypeMetadata(contextUser: UserInfo): Promise<AuditLogTypeInfo[]>;
+    protected GetUserMetadata(contextUser: UserInfo): Promise<UserInfo[]>;
+    protected GetAuthorizationMetadata(contextUser: UserInfo): Promise<AuthorizationInfo[]>;
     /**
      * Processes entity rows returned from SQL Server to handle timezone conversions for datetime fields.
      * This method specifically handles the conversion of datetime2 fields (which SQL Server returns without timezone info)
@@ -431,6 +364,40 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @returns The processed rows with corrected datetime values
      */
     ProcessEntityRows(rows: any[], entityInfo: EntityInfo): Promise<any[]>;
+    /**
+     * Static method for executing SQL with proper handling of connections and logging.
+     * This is the single point where all SQL execution happens in the entire class.
+     *
+     * @param query - SQL query to execute
+     * @param parameters - Query parameters
+     * @param context - Execution context containing pool, transaction, and logging functions
+     * @param options - Options for SQL execution
+     * @returns Promise<sql.IResult<any>> - Query result
+     * @private
+     */
+    private static _internalExecuteSQLStatic;
+    /**
+     * Internal centralized method for executing SQL queries with consistent transaction and connection handling.
+     * This method ensures proper request object creation and management to avoid concurrency issues,
+     * particularly when using transactions where multiple operations may execute in parallel.
+     *
+     * @private
+     * @param query - The SQL query to execute
+     * @param parameters - Optional parameters for the query (array for positional, object for named)
+     * @param connectionSource - Optional specific connection source (pool, transaction, or request)
+     * @param loggingOptions - Optional logging configuration
+     * @returns Promise<sql.IResult<any>> - The raw mssql result object
+     *
+     * @remarks
+     * - Always creates a new Request object for each query to avoid "EREQINPROG" errors
+     * - Handles both positional (?) and named (@param) parameter styles
+     * - Automatically uses active transaction if one exists, otherwise uses connection pool
+     * - Handles SQL logging in parallel with query execution
+     * - Provides automatic retry with pool connection if transaction fails
+     *
+     * @throws {Error} Rethrows any SQL execution errors after logging
+     */
+    private _internalExecuteSQL;
     /**
      * This method can be used to execute raw SQL statements outside of the MJ infrastructure.
      * *CAUTION* - use this method with great care.
@@ -438,7 +405,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @param parameters
      * @returns
      */
-    ExecuteSQL(query: string, parameters?: any, options?: ExecuteSQLOptions): Promise<any>;
+    ExecuteSQL(query: string, parameters?: any, options?: ExecuteSQLOptions, contextUser?: UserInfo): Promise<any>;
     /**
      * 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
@@ -450,7 +417,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @param parameters - Optional parameters for the query
      * @returns Promise<any[]> - Array of results (empty array if no results)
      */
-    static ExecuteSQLWithPool(pool: sql.ConnectionPool, query: string, parameters?: any): Promise<any[]>;
+    static ExecuteSQLWithPool(pool: sql.ConnectionPool, query: string, parameters?: any, contextUser?: UserInfo): Promise<any[]>;
     /**
      * 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.
@@ -462,7 +429,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @param parameters - Optional array of parameter arrays, one for each query
      * @returns Promise<any[][]> - Array of result arrays, one for each query
      */
-    static ExecuteSQLBatchStatic(connectionSource: sql.ConnectionPool | sql.Transaction | sql.Request, queries: string[], parameters?: any[][]): Promise<any[][]>;
+    static ExecuteSQLBatchStatic(connectionSource: sql.ConnectionPool | sql.Transaction | sql.Request, queries: string[], parameters?: any[][], contextUser?: UserInfo): Promise<any[][]>;
     /**
      * Executes multiple SQL queries in a single batch for optimal performance.
      * All queries are combined into a single SQL statement and executed together.
@@ -474,7 +441,7 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * @param options - Optional execution options for logging and description
      * @returns Promise<any[][]> - Array of result arrays, one for each query
      */
-    ExecuteSQLBatch(queries: string[], parameters?: any[][], options?: ExecuteSQLBatchOptions): Promise<any[][]>;
+    ExecuteSQLBatch(queries: string[], parameters?: any[][], options?: ExecuteSQLBatchOptions, contextUser?: UserInfo): Promise<any[][]>;
     /**
      * 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., mssql)
@@ -502,12 +469,24 @@ export declare class SQLServerDataProvider extends ProviderBase implements IEnti
      * This empirical test determines if we need to adjust for incorrect timezone handling.
      */
     private testDatetimeOffsetHandling;
-    protected BeginTransaction(): Promise<void>;
-    protected CommitTransaction(): Promise<void>;
-    protected RollbackTransaction(): Promise<void>;
+    BeginTransaction(): Promise<void>;
+    CommitTransaction(): Promise<void>;
+    RollbackTransaction(): Promise<void>;
+    /**
+     * Override RefreshIfNeeded to skip refresh when a transaction is active
+     * This prevents conflicts between metadata refresh operations and active transactions
+     * @returns Promise<boolean> - true if refresh was performed, false if skipped or no refresh needed
+     */
+    RefreshIfNeeded(): Promise<boolean>;
+    /**
+     * Process any deferred tasks that were queued during a transaction
+     * This is called after a successful transaction commit
+     * @private
+     */
+    private processDeferredTasks;
     get LocalStorageProvider(): ILocalStorageProvider;
-    GetEntityRecordNames(info: EntityRecordNameInput[]): Promise<EntityRecordNameResult[]>;
-    GetEntityRecordName(entityName: string, CompositeKey: CompositeKey): Promise<string>;
+    GetEntityRecordNames(info: EntityRecordNameInput[], contextUser?: UserInfo): Promise<EntityRecordNameResult[]>;
+    GetEntityRecordName(entityName: string, CompositeKey: CompositeKey, contextUser?: UserInfo): Promise<string>;
     protected GetEntityRecordNameSQL(entityName: string, CompositeKey: CompositeKey): string;
     CreateTransactionGroup(): Promise<TransactionGroupBase>;
     /**************************************************************************/