@memberjunction/sqlserver-dataprovider 5.4.1 → 5.5.0

package/dist/SQLServerDataProvider.d.ts

@@ -15,20 +15,12 @@
  * 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, RunViewResult, AggregateResult, EntityInfo, EntityFieldInfo, ApplicationInfo, RunViewParams, ProviderType, UserInfo, RecordChange, ILocalStorageProvider, IFileSystemProvider, AuditLogTypeInfo, AuthorizationInfo, TransactionGroupBase, EntitySaveOptions, RunReportParams, DatasetItemFilterType, DatasetResultType, DatasetStatusResultType, EntityRecordNameInput, EntityRecordNameResult, IRunReportProvider, RunReportResult, RecordDependency, RecordMergeRequest, RecordMergeResult, EntityDependency, RunQueryResult, RunQueryParams, PotentialDuplicateRequest, PotentialDuplicateResponse, CompositeKey, EntityDeleteOptions, EntityMergeOptions, DatasetItemResultType, DatabaseProviderBase, QueryInfo, RunViewWithCacheCheckParams, RunViewsWithCacheCheckResponse, RunViewWithCacheCheckResult, RunQueryWithCacheCheckParams, RunQueriesWithCacheCheckResponse, RunQueryWithCacheCheckResult } from '@memberjunction/core';
-import { MJAuditLogEntity, MJEntityAIActionEntity, MJQueryEntity, MJRecordMergeLogEntity, MJUserViewEntityExtended } from '@memberjunction/core-entities';
+import { BaseEntity, IEntityDataProvider, IMetadataProvider, EntityInfo, EntityFieldInfo, ProviderType, UserInfo, ILocalStorageProvider, IFileSystemProvider, TransactionGroupBase, EntitySaveOptions, IRunReportProvider, EntityDependency, RunQueryResult, RunQueryParams, CompositeKey, BaseEntityResult, SaveSQLResult, DeleteSQLResult, QueryInfo, RunViewWithCacheCheckParams, RunQueryWithCacheCheckParams } from '@memberjunction/core';
+import { EntityAIActionParams } from '@memberjunction/aiengine';
+import { GenericDatabaseProvider, ExecuteSQLBatchOptions } from '@memberjunction/generic-database-provider';
 import sql from 'mssql';
 import { Observable } from 'rxjs';
-import { ExecuteSQLOptions, ExecuteSQLBatchOptions, SQLServerProviderConfigData, SqlLoggingOptions, SqlLoggingSession } from './types.js';
-import { ActionResult } from '@memberjunction/actions-base';
-/**
- * Represents a single field change in the DiffObjects comparison result
- */
-export type FieldChange = {
-    field: string;
-    oldValue: any;
-    newValue: any;
-};
+import { ExecuteSQLOptions, SQLServerProviderConfigData } from './types.js';
 /**
  * SQL Server implementation of the MemberJunction data provider interfaces.
  *
@@ -48,7 +40,15 @@ export type FieldChange = {
  * await provider.Config();
  * ```
  */
-export declare class SQLServerDataProvider extends DatabaseProviderBase implements IEntityDataProvider, IMetadataProvider, IRunReportProvider {
+export declare class SQLServerDataProvider extends GenericDatabaseProvider implements IEntityDataProvider, IMetadataProvider, IRunReportProvider {
+    /**************************************************************************/
+    /**************************************************************************/
+    QuoteIdentifier(name: string): string;
+    QuoteSchemaAndView(schemaName: string, objectName: string): string;
+    private static readonly _sqlServerUUIDPattern;
+    private static readonly _sqlServerDefaultPattern;
+    protected get UUIDFunctionPattern(): RegExp;
+    protected get DBDefaultFunctionPattern(): RegExp;
     private _pool;
     private _transaction;
     private _transactionDepth;
@@ -61,8 +61,6 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
     private _recordDupeDetector;
     private _needsDatetimeOffsetAdjustment;
     private _datetimeOffsetTestComplete;
-    private static _sqlLoggingSessionsKey;
-    private get _sqlLoggingSessions();
     private _sqlQueue$;
     private _queueSubscription;
     private _transactionState$;
@@ -135,105 +133,12 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      * Gets the MemberJunction core schema name (defaults to __mj if not configured)
      */
     get MJCoreSchemaName(): string;
-    /**************************************************************************/
-    /**************************************************************************/
-    /**
-     * 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'
-     * });
-     * ```
-     */
-    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<{
-        id: string;
-        filePath: string;
-        startTime: Date;
-        statementCount: number;
-        options: SqlLoggingOptions;
-    }>;
-    /**
-     * Gets a specific SQL logging session by its ID.
-     * Returns the session if found, or undefined if not found.
-     *
-     * @param sessionId - The unique identifier of the session to retrieve
-     * @returns The SqlLoggingSession if found, undefined otherwise
-     */
-    GetSqlLoggingSessionById(sessionId: string): SqlLoggingSession | undefined;
-    /**
-     * Disposes all active SQL logging sessions.
-     * Useful for cleanup on provider shutdown.
-     */
-    DisposeAllSqlLoggingSessions(): Promise<void>;
     /**
      * Dispose of this provider instance and clean up resources.
      * This should be called when the provider is no longer needed.
      */
     Dispose(): Promise<void>;
-    /**
-     * 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
-     */
-    private _logSqlStatement;
-    /**
-     * 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 LogSQLStatement(query: string, parameters?: any, description?: string, isMutation?: boolean, simpleSQLFallback?: string, contextUser?: UserInfo): Promise<void>;
-    /**************************************************************************/
-    /**************************************************************************/
-    /**************************************************************************/
-    /**************************************************************************/
-    RunReport(params: RunReportParams, contextUser?: UserInfo): Promise<RunReportResult>;
-    /**************************************************************************/
-    /**************************************************************************/
-    /**
-     * Resolves a hierarchical category path (e.g., "/MJ/AI/Agents/") to a CategoryID.
-     * The path is split by "/" and each segment is matched case-insensitively against
-     * category names, walking down the hierarchy from root to leaf.
-     *
-     * @param categoryPath The hierarchical category path (e.g., "/MJ/AI/Agents/")
-     * @returns The CategoryID if the path exists, null otherwise
-     */
-    private resolveCategoryPath;
     /**
      * Finds a query by ID or by Name+Category combination.
      * Supports both direct CategoryID lookup and hierarchical CategoryPath path resolution.
@@ -246,15 +151,6 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      * @returns The found QueryInfo or null if not found
      */
     protected findQuery(QueryID: string, QueryName: string, CategoryID: string, CategoryPath: string, refreshMetadataIfNotFound?: boolean): Promise<QueryInfo | null>;
-    /**
-     * Looks up a query from QueryEngine's auto-refreshed cache by ID, name, and optional category filters.
-     */
-    protected findQueryInEngine(QueryID: string, QueryName: string, CategoryID: string, CategoryPath: string): MJQueryEntity | null;
-    /**
-     * Creates a fresh QueryInfo from a MJQueryEntity and patches the ProviderBase in-memory cache.
-     * This avoids stale data without requiring a full metadata reload.
-     */
-    protected refreshQueryInfoFromEntity(entity: MJQueryEntity): QueryInfo;
     /**************************************************************************/
     /**************************************************************************/
     protected InternalRunQuery(params: RunQueryParams, contextUser?: UserInfo): Promise<RunQueryResult>;
@@ -308,19 +204,6 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      * @returns Array of query results
      */
     protected InternalRunQueries(params: RunQueryParams[], contextUser?: UserInfo): Promise<RunQueryResult[]>;
-    /**
-     * RunQueriesWithCacheCheck - Smart cache validation for batch RunQueries.
-     * For each query request, if cacheStatus is provided, uses the Query's CacheValidationSQL
-     * to check if the cached data is still current by comparing MAX(__mj_UpdatedAt) and COUNT(*)
-     * with client's values. Returns 'current' if cache is valid (no data), or 'stale' with fresh data.
-     *
-     * Queries without CacheValidationSQL configured will return 'no_validation' status with full data.
-     */
-    RunQueriesWithCacheCheck<T = unknown>(params: RunQueryWithCacheCheckParams[], contextUser?: UserInfo): Promise<RunQueriesWithCacheCheckResponse<T>>;
-    /**
-     * Resolves QueryInfo from RunQueryParams (by ID or Name+CategoryPath).
-     */
-    protected resolveQueryInfo(params: RunQueryParams): QueryInfo | undefined;
     /**
      * Executes a batched cache status check for multiple queries using their CacheValidationSQL.
      */
@@ -334,34 +217,13 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
         rowCount?: number;
         errorMessage?: string;
     }>>;
-    /**
-     * Runs the full query and returns results with cache metadata.
-     */
-    protected runFullQueryAndReturnForQuery<T = unknown>(params: RunQueryParams, queryIndex: number, status: 'stale' | 'no_validation', contextUser?: UserInfo, queryId?: string): Promise<RunQueryWithCacheCheckResult<T>>;
     /**************************************************************************/
     /**************************************************************************/
-    /**
-     * This method will check to see if the where clause for the view provided has any templating within it, and if it does
-     * will replace the templating with the appropriate run-time values. This is done recursively with depth-first traversal
-     * so that if there are nested templates, they will be replaced as well. We also maintain a stack to ensure that any
-     * possible circular references are caught and an error is thrown if that is the case.
-     * @param viewEntity
-     * @param user
-     */
-    protected RenderViewWhereClause(viewEntity: MJUserViewEntityExtended, user: UserInfo, stack?: string[]): Promise<string>;
     /**************************************************************************/
     /**************************************************************************/
-    protected InternalRunView<T = any>(params: RunViewParams, contextUser?: UserInfo): Promise<RunViewResult<T>>;
-    protected InternalRunViews<T = any>(params: RunViewParams[], contextUser?: UserInfo): Promise<RunViewResult<T>[]>;
-    /**
-     * RunViewsWithCacheCheck - Smart cache validation for batch RunViews.
-     * For each view request, if cacheStatus is provided, first checks if the cache is current
-     * by comparing MAX(__mj_UpdatedAt) and COUNT(*) with client's values.
-     * Returns 'current' if cache is valid (no data), or 'stale' with fresh data if cache is outdated.
-     *
-     * Optimized to batch all cache status checks into a single SQL call with multiple result sets.
-     */
-    RunViewsWithCacheCheck<T = unknown>(params: RunViewWithCacheCheckParams[], contextUser?: UserInfo): Promise<RunViewsWithCacheCheckResponse<T>>;
+    protected BuildTopClause(maxRows: number): string;
+    protected BuildPaginationSQL(maxRows: number, startRow: number): string;
+    protected BuildParameterPlaceholder(index: number): string;
     /**
      * Executes a batched cache status check for multiple views in a single SQL call.
      * Uses multiple result sets to return status for each view efficiently.
@@ -377,124 +239,15 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
         rowCount?: number;
         errorMessage?: string;
     }>>;
-    /**
-     * Builds the WHERE clause for cache status check, using same logic as InternalRunView.
-     */
-    protected buildWhereClauseForCacheCheck(params: RunViewParams, entityInfo: EntityInfo, user: UserInfo): Promise<string>;
-    /**
-     * Compares client cache status with server status to determine if cache is current.
-     */
-    protected isCacheCurrent(clientStatus: {
-        maxUpdatedAt: string;
-        rowCount: number;
-    }, serverStatus: {
-        maxUpdatedAt?: string;
-        rowCount?: number;
-    }): boolean;
-    /**
-     * Runs the full query and returns results with cache metadata.
-     */
-    protected runFullQueryAndReturn<T = unknown>(params: RunViewParams, viewIndex: number, contextUser?: UserInfo): Promise<RunViewWithCacheCheckResult<T>>;
-    /**
-     * Extracts the maximum __mj_UpdatedAt value from a result set.
-     * @param results - Array of result objects that may contain __mj_UpdatedAt
-     * @returns ISO string of the max timestamp, or current time if none found
-     */
-    protected extractMaxUpdatedAt(results: unknown[]): string;
-    /**
-     * Gets the IDs of records that have been deleted since a given timestamp.
-     * Uses the RecordChange table which tracks all deletions for entities with TrackRecordChanges enabled.
-     * @param entityID - The entity ID to check deletions for
-     * @param sinceTimestamp - ISO timestamp to check deletions since
-     * @param contextUser - Optional user context for permissions
-     * @returns Array of record IDs (in CompositeKey concatenated string format)
-     */
-    protected getDeletedRecordIDsSince(entityID: string, sinceTimestamp: string, contextUser?: UserInfo): Promise<string[]>;
-    /**
-     * Gets rows that have been created or updated since a given timestamp.
-     * @param params - RunView parameters (used for entity, filter, etc.)
-     * @param entityInfo - Entity metadata
-     * @param sinceTimestamp - ISO timestamp to check updates since
-     * @param whereSQL - Pre-built WHERE clause from the original query
-     * @param contextUser - Optional user context for permissions
-     * @returns Array of updated/created rows
-     */
-    protected getUpdatedRowsSince<T = unknown>(params: RunViewParams, entityInfo: EntityInfo, sinceTimestamp: string, whereSQL: string, contextUser?: UserInfo): Promise<T[]>;
-    /**
-     * Runs a differential query and returns only changes since the client's cached state.
-     * This includes updated/created rows and deleted record IDs.
-     *
-     * Validates that the differential can be safely applied by checking for "hidden" deletes
-     * (rows deleted outside of MJ's RecordChanges tracking, e.g., direct SQL deletes).
-     * If hidden deletes are detected, falls back to a full query with 'stale' status.
-     *
-     * @param params - RunView parameters
-     * @param entityInfo - Entity metadata
-     * @param clientMaxUpdatedAt - Client's cached maxUpdatedAt timestamp
-     * @param clientRowCount - Client's cached row count
-     * @param serverStatus - Current server status (for new row count)
-     * @param whereSQL - Pre-built WHERE clause
-     * @param viewIndex - Index for correlation in batch operations
-     * @param contextUser - Optional user context
-     * @returns RunViewWithCacheCheckResult with differential data, or falls back to full query if unsafe
-     */
-    protected runDifferentialQueryAndReturn<T = unknown>(params: RunViewParams, entityInfo: EntityInfo, clientMaxUpdatedAt: string, clientRowCount: number, serverStatus: {
-        maxUpdatedAt?: string;
-        rowCount?: number;
-    }, whereSQL: string, viewIndex: number, contextUser?: UserInfo): Promise<RunViewWithCacheCheckResult<T>>;
-    protected validateUserProvidedSQLClause(clause: string): boolean;
-    /**
-     * Validates and builds an aggregate SQL query from the provided aggregate expressions.
-     * Uses the SQLExpressionValidator to ensure expressions are safe from SQL injection.
-     *
-     * @param aggregates - Array of aggregate expressions to validate and build
-     * @param entityInfo - Entity metadata for field reference validation
-     * @param schemaName - Schema name for the table
-     * @param baseView - Base view name for the table
-     * @param whereSQL - WHERE clause to apply (without the WHERE keyword)
-     * @returns Object with aggregateSQL string and any validation errors
-     */
-    protected buildAggregateSQL(aggregates: {
-        expression: string;
-        alias?: string;
-    }[], entityInfo: EntityInfo, schemaName: string, baseView: string, whereSQL: string): {
-        aggregateSQL: string | null;
-        validationErrors: AggregateResult[];
-    };
-    /**
-     * Executes the aggregate query and maps results back to the original expressions.
-     *
-     * @param aggregateSQL - The aggregate SQL query to execute
-     * @param aggregates - Original aggregate expressions (for result mapping)
-     * @param validationErrors - Any validation errors from buildAggregateSQL
-     * @param contextUser - User context for query execution
-     * @returns Array of AggregateResult objects
-     */
-    protected executeAggregateQuery(aggregateSQL: string | null, aggregates: {
-        expression: string;
-        alias?: string;
-    }[], validationErrors: AggregateResult[], contextUser?: UserInfo): Promise<{
-        results: AggregateResult[];
-        executionTime: number;
-    }>;
-    protected getRunTimeViewFieldString(params: RunViewParams, viewEntity: MJUserViewEntityExtended): string;
-    protected getRunTimeViewFieldArray(params: RunViewParams, viewEntity: MJUserViewEntityExtended): EntityFieldInfo[];
     protected executeSQLForUserViewRunLogging(viewId: number, entityBaseView: string, whereSQL: string, orderBySQL: string, user: UserInfo): Promise<{
         executeViewSQL: string;
         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, saveOptions: EntitySaveOptions): Promise<MJAuditLogEntity>;
-    protected CheckUserReadPermissions(entityName: string, contextUser: UserInfo): void;
     /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
     get ProviderType(): ProviderType;
-    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, 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
@@ -502,22 +255,9 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      * @param entityName
      * @param compositeKey
      */
-    protected GetSoftLinkDependencySQL(entityName: string, compositeKey: CompositeKey): string;
-    protected GetHardLinkDependencySQL(entityDependencies: EntityDependency[], compositeKey: CompositeKey): string;
-    /**
-     * Returns a list of dependencies - records that are linked to the specified Entity/RecordID combination. A dependency is as defined by the relationships in the database. The MemberJunction metadata that is used
-     * for this simply reflects the foreign key relationships that exist in the database. The CodeGen tool is what detects all of the relationships and generates the metadata that is used by MemberJunction. The metadata in question
-     * is within the EntityField table and specifically the RelatedEntity and RelatedEntityField columns. In turn, this method uses that metadata and queries the database to determine the dependencies. To get the list of entity dependencies
-     * you can use the utility method GetEntityDependencies(), which doesn't check for dependencies on a specific record, but rather gets the metadata in one shot that can be used for dependency checking.
-     * @param entityName the name of the entity to check
-     * @param KeyValuePairs the primary key(s) to check - only send multiple if you have an entity with a composite primary key
-     */
-    GetRecordDependencies(entityName: string, compositeKey: CompositeKey, contextUser?: UserInfo): Promise<RecordDependency[]>;
+    protected BuildSoftLinkDependencySQL(entityName: string, compositeKey: CompositeKey): string;
+    protected BuildHardLinkDependencySQL(entityDependencies: EntityDependency[], compositeKey: CompositeKey): string;
     protected GetRecordDependencyLinkSQL(dep: EntityDependency, entity: EntityInfo, relatedEntity: EntityInfo, CompositeKey: CompositeKey): string;
-    GetRecordDuplicates(params: PotentialDuplicateRequest, contextUser?: UserInfo): Promise<PotentialDuplicateResponse>;
-    MergeRecords(request: RecordMergeRequest, contextUser?: UserInfo, options?: EntityMergeOptions): Promise<RecordMergeResult>;
-    protected StartMergeLogging(request: RecordMergeRequest, result: RecordMergeResult, contextUser: UserInfo): Promise<MJRecordMergeLogEntity>;
-    protected CompleteMergeLogging(recordMergeLog: MJRecordMergeLogEntity, result: RecordMergeResult, contextUser?: UserInfo): Promise<void>;
     /**
      * Generates the SQL Statement that will Save a record to the database.
      *
@@ -546,47 +286,11 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      */
     private GetSaveSQLWithDetails;
     /**
-     * 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
-     */
-    protected GetEntityAIActions(entityInfo: EntityInfo, before: boolean): MJEntityAIActionEntity[];
-    /**
-     * 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
-     */
-    protected HandleEntityActions(entity: BaseEntity, baseType: 'save' | 'delete' | 'validate', before: boolean, user: UserInfo): Promise<ActionResult[]>;
-    /**
-     * Handles Entity AI Actions. Parameters are setup for a future support of delete actions, but currently that isn't supported so the baseType parameter
-     * isn't fully functional. If you pass in delete, the function will just exit for now, and in the future calling code will start working when we support
-     * Delete as a trigger event for Entity AI Actions...
-     * @param entity
-     * @param baseType
-     * @param before
-     * @param user
-     */
-    protected HandleEntityAIActions(entity: BaseEntity, baseType: 'save' | 'delete', before: boolean, user: UserInfo): Promise<void>;
-    Save(entity: BaseEntity, user: UserInfo, options: EntitySaveOptions): Promise<{}>;
-    protected MapTransactionResultToNewValues(transactionResult: Record<string, any>): {
-        FieldName: string;
-        Value: any;
-    }[];
-    /**
-     * Returns the stored procedure name to use for the given entity based on if it is a new record or an existing record.
-     * @param entity
-     * @param bNewRecord
-     * @returns
+     * Override to defer AI action tasks when a transaction is active.
+     * When inside a transaction, tasks are queued to _deferredTasks and
+     * processed after transaction commit (see processDeferredTasks).
      */
-    GetCreateUpdateSPName(entity: BaseEntity, bNewRecord: boolean): string;
+    protected EnqueueAfterSaveAIAction(params: EntityAIActionParams, user: UserInfo): void;
     private getAllEntityColumnsSQL;
     /**
      * Generates the stored procedure parameters for a save operation.
@@ -624,85 +328,14 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      */
     protected packageSPParam(paramValue: any, quoteString: string, unicodePrefix: string): string;
     protected GetLogRecordChangeSQL(newData: any, oldData: any, entityName: string, recordID: any, entityInfo: EntityInfo, type: 'Create' | 'Update' | 'Delete', user: UserInfo, wrapRecordIdInQuotes: boolean): string;
-    protected LogRecordChange(newData: any, oldData: any, entityName: string, recordID: any, entityInfo: EntityInfo, type: 'Create' | 'Update' | 'Delete', user: UserInfo): Promise<any>;
-    /**
-     * This method will create a human-readable string that describes the changes object that was created using the DiffObjects() method
-     * @param changesObject JavaScript object that has properties for each changed field that in turn have field, oldValue and newValue as sub-properties
-     * @param maxValueLength If not specified, default value of 200 characters applies where any values after the maxValueLength is cut off. The actual values are stored in the ChangesJSON and FullRecordJSON in the RecordChange table, this is only for the human-display
-     * @param cutOffText If specified, and if maxValueLength applies to any of the values being included in the description, this cutOffText param will be appended to the end of the cut off string to indicate to the human reader that the value is partial.
-     * @returns
-     */
-    CreateUserDescriptionOfChanges(changesObject: any, maxValueLength?: number, cutOffText?: string): string;
-    protected trimString(value: any, maxLength: number, trailingChars: string): any;
     /**
-     * Recursively escapes quotes in all string properties of an object or array.
-     * This method traverses through nested objects and arrays, escaping the specified
-     * quote character in all string values to prevent SQL injection and syntax errors.
-     *
-     * @param obj - The object, array, or primitive value to process
-     * @param quoteToEscape - The quote character to escape (typically single quote "'")
-     * @returns A new object/array with all string values having quotes properly escaped.
-     *          Non-string values are preserved as-is.
-     *
-     * @example
-     * // Escaping single quotes in a nested object
-     * const input = {
-     *   name: "John's Company",
-     *   details: {
-     *     description: "It's the best",
-     *     tags: ["Won't fail", "Can't stop"]
-     *   }
-     * };
-     * const escaped = this.escapeQuotesInProperties(input, "'");
-     * // Result: {
-     * //   name: "John''s Company",
-     * //   details: {
-     * //     description: "It''s the best",
-     * //     tags: ["Won''t fail", "Can''t stop"]
-     * //   }
-     * // }
-     *
-     * @remarks
-     * This method is essential for preparing data to be embedded in SQL strings.
-     * It handles:
-     * - Nested objects of any depth
-     * - Arrays (including arrays of objects)
-     * - Mixed-type objects with strings, numbers, booleans, null values
-     * - Circular references are NOT handled and will cause stack overflow
-     */
-    protected escapeQuotesInProperties(obj: any, quoteToEscape: string): any;
-    /**
-     * Creates a changes object by comparing two javascript objects, identifying fields that have different values.
-     * Each property in the returned object represents a changed field, with the field name as the key.
-     *
-     * @param oldData - The original data object to compare from
-     * @param newData - The new data object to compare to
-     * @param entityInfo - Entity metadata used to validate fields and determine comparison logic
-     * @param quoteToEscape - The quote character to escape in string values (typically "'")
-     * @returns A Record mapping field names to FieldChange objects containing the field name, old value, and new value.
-     *          Returns null if either oldData or newData is null/undefined.
-     *          Only includes fields that have actually changed and are not read-only.
-     *
-     * @remarks
-     * - Read-only fields are never considered changed
-     * - null and undefined are treated as equivalent
-     * - Date fields are compared by timestamp
-     * - String and object values have quotes properly escaped for SQL
-     * - Objects/arrays are recursively escaped using escapeQuotesInProperties
-     *
-     * @example
-     * ```typescript
-     * const changes = provider.DiffObjects(
-     *   { name: "John's Co", revenue: 1000 },
-     *   { name: "John's Co", revenue: 2000 },
-     *   entityInfo,
-     *   "'"
-     * );
-     * // Returns: { revenue: { field: "revenue", oldValue: 1000, newValue: 2000 } }
-     * ```
+     * Implements the abstract BuildRecordChangeSQL from DatabaseProviderBase.
+     * Delegates to GetLogRecordChangeSQL for T-SQL generation.
      */
-    DiffObjects(oldData: any, newData: any, entityInfo: EntityInfo, quoteToEscape: string): Record<string, FieldChange> | null;
-    Load(entity: BaseEntity, CompositeKey: CompositeKey, EntityRelationshipsToLoad: string[], user: UserInfo): Promise<{}>;
+    protected BuildRecordChangeSQL(newData: Record<string, unknown> | null, oldData: Record<string, unknown> | null, entityName: string, recordID: string, entityInfo: EntityInfo, type: 'Create' | 'Update' | 'Delete', user: UserInfo): {
+        sql: string;
+        parameters?: unknown[];
+    } | null;
     /**
      * Generates the SQL statement for deleting an entity record
      *
@@ -717,54 +350,41 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      * @returns Object with fullSQL and simpleSQL properties
      */
     private GetDeleteSQLWithDetails;
-    Delete(entity: BaseEntity, options: EntityDeleteOptions, user: UserInfo): Promise<boolean>;
+    /**************************************************************************/
+    /**************************************************************************/
+    protected GenerateSaveSQL(entity: BaseEntity, isNew: boolean, user: UserInfo): Promise<SaveSQLResult>;
+    protected GenerateDeleteSQL(entity: BaseEntity, user: UserInfo): DeleteSQLResult;
+    protected OnSaveCompleted(entity: BaseEntity, saveSQLResult: SaveSQLResult, user: UserInfo, options: EntitySaveOptions): Promise<void>;
+    protected OnSuspendRefresh(): void;
+    protected OnResumeRefresh(): void;
+    protected GetTransactionExtraData(_entity: BaseEntity): Record<string, unknown>;
+    protected BuildSaveExecuteOptions(entity: BaseEntity, sqlDetails: SaveSQLResult): ExecuteSQLOptions;
+    protected BuildDeleteExecuteOptions(entity: BaseEntity, sqlDetails: DeleteSQLResult): ExecuteSQLOptions;
+    protected ValidateDeleteResult(entity: BaseEntity, rawResult: Record<string, unknown>[], entityResult: BaseEntityResult): boolean;
+    /**************************************************************************/
+    /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
     /**************************************************************************/
-    GetDatasetByName(datasetName: string, itemFilters?: DatasetItemFilterType[], contextUser?: UserInfo, providerToUse?: IMetadataProvider): Promise<DatasetResultType>;
-    /**
-     * 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
-     */
-    protected GetDatasetItemSQL(item: any, itemFilters: any, datasetName: string): string | null;
-    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.
-     * @param item
-     * @param datasetName
-     * @returns
+     * Public backward-compatible wrapper that delegates to PostProcessRows (inherited from GenericDP).
+     * Used by SQLServerTransactionGroup which needs a public entry point for row processing.
+     *
+     * PostProcessRows (GenericDP) handles: AdjustDatetimeFields → encryption decryption.
      */
-    protected GetColumnsForDatasetItem(item: any, datasetName: string): string;
-    GetDatasetStatusByName(datasetName: string, itemFilters?: DatasetItemFilterType[], contextUser?: UserInfo, providerToUse?: IMetadataProvider): 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[]>;
+    ProcessEntityRows(rows: Record<string, unknown>[], entityInfo: EntityInfo, contextUser?: UserInfo): Promise<Record<string, unknown>[]>;
     /**
-     * Processes entity rows returned from SQL Server to handle:
-     * 1. Timezone conversions for datetime fields
-     * 2. Field-level decryption for encrypted fields
-     *
-     * This method specifically handles the conversion of datetime2 fields (which SQL Server returns without timezone info)
-     * to proper UTC dates, preventing JavaScript from incorrectly interpreting them as local time.
-     *
-     * For encrypted fields, this method decrypts values at the data provider level.
-     * API-level filtering (AllowDecryptInAPI/SendEncryptedValue) is handled by the GraphQL layer.
+     * SQL Server-specific datetime field adjustments.
      *
-     * @param rows The raw result rows from SQL Server
-     * @param entityInfo The entity metadata to determine field types
-     * @param contextUser Optional user context for decryption operations
-     * @returns The processed rows with corrected datetime values and decrypted fields
+     * SQL Server's `datetime2` and `datetime` types store values without timezone info.
+     * The mssql driver creates Date objects using local timezone interpretation, which is
+     * incorrect when the server stores UTC. This method adjusts dates back to UTC.
      *
-     * @security Encrypted fields are decrypted here for internal use.
-     *           The API layer handles response filtering based on AllowDecryptInAPI settings.
+     * For `datetimeoffset`, the driver sometimes mishandles timezone info (detected via
+     * `NeedsDatetimeOffsetAdjustment()`), requiring similar correction.
      */
-    ProcessEntityRows(rows: any[], entityInfo: EntityInfo, contextUser?: UserInfo): Promise<any[]>;
+    protected AdjustDatetimeFields(rows: Record<string, unknown>[], datetimeFields: EntityFieldInfo[], entityInfo: EntityInfo): Promise<Record<string, unknown>[]>;
     /**
      * 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.
@@ -898,38 +518,12 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      * @param txn The sql.Transaction object returned from BeginISATransaction()
      */
     RollbackISATransaction(txn: unknown): Promise<void>;
-    /**
-     * Discovers which IS-A child entity, if any, has a record with the given primary key.
-     * Executes a single UNION ALL query across all child entity tables for maximum efficiency.
-     * Each branch of the UNION is a PK lookup on a clustered index — effectively instant.
-     *
-     * @param entityInfo The parent entity whose children to search
-     * @param recordPKValue The primary key value to find in child tables
-     * @param contextUser Optional context user for audit/permission purposes
-     * @returns The child entity name if found, or null if no child record exists
-     */
-    FindISAChildEntity(entityInfo: EntityInfo, recordPKValue: string, contextUser?: UserInfo): Promise<{
-        ChildEntityName: string;
-    } | null>;
-    /**
-     * Discovers ALL IS-A child entities that have records with the given primary key.
-     * Used for overlapping subtype parents (AllowMultipleSubtypes = true) where multiple
-     * children can coexist. Same UNION ALL query as FindISAChildEntity, but returns all matches.
-     *
-     * @param entityInfo The parent entity whose children to search
-     * @param recordPKValue The primary key value to find in child tables
-     * @param contextUser Optional context user for audit/permission purposes
-     * @returns Array of child entity names found (empty if none)
-     */
-    FindISAChildEntities(entityInfo: EntityInfo, recordPKValue: string, contextUser?: UserInfo): Promise<{
-        ChildEntityName: string;
-    }[]>;
     /**
      * Builds a UNION ALL query that checks each child entity's base table for a record
      * with the given primary key. Returns the first match (disjoint subtypes guarantee
      * at most one result) unless used with overlapping subtypes.
      */
-    private buildChildDiscoverySQL;
+    protected BuildChildDiscoverySQL(childEntities: EntityInfo[], recordPKValue: string): string;
     /**************************************************************************
      * IS-A Overlapping Subtype — Record Change Propagation
      *
@@ -951,24 +545,12 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
      *        Undefined when saving the parent directly — all children get propagated to.
      * @param transaction The active IS-A transaction, or undefined for standalone saves
      */
-    private PropagateRecordChangesToSiblings;
-    /**
-     * Checks whether a given entity matches the target name, or is an ancestor
-     * of the target (i.e., the target is somewhere in its descendant sub-tree).
-     * Used to identify and skip the active branch during sibling propagation.
-     */
-    private isEntityOrAncestorOf;
-    /**
-     * Recursively enumerates an entity's entire sub-tree from metadata.
-     * No DB queries — uses EntityInfo.ChildEntities which is populated from metadata.
-     */
-    private getFullSubTree;
     /**
-     * Generates a single block of SQL for one sibling entity in the Record Change
+     * Generates a single block of T-SQL for one sibling entity in the Record Change
      * propagation batch. Uses SELECT...FOR JSON to get the full record, then
-     * conditionally inserts a Record Change entry if the record exists.
+     * conditionally inserts a Record Change entry via spCreateRecordChange_Internal.
      */
-    private buildSiblingRecordChangeSQL;
+    protected BuildSiblingRecordChangeSQL(varName: string, entityInfo: EntityInfo, safeChangesJSON: string, safeChangesDesc: string, safePKValue: string, safeUserId: string): string;
     BeginTransaction(): Promise<void>;
     CommitTransaction(): Promise<void>;
     RollbackTransaction(): Promise<void>;
@@ -986,9 +568,6 @@ export declare class SQLServerDataProvider extends DatabaseProviderBase implemen
     private processDeferredTasks;
     get LocalStorageProvider(): ILocalStorageProvider;
     get FileSystemProvider(): IFileSystemProvider;
-    protected InternalGetEntityRecordNames(info: EntityRecordNameInput[], contextUser?: UserInfo): Promise<EntityRecordNameResult[]>;
-    protected InternalGetEntityRecordName(entityName: string, CompositeKey: CompositeKey, contextUser?: UserInfo): Promise<string>;
-    protected GetEntityRecordNameSQL(entityName: string, CompositeKey: CompositeKey): string;
     CreateTransactionGroup(): Promise<TransactionGroupBase>;
     /**************************************************************************/
     /**************************************************************************/