snow-flow 3.0.9 → 3.0.10

package/dist/api/transaction-manager.js

@@ -1,576 +0,0 @@
-"use strict";
-/**
- * Transaction Management for Multi-Step Flow Creation
- * Provides ACID-like properties for complex flow operations
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionManager = exports.TransactionExecutionState = void 0;
-const logger_js_1 = require("../utils/logger.js");
-var TransactionExecutionState;
-(function (TransactionExecutionState) {
-    TransactionExecutionState["PENDING"] = "pending";
-    TransactionExecutionState["RUNNING"] = "running";
-    TransactionExecutionState["COMPLETED"] = "completed";
-    TransactionExecutionState["FAILED"] = "failed";
-    TransactionExecutionState["COMPENSATING"] = "compensating";
-    TransactionExecutionState["COMPENSATED"] = "compensated";
-    TransactionExecutionState["TIMEOUT"] = "timeout";
-})(TransactionExecutionState || (exports.TransactionExecutionState = TransactionExecutionState = {}));
-class TransactionManager {
-    constructor(client, errorHandler) {
-        this.activeTransactions = new Map();
-        this.sagaLog = new Map();
-        this.client = client;
-        this.errorHandler = errorHandler;
-        this.logger = new logger_js_1.Logger('TransactionManager');
-        this.lockManager = new SimpleLockManager();
-    }
-    /**
-     * Execute a transaction with ACID properties
-     */
-    async executeTransaction(definition) {
-        const execution = {
-            id: definition.id,
-            definition,
-            state: TransactionExecutionState.PENDING,
-            start_time: new Date(),
-            completed_steps: [],
-            failed_steps: [],
-            results: new Map(),
-            errors: new Map(),
-            compensations: [],
-            locks: new Set()
-        };
-        this.activeTransactions.set(definition.id, execution);
-        try {
-            // Initialize saga log
-            this.sagaLog.set(definition.id, []);
-            // Start transaction
-            await this.startTransaction(execution);
-            // Execute steps
-            const result = await this.executeSteps(execution);
-            if (result.success) {
-                await this.commitTransaction(execution);
-                return {
-                    success: true,
-                    transaction_id: execution.id,
-                    results: execution.results
-                };
-            }
-            else {
-                await this.rollbackTransaction(execution);
-                return {
-                    success: false,
-                    transaction_id: execution.id,
-                    errors: Array.from(execution.errors.values()),
-                    compensation_applied: true
-                };
-            }
-        }
-        catch (error) {
-            this.logger.error('Transaction execution failed', { transactionId: definition.id, error });
-            await this.rollbackTransaction(execution);
-            return {
-                success: false,
-                transaction_id: execution.id,
-                errors: [error instanceof Error ? error : new Error(String(error))],
-                compensation_applied: true
-            };
-        }
-        finally {
-            this.activeTransactions.delete(definition.id);
-        }
-    }
-    /**
-     * Execute a saga pattern transaction
-     */
-    async executeSaga(definition) {
-        const execution = {
-            id: definition.id,
-            definition,
-            state: TransactionExecutionState.PENDING,
-            start_time: new Date(),
-            completed_steps: [],
-            failed_steps: [],
-            results: new Map(),
-            errors: new Map(),
-            compensations: [],
-            locks: new Set()
-        };
-        this.activeTransactions.set(definition.id, execution);
-        try {
-            execution.state = TransactionExecutionState.RUNNING;
-            // Execute steps with saga pattern
-            for (const step of definition.steps) {
-                try {
-                    const stepResult = await this.executeStep(execution, step);
-                    execution.results.set(step.id, stepResult);
-                    execution.completed_steps.push(step.id);
-                    // Log successful step for saga
-                    this.logSagaStep(execution.id, step, stepResult);
-                }
-                catch (error) {
-                    execution.errors.set(step.id, error instanceof Error ? error : new Error(String(error)));
-                    execution.failed_steps.push(step.id);
-                    // If step failed, compensate previous steps
-                    await this.compensateSteps(execution);
-                    return {
-                        success: false,
-                        transaction_id: execution.id,
-                        compensations_applied: execution.compensations
-                    };
-                }
-            }
-            execution.state = TransactionExecutionState.COMPLETED;
-            execution.end_time = new Date();
-            return {
-                success: true,
-                transaction_id: execution.id,
-                results: execution.results
-            };
-        }
-        catch (error) {
-            execution.state = TransactionExecutionState.FAILED;
-            execution.end_time = new Date();
-            await this.compensateSteps(execution);
-            return {
-                success: false,
-                transaction_id: execution.id,
-                compensations_applied: execution.compensations
-            };
-        }
-        finally {
-            this.activeTransactions.delete(definition.id);
-            this.sagaLog.delete(definition.id);
-        }
-    }
-    /**
-     * Create a distributed transaction across multiple ServiceNow instances
-     */
-    async executeDistributedTransaction(definition, participants) {
-        const transactionId = definition.id;
-        const participantResults = new Map();
-        const failedParticipants = [];
-        try {
-            // Phase 1: Prepare all participants
-            const prepareResults = await Promise.allSettled(participants.map(participant => this.prepareParticipant(participant, definition)));
-            // Check if all participants are prepared
-            const allPrepared = prepareResults.every(result => result.status === 'fulfilled');
-            if (!allPrepared) {
-                // Abort transaction - some participants failed to prepare
-                await this.abortDistributedTransaction(transactionId, participants);
-                prepareResults.forEach((result, index) => {
-                    if (result.status === 'rejected') {
-                        failedParticipants.push(participants[index]);
-                    }
-                });
-                return {
-                    success: false,
-                    transaction_id: transactionId,
-                    failed_participants: failedParticipants
-                };
-            }
-            // Phase 2: Commit all participants
-            const commitResults = await Promise.allSettled(participants.map(participant => this.commitParticipant(participant, transactionId)));
-            // Check if all participants committed successfully
-            const allCommitted = commitResults.every(result => result.status === 'fulfilled');
-            if (!allCommitted) {
-                // Some participants failed to commit - this is a critical situation
-                this.logger.error('Distributed transaction commit failed', {
-                    transactionId,
-                    failedParticipants: commitResults
-                        .map((result, index) => result.status === 'rejected' ? participants[index] : null)
-                        .filter(Boolean)
-                });
-                // Attempt to rollback successful commits
-                await this.rollbackDistributedTransaction(transactionId, participants);
-            }
-            commitResults.forEach((result, index) => {
-                if (result.status === 'fulfilled') {
-                    participantResults.set(participants[index], result.value);
-                }
-                else {
-                    failedParticipants.push(participants[index]);
-                }
-            });
-            return {
-                success: allCommitted,
-                transaction_id: transactionId,
-                participant_results: participantResults,
-                failed_participants: failedParticipants.length > 0 ? failedParticipants : undefined
-            };
-        }
-        catch (error) {
-            this.logger.error('Distributed transaction failed', { transactionId, error });
-            await this.abortDistributedTransaction(transactionId, participants);
-            return {
-                success: false,
-                transaction_id: transactionId,
-                failed_participants: participants
-            };
-        }
-    }
-    /**
-     * Start transaction with isolation
-     */
-    async startTransaction(execution) {
-        execution.state = TransactionExecutionState.RUNNING;
-        this.logger.info('Starting transaction', { transactionId: execution.id });
-        // Acquire locks based on isolation level
-        await this.acquireLocks(execution);
-        // Start ServiceNow transaction tracking
-        const transactionId = this.errorHandler.startTransaction(execution.definition.name);
-        execution.id = transactionId;
-    }
-    /**
-     * Execute all steps in the transaction
-     */
-    async executeSteps(execution) {
-        const steps = this.orderStepsByDependencies(execution.definition.steps);
-        for (const step of steps) {
-            execution.current_step = step.id;
-            try {
-                // Check timeout
-                if (this.isTransactionTimeout(execution)) {
-                    execution.state = TransactionExecutionState.TIMEOUT;
-                    throw new Error('Transaction timeout');
-                }
-                // Execute step with retry
-                const result = await this.executeStepWithRetry(execution, step);
-                execution.results.set(step.id, result);
-                execution.completed_steps.push(step.id);
-                // Add to rollback stack
-                this.errorHandler.addOperation(execution.id, {
-                    type: step.operation,
-                    table: step.table,
-                    record_id: result?.sys_id,
-                    original_data: step.operation === 'update' ? step.data : undefined,
-                    new_data: result,
-                    dependencies: step.dependencies
-                });
-            }
-            catch (error) {
-                execution.errors.set(step.id, error instanceof Error ? error : new Error(String(error)));
-                execution.failed_steps.push(step.id);
-                if (step.critical || execution.definition.rollback_on_error) {
-                    return { success: false };
-                }
-                // Continue with non-critical steps
-                this.logger.warn('Non-critical step failed, continuing', { stepId: step.id, error });
-            }
-        }
-        return { success: execution.failed_steps.length === 0 };
-    }
-    /**
-     * Execute a single step with retry logic
-     */
-    async executeStepWithRetry(execution, step) {
-        const retryPolicy = execution.definition.retry_policy;
-        let lastError = null;
-        let delay = retryPolicy.initial_delay;
-        for (let attempt = 1; attempt <= retryPolicy.max_attempts; attempt++) {
-            try {
-                return await this.executeStep(execution, step);
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                // Check if error is retryable
-                const isRetryable = retryPolicy.retryable_errors.some(retryableError => lastError.message.toLowerCase().includes(retryableError.toLowerCase()));
-                if (!isRetryable || attempt === retryPolicy.max_attempts) {
-                    throw lastError;
-                }
-                // Wait before retry
-                await new Promise(resolve => setTimeout(resolve, delay));
-                delay = Math.min(delay * retryPolicy.backoff_multiplier, retryPolicy.max_delay);
-            }
-        }
-        throw lastError;
-    }
-    /**
-     * Execute a single step
-     */
-    async executeStep(execution, step) {
-        this.logger.debug('Executing step', { transactionId: execution.id, stepId: step.id });
-        // Check dependencies
-        for (const dependency of step.dependencies) {
-            if (!execution.completed_steps.includes(dependency)) {
-                throw new Error(`Dependency ${dependency} not completed`);
-            }
-        }
-        // Execute based on operation type
-        switch (step.operation) {
-            case 'create':
-                return await this.client.createRecord(step.table, step.data);
-            case 'update':
-                if (!step.data?.sys_id) {
-                    throw new Error('sys_id required for update operation');
-                }
-                return await this.client.updateRecord(step.table, step.data.sys_id, step.data);
-            case 'delete':
-                if (!step.data?.sys_id) {
-                    throw new Error('sys_id required for delete operation');
-                }
-                return await this.client.deleteRecord(step.table, step.data.sys_id);
-            case 'validate':
-                return await this.validateData(step.table, step.data, step.condition);
-            case 'custom':
-                if (step.data?.custom_function) {
-                    return await step.data.custom_function();
-                }
-                throw new Error('Custom function not provided');
-            default:
-                throw new Error(`Unknown operation: ${step.operation}`);
-        }
-    }
-    /**
-     * Commit transaction
-     */
-    async commitTransaction(execution) {
-        execution.state = TransactionExecutionState.COMPLETED;
-        execution.end_time = new Date();
-        // Commit ServiceNow transaction
-        await this.errorHandler.commitTransaction(execution.id);
-        // Release locks
-        await this.releaseLocks(execution);
-        this.logger.info('Transaction committed', { transactionId: execution.id });
-    }
-    /**
-     * Rollback transaction
-     */
-    async rollbackTransaction(execution) {
-        execution.state = TransactionExecutionState.COMPENSATING;
-        try {
-            // Rollback ServiceNow transaction
-            await this.errorHandler.rollbackTransaction(execution.id);
-            // Apply compensations
-            await this.compensateSteps(execution);
-            execution.state = TransactionExecutionState.COMPENSATED;
-        }
-        catch (error) {
-            execution.state = TransactionExecutionState.FAILED;
-            this.logger.error('Transaction rollback failed', { transactionId: execution.id, error });
-        }
-        finally {
-            // Always release locks
-            await this.releaseLocks(execution);
-            execution.end_time = new Date();
-        }
-    }
-    /**
-     * Apply compensations for completed steps
-     */
-    async compensateSteps(execution) {
-        const completedSteps = execution.definition.steps.filter(step => execution.completed_steps.includes(step.id));
-        // Apply compensations in reverse order
-        for (const step of completedSteps.reverse()) {
-            if (step.compensation) {
-                try {
-                    await this.applyCompensation(execution, step.compensation);
-                    execution.compensations.push(step.compensation);
-                }
-                catch (error) {
-                    this.logger.error('Compensation failed', { stepId: step.id, error });
-                }
-            }
-        }
-    }
-    /**
-     * Apply a compensation action
-     */
-    async applyCompensation(execution, compensation) {
-        switch (compensation.type) {
-            case 'delete':
-                const result = execution.results.get(compensation.table);
-                if (result?.sys_id) {
-                    await this.client.deleteRecord(compensation.table, result.sys_id);
-                }
-                break;
-            case 'update':
-                if (compensation.data?.sys_id) {
-                    await this.client.updateRecord(compensation.table, compensation.data.sys_id, compensation.data);
-                }
-                break;
-            case 'restore':
-                if (compensation.data) {
-                    await this.client.createRecord(compensation.table, compensation.data);
-                }
-                break;
-            case 'custom':
-                if (compensation.custom_function) {
-                    await compensation.custom_function();
-                }
-                break;
-        }
-    }
-    /**
-     * Acquire locks for transaction isolation
-     */
-    async acquireLocks(execution) {
-        const resourcesToLock = new Set();
-        // Collect resources to lock
-        for (const step of execution.definition.steps) {
-            if (step.operation === 'update' || step.operation === 'delete') {
-                resourcesToLock.add(`${step.table}:${step.data?.sys_id}`);
-            }
-            else if (step.operation === 'create') {
-                resourcesToLock.add(`${step.table}:create`);
-            }
-        }
-        // Acquire locks
-        for (const resource of resourcesToLock) {
-            try {
-                const lockId = await this.lockManager.acquire(resource, execution.definition.timeout);
-                execution.locks.add(lockId);
-            }
-            catch (error) {
-                // Release already acquired locks
-                await this.releaseLocks(execution);
-                throw new Error(`Failed to acquire lock for ${resource}: ${error}`);
-            }
-        }
-    }
-    /**
-     * Release all locks
-     */
-    async releaseLocks(execution) {
-        for (const lockId of execution.locks) {
-            try {
-                await this.lockManager.release(lockId);
-            }
-            catch (error) {
-                this.logger.warn('Failed to release lock', { lockId, error });
-            }
-        }
-        execution.locks.clear();
-    }
-    /**
-     * Order steps by dependencies
-     */
-    orderStepsByDependencies(steps) {
-        const ordered = [];
-        const remaining = [...steps];
-        while (remaining.length > 0) {
-            const nextSteps = remaining.filter(step => step.dependencies.every(dep => ordered.some(orderedStep => orderedStep.id === dep)));
-            if (nextSteps.length === 0) {
-                throw new Error('Circular dependency detected in transaction steps');
-            }
-            ordered.push(...nextSteps);
-            remaining.splice(0, remaining.length, ...remaining.filter(step => !nextSteps.includes(step)));
-        }
-        return ordered;
-    }
-    /**
-     * Check if transaction has timed out
-     */
-    isTransactionTimeout(execution) {
-        const elapsed = Date.now() - execution.start_time.getTime();
-        return elapsed > execution.definition.timeout;
-    }
-    /**
-     * Validate data against condition
-     */
-    async validateData(table, data, condition) {
-        if (!condition)
-            return true;
-        // Simple validation logic - could be enhanced with more complex rules
-        const record = await this.client.getRecord(table, data.sys_id);
-        return record !== null;
-    }
-    /**
-     * Log saga step
-     */
-    logSagaStep(transactionId, step, result) {
-        const sagaLog = this.sagaLog.get(transactionId) || [];
-        sagaLog.push({
-            step_id: step.id,
-            operation: step.operation,
-            table: step.table,
-            result: result,
-            timestamp: new Date()
-        });
-        this.sagaLog.set(transactionId, sagaLog);
-    }
-    /**
-     * Prepare participant for distributed transaction
-     */
-    async prepareParticipant(participant, definition) {
-        // Implementation would send prepare request to participant
-        // For now, return success
-        return { prepared: true, participant };
-    }
-    /**
-     * Commit participant in distributed transaction
-     */
-    async commitParticipant(participant, transactionId) {
-        // Implementation would send commit request to participant
-        return { committed: true, participant };
-    }
-    /**
-     * Abort distributed transaction
-     */
-    async abortDistributedTransaction(transactionId, participants) {
-        // Implementation would send abort request to all participants
-        this.logger.info('Aborting distributed transaction', { transactionId, participants });
-    }
-    /**
-     * Rollback distributed transaction
-     */
-    async rollbackDistributedTransaction(transactionId, participants) {
-        // Implementation would send rollback request to all participants
-        this.logger.info('Rolling back distributed transaction', { transactionId, participants });
-    }
-    /**
-     * Get transaction status
-     */
-    getTransactionStatus(transactionId) {
-        return this.activeTransactions.get(transactionId) || null;
-    }
-    /**
-     * Get all active transactions
-     */
-    getActiveTransactions() {
-        return Array.from(this.activeTransactions.values());
-    }
-}
-exports.TransactionManager = TransactionManager;
-/**
- * Simple lock manager implementation
- */
-class SimpleLockManager {
-    constructor() {
-        this.locks = new Map();
-    }
-    async acquire(resource, timeout) {
-        const lockId = `lock_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        const startTime = Date.now();
-        while (Date.now() - startTime < timeout) {
-            if (!this.locks.has(resource)) {
-                this.locks.set(resource, {
-                    lockId,
-                    owner: 'transaction_manager',
-                    timestamp: new Date()
-                });
-                return lockId;
-            }
-            // Wait before retry
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        throw new Error(`Failed to acquire lock for ${resource}: timeout`);
-    }
-    async release(lockId) {
-        for (const [resource, lock] of this.locks) {
-            if (lock.lockId === lockId) {
-                this.locks.delete(resource);
-                return;
-            }
-        }
-    }
-    isLocked(resource) {
-        return this.locks.has(resource);
-    }
-    getLockOwner(resource) {
-        const lock = this.locks.get(resource);
-        return lock ? lock.owner : null;
-    }
-}
-//# sourceMappingURL=transaction-manager.js.map