snow-flow 1.3.0 → 1.3.2

package/dist/api/error-handling.js

@@ -447,12 +447,594 @@ class FlowErrorHandler {
         }
     }
     /**
-     * Retry original operation
+     * Retry original operation with exponential backoff
      */
     async retryOriginalOperation(error) {
-        // This would contain the logic to retry the original operation
-        // Implementation depends on the specific operation being retried
-        throw new Error('Retry logic not implemented for this operation');
+        const maxRetries = error.max_retries || 3;
+        const currentRetryCount = error.retry_count || 0;
+        this.logger.info(`Attempting retry ${currentRetryCount + 1}/${maxRetries} for operation`, {
+            operation: error.context.operation,
+            error_type: error.type,
+            previous_attempts: currentRetryCount
+        });
+        // Check if we've exceeded max retries
+        if (currentRetryCount >= maxRetries) {
+            this.logger.error('Maximum retry attempts exceeded', {
+                operation: error.context.operation,
+                total_attempts: currentRetryCount,
+                final_error: error.message
+            });
+            return {
+                success: false,
+                final_state: null,
+                retry_exhausted: true,
+                total_attempts: currentRetryCount,
+                last_error: error.message,
+                suggested_actions: [
+                    'Review the operation configuration',
+                    'Check ServiceNow system status',
+                    'Contact administrator for manual intervention',
+                    'Consider alternative approach'
+                ]
+            };
+        }
+        // Calculate retry delay using exponential backoff
+        const baseDelay = this.retryDelays[Math.min(currentRetryCount, this.retryDelays.length - 1)];
+        const jitterDelay = baseDelay + Math.random() * 1000; // Add jitter to prevent thundering herd
+        this.logger.info(`Waiting ${Math.round(jitterDelay)}ms before retry attempt`, {
+            retry_count: currentRetryCount + 1,
+            base_delay: baseDelay,
+            actual_delay: Math.round(jitterDelay)
+        });
+        // Wait before retry
+        await this.delay(jitterDelay);
+        try {
+            // Determine retry strategy based on error type
+            const retryResult = await this.executeRetryBasedOnErrorType(error);
+            if (retryResult.success) {
+                this.logger.info('Retry attempt successful', {
+                    operation: error.context.operation,
+                    retry_count: currentRetryCount + 1,
+                    success_after_attempts: currentRetryCount + 1
+                });
+                return {
+                    success: true,
+                    final_state: retryResult.data,
+                    retry_count: currentRetryCount + 1,
+                    recovery_method: 'retry_with_backoff'
+                };
+            }
+            else {
+                // Update error with new retry count and continue retry cycle
+                const updatedError = {
+                    ...error,
+                    retry_count: currentRetryCount + 1,
+                    message: retryResult.error || error.message
+                };
+                // Recursively retry if not at max attempts
+                return await this.retryOriginalOperation(updatedError);
+            }
+        }
+        catch (retryError) {
+            this.logger.error('Error during retry attempt', {
+                retry_count: currentRetryCount + 1,
+                error: retryError instanceof Error ? retryError.message : String(retryError)
+            });
+            // Create updated error for next retry or final failure
+            const updatedError = {
+                ...error,
+                retry_count: currentRetryCount + 1,
+                message: retryError instanceof Error ? retryError.message : String(retryError),
+                original_error: retryError instanceof Error ? retryError : new Error(String(retryError))
+            };
+            // Continue retry cycle
+            return await this.retryOriginalOperation(updatedError);
+        }
+    }
+    /**
+     * Execute retry based on specific error type
+     */
+    async executeRetryBasedOnErrorType(error) {
+        try {
+            switch (error.type) {
+                case ErrorType.AUTHENTICATION_ERROR:
+                    return await this.retryAuthenticationOperation(error);
+                case ErrorType.NETWORK_ERROR:
+                case ErrorType.TIMEOUT_ERROR:
+                    return await this.retryNetworkOperation(error);
+                case ErrorType.RATE_LIMIT_ERROR:
+                    return await this.retryRateLimitedOperation(error);
+                case ErrorType.SERVICE_UNAVAILABLE:
+                    return await this.retryServiceUnavailableOperation(error);
+                case ErrorType.API_ERROR:
+                    return await this.retryAPIOperation(error);
+                case ErrorType.CONFLICT_ERROR:
+                    return await this.retryConflictOperation(error);
+                case ErrorType.RESOURCE_NOT_FOUND:
+                    return await this.retryResourceOperation(error);
+                default:
+                    return await this.retryGenericOperation(error);
+            }
+        }
+        catch (executeError) {
+            return {
+                success: false,
+                error: executeError instanceof Error ? executeError.message : String(executeError)
+            };
+        }
+    }
+    /**
+     * Retry authentication operations
+     */
+    async retryAuthenticationOperation(error) {
+        try {
+            this.logger.info('Retrying authentication operation');
+            // Try to refresh authentication
+            const credentials = this.client.credentialsInstance;
+            if (credentials?.refreshToken) {
+                // Attempt token refresh
+                const refreshResult = await this.client.oauth?.refreshAccessToken();
+                if (refreshResult?.success) {
+                    // Retry the original operation with new token
+                    return await this.retryWithNewAuthentication(error);
+                }
+            }
+            return {
+                success: false,
+                error: 'Authentication refresh failed - manual re-authentication required'
+            };
+        }
+        catch (authError) {
+            return {
+                success: false,
+                error: authError instanceof Error ? authError.message : String(authError)
+            };
+        }
+    }
+    /**
+     * Retry network operations
+     */
+    async retryNetworkOperation(error) {
+        try {
+            this.logger.info('Retrying network operation');
+            // For network errors, simply retry the original request
+            return await this.executeOriginalOperation(error);
+        }
+        catch (networkError) {
+            return {
+                success: false,
+                error: networkError instanceof Error ? networkError.message : String(networkError)
+            };
+        }
+    }
+    /**
+     * Retry rate limited operations with longer delay
+     */
+    async retryRateLimitedOperation(error) {
+        try {
+            this.logger.info('Retrying rate limited operation with extended delay');
+            // Rate limit errors need longer delays
+            const rateLimitDelay = 30000 + Math.random() * 10000; // 30-40 seconds
+            await this.delay(rateLimitDelay);
+            return await this.executeOriginalOperation(error);
+        }
+        catch (rateLimitError) {
+            return {
+                success: false,
+                error: rateLimitError instanceof Error ? rateLimitError.message : String(rateLimitError)
+            };
+        }
+    }
+    /**
+     * Retry service unavailable operations
+     */
+    async retryServiceUnavailableOperation(error) {
+        try {
+            this.logger.info('Retrying operation after service unavailability');
+            // Check service health before retry
+            const healthCheck = await this.performServiceHealthCheck();
+            if (!healthCheck.healthy) {
+                return {
+                    success: false,
+                    error: `Service still unavailable: ${healthCheck.reason}`
+                };
+            }
+            return await this.executeOriginalOperation(error);
+        }
+        catch (serviceError) {
+            return {
+                success: false,
+                error: serviceError instanceof Error ? serviceError.message : String(serviceError)
+            };
+        }
+    }
+    /**
+     * Retry API operations
+     */
+    async retryAPIOperation(error) {
+        try {
+            this.logger.info('Retrying API operation');
+            // API errors might be transient, retry with same parameters
+            return await this.executeOriginalOperation(error);
+        }
+        catch (apiError) {
+            return {
+                success: false,
+                error: apiError instanceof Error ? apiError.message : String(apiError)
+            };
+        }
+    }
+    /**
+     * Retry conflict operations with modified data
+     */
+    async retryConflictOperation(error) {
+        try {
+            this.logger.info('Retrying conflict operation with modifications');
+            // For conflicts, try to modify the operation slightly
+            const modifiedOperation = await this.modifyOperationForConflictResolution(error);
+            return await this.executeModifiedOperation(error, modifiedOperation);
+        }
+        catch (conflictError) {
+            return {
+                success: false,
+                error: conflictError instanceof Error ? conflictError.message : String(conflictError)
+            };
+        }
+    }
+    /**
+     * Retry resource operations
+     */
+    async retryResourceOperation(error) {
+        try {
+            this.logger.info('Retrying resource operation');
+            // For resource not found, try to create the resource first
+            const resourceCreated = await this.ensureResourceExists(error);
+            if (resourceCreated.success) {
+                return await this.executeOriginalOperation(error);
+            }
+            return {
+                success: false,
+                error: `Failed to create required resource: ${resourceCreated.error}`
+            };
+        }
+        catch (resourceError) {
+            return {
+                success: false,
+                error: resourceError instanceof Error ? resourceError.message : String(resourceError)
+            };
+        }
+    }
+    /**
+     * Generic retry operation
+     */
+    async retryGenericOperation(error) {
+        try {
+            this.logger.info('Performing generic retry operation');
+            // Generic retry - just execute the original operation again
+            return await this.executeOriginalOperation(error);
+        }
+        catch (genericError) {
+            return {
+                success: false,
+                error: genericError instanceof Error ? genericError.message : String(genericError)
+            };
+        }
+    }
+    /**
+     * Execute the original operation that failed
+     */
+    async executeOriginalOperation(error) {
+        try {
+            // This would reconstruct and execute the original operation
+            // For now, we'll simulate the operation based on context
+            const operation = error.context.operation;
+            const operationType = this.extractOperationType(operation);
+            switch (operationType) {
+                case 'deploy':
+                    return await this.retryDeployOperation(error);
+                case 'search':
+                    return await this.retrySearchOperation(error);
+                case 'create':
+                    return await this.retryCreateOperation(error);
+                case 'update':
+                    return await this.retryUpdateOperation(error);
+                default:
+                    // Generic HTTP request retry
+                    return await this.retryHTTPRequest(error);
+            }
+        }
+        catch (executeError) {
+            return {
+                success: false,
+                error: executeError instanceof Error ? executeError.message : String(executeError)
+            };
+        }
+    }
+    // Helper methods for specific operation types
+    async retryDeployOperation(error) {
+        try {
+            this.logger.info('Retrying deployment operation', {
+                component_type: error.context.component_type,
+                component_id: error.context.component_id
+            });
+            // Extract deployment parameters from context
+            const deploymentData = error.context.user_input;
+            if (!deploymentData) {
+                return { success: false, error: 'No deployment data available for retry' };
+            }
+            // Retry based on component type
+            switch (error.context.component_type) {
+                case 'widget':
+                    return await this.retryWidgetDeployment(deploymentData, error);
+                case 'flow':
+                    return await this.retryFlowDeployment(deploymentData, error);
+                case 'application':
+                    return await this.retryApplicationDeployment(deploymentData, error);
+                case 'script':
+                    return await this.retryScriptDeployment(deploymentData, error);
+                default:
+                    return await this.retryGenericDeployment(deploymentData, error);
+            }
+        }
+        catch (deployError) {
+            return {
+                success: false,
+                error: deployError instanceof Error ? deployError.message : String(deployError)
+            };
+        }
+    }
+    async retrySearchOperation(error) {
+        try {
+            this.logger.info('Retrying search operation', { operation: error.context.operation });
+            const searchParams = error.context.user_input;
+            if (!searchParams) {
+                return { success: false, error: 'No search parameters available for retry' };
+            }
+            // Modify search parameters if this is a retry to avoid same failure
+            const modifiedParams = {
+                ...searchParams,
+                sysparm_limit: Math.min(searchParams.sysparm_limit || 100, 50), // Reduce limit
+                sysparm_offset: searchParams.sysparm_offset || 0,
+                retry_attempt: (error.retry_count || 0) + 1
+            };
+            // Perform the search request
+            const result = await this.client.makeRequest({
+                method: 'GET',
+                endpoint: searchParams.endpoint || '/api/now/table/sys_metadata',
+                params: modifiedParams
+            });
+            if (result.status === 200) {
+                return { success: true, data: result.data };
+            }
+            else {
+                return { success: false, error: `Search failed with status: ${result.status}` };
+            }
+        }
+        catch (searchError) {
+            return {
+                success: false,
+                error: searchError instanceof Error ? searchError.message : String(searchError)
+            };
+        }
+    }
+    async retryCreateOperation(error) {
+        try {
+            this.logger.info('Retrying create operation', {
+                table: error.context.component_type,
+                retry_count: error.retry_count
+            });
+            const createData = error.context.user_input;
+            if (!createData || !createData.table) {
+                return { success: false, error: 'No create data or table specified for retry' };
+            }
+            // Modify data for conflict resolution if needed
+            let retryData = { ...createData.data };
+            // If this is a conflict retry, modify unique fields
+            if (error.type === ErrorType.CONFLICT_ERROR && error.retry_count > 0) {
+                const timestamp = Date.now();
+                if (retryData.name) {
+                    retryData.name = `${retryData.name}_retry_${timestamp}`;
+                }
+                if (retryData.sys_name) {
+                    retryData.sys_name = `${retryData.sys_name}_retry_${timestamp}`;
+                }
+            }
+            // Perform the create request
+            const result = await this.client.createRecord(createData.table, retryData);
+            if (result && result.sys_id) {
+                this.logger.info('Create operation retry successful', { sys_id: result.sys_id });
+                return { success: true, data: result };
+            }
+            else {
+                return { success: false, error: 'Create operation failed - no sys_id returned' };
+            }
+        }
+        catch (createError) {
+            return {
+                success: false,
+                error: createError instanceof Error ? createError.message : String(createError)
+            };
+        }
+    }
+    async retryUpdateOperation(error) {
+        try {
+            this.logger.info('Retrying update operation', {
+                table: error.context.component_type,
+                record_id: error.context.component_id
+            });
+            const updateData = error.context.user_input;
+            if (!updateData || !updateData.table || !updateData.record_id) {
+                return { success: false, error: 'No update data, table, or record ID available for retry' };
+            }
+            // First, verify the record still exists
+            try {
+                const existingRecord = await this.client.getRecord(updateData.table, updateData.record_id);
+                if (!existingRecord) {
+                    return { success: false, error: 'Record no longer exists for update' };
+                }
+            }
+            catch (getError) {
+                return { success: false, error: 'Cannot verify record existence for update retry' };
+            }
+            // Perform the update request
+            const result = await this.client.updateRecord(updateData.table, updateData.record_id, updateData.data);
+            if (result) {
+                this.logger.info('Update operation retry successful', { sys_id: updateData.record_id });
+                return { success: true, data: result };
+            }
+            else {
+                return { success: false, error: 'Update operation failed' };
+            }
+        }
+        catch (updateError) {
+            return {
+                success: false,
+                error: updateError instanceof Error ? updateError.message : String(updateError)
+            };
+        }
+    }
+    async retryHTTPRequest(error) {
+        try {
+            this.logger.info('Retrying HTTP request', { operation: error.context.operation });
+            const requestData = error.context.user_input;
+            if (!requestData) {
+                return { success: false, error: 'No request data available for HTTP retry' };
+            }
+            // Construct request with retry-safe parameters
+            const requestConfig = {
+                method: requestData.method || 'GET',
+                endpoint: requestData.endpoint || requestData.url,
+                params: requestData.params,
+                data: requestData.data,
+                timeout: Math.min((requestData.timeout || 30000) * 1.5, 60000), // Increase timeout
+                retry_attempt: (error.retry_count || 0) + 1
+            };
+            // Add retry headers
+            const headers = {
+                ...requestData.headers,
+                'X-Retry-Attempt': String(requestConfig.retry_attempt),
+                'X-Request-ID': `retry_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+            };
+            const result = await this.client.makeRequest({
+                ...requestConfig,
+                headers
+            });
+            if (result.status >= 200 && result.status < 300) {
+                return { success: true, data: result.data };
+            }
+            else {
+                return {
+                    success: false,
+                    error: `HTTP request failed with status: ${result.status} - ${result.statusText}`
+                };
+            }
+        }
+        catch (httpError) {
+            return {
+                success: false,
+                error: httpError instanceof Error ? httpError.message : String(httpError)
+            };
+        }
+    }
+    // Additional helper methods
+    async retryWithNewAuthentication(error) {
+        // Retry with refreshed authentication
+        return await this.executeOriginalOperation(error);
+    }
+    async performServiceHealthCheck() {
+        try {
+            // Basic health check - try to access ServiceNow instance
+            const response = await this.client.makeRequest({
+                method: 'GET',
+                endpoint: '/api/now/v2/table/sys_user',
+                params: { sysparm_limit: 1 }
+            });
+            return { healthy: response.status === 200 };
+        }
+        catch (healthError) {
+            return {
+                healthy: false,
+                reason: healthError instanceof Error ? healthError.message : 'Unknown health check error'
+            };
+        }
+    }
+    async modifyOperationForConflictResolution(error) {
+        // Modify operation to resolve conflicts (e.g., add timestamp to name)
+        const timestamp = Date.now();
+        return {
+            ...error.context.system_state,
+            name: `${error.context.system_state?.name || 'item'}_${timestamp}`,
+            modified_for_conflict: true
+        };
+    }
+    async executeModifiedOperation(error, modifiedData) {
+        try {
+            this.logger.info('Executing modified operation for conflict resolution', {
+                original_operation: error.context.operation,
+                modifications: modifiedData.modified_for_conflict ? 'conflict_resolution' : 'standard'
+            });
+            // Execute the operation with modified data based on operation type
+            const operationType = this.extractOperationType(error.context.operation);
+            switch (operationType) {
+                case 'create':
+                    const table = error.context.component_type || 'sys_metadata';
+                    const result = await this.client.createRecord(table, modifiedData);
+                    return { success: true, data: result };
+                case 'update':
+                    if (!error.context.component_id) {
+                        return { success: false, error: 'No component ID for update operation' };
+                    }
+                    const updateResult = await this.client.updateRecord(error.context.component_type || 'sys_metadata', error.context.component_id, modifiedData);
+                    return { success: true, data: updateResult };
+                case 'deploy':
+                    // For deployment operations, use the deployment data structure
+                    return await this.retryGenericDeployment(modifiedData, error);
+                default:
+                    return { success: false, error: 'Unsupported operation type for modification' };
+            }
+        }
+        catch (executeError) {
+            return {
+                success: false,
+                error: executeError instanceof Error ? executeError.message : String(executeError)
+            };
+        }
+    }
+    async ensureResourceExists(error) {
+        try {
+            this.logger.info('Attempting to create missing resource', {
+                resource_type: error.context.component_type,
+                resource_id: error.context.component_id
+            });
+            // Extract resource information from context
+            const resourceData = error.context.user_input;
+            if (!resourceData) {
+                return { success: false, error: 'No resource data available for creation' };
+            }
+            // Determine resource type and create accordingly
+            switch (error.context.component_type) {
+                case 'table':
+                    return await this.createMissingTable(resourceData);
+                case 'field':
+                    return await this.createMissingField(resourceData);
+                case 'user':
+                    return await this.createMissingUser(resourceData);
+                case 'group':
+                    return await this.createMissingGroup(resourceData);
+                default:
+                    // Generic resource creation
+                    return await this.createGenericResource(resourceData);
+            }
+        }
+        catch (resourceError) {
+            return {
+                success: false,
+                error: resourceError instanceof Error ? resourceError.message : String(resourceError)
+            };
+        }
+    }
+    async delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
     }
     /**
      * Create missing resource
@@ -589,5 +1171,317 @@ class FlowErrorHandler {
         return Array.from(this.transactions.values())
             .filter(t => t.status === 'active');
     }
+    // =====================================
+    // DEPLOYMENT RETRY METHODS
+    // =====================================
+    /**
+     * Retry widget deployment
+     */
+    async retryWidgetDeployment(deploymentData, error) {
+        try {
+            this.logger.info('Retrying widget deployment', { widget_name: deploymentData.name });
+            // Construct widget data with retry modifications
+            const widgetData = {
+                name: deploymentData.name,
+                title: deploymentData.title,
+                template: deploymentData.template,
+                server_script: deploymentData.server_script,
+                client_script: deploymentData.client_script,
+                css: deploymentData.css,
+                category: deploymentData.category || 'custom',
+                roles: deploymentData.roles || '',
+                public: deploymentData.public !== false
+            };
+            // If this is a conflict retry, modify the name
+            if (error.type === ErrorType.CONFLICT_ERROR && (error.retry_count || 0) > 0) {
+                widgetData.name = `${widgetData.name}_retry_${Date.now()}`;
+            }
+            const result = await this.client.createRecord('sp_widget', widgetData);
+            return { success: true, data: result };
+        }
+        catch (widgetError) {
+            return {
+                success: false,
+                error: widgetError instanceof Error ? widgetError.message : String(widgetError)
+            };
+        }
+    }
+    /**
+     * Retry flow deployment
+     */
+    async retryFlowDeployment(deploymentData, error) {
+        try {
+            this.logger.info('Retrying flow deployment', { flow_name: deploymentData.name });
+            const flowData = {
+                name: deploymentData.name,
+                description: deploymentData.description,
+                active: deploymentData.active !== false,
+                flow_designer: deploymentData.flow_definition || '{}',
+                trigger_conditions: deploymentData.trigger_conditions,
+                table: deploymentData.table
+            };
+            // Handle conflict retry
+            if (error.type === ErrorType.CONFLICT_ERROR && (error.retry_count || 0) > 0) {
+                flowData.name = `${flowData.name}_retry_${Date.now()}`;
+            }
+            const result = await this.client.createRecord('sys_hub_flow', flowData);
+            return { success: true, data: result };
+        }
+        catch (flowError) {
+            return {
+                success: false,
+                error: flowError instanceof Error ? flowError.message : String(flowError)
+            };
+        }
+    }
+    /**
+     * Retry application deployment
+     */
+    async retryApplicationDeployment(deploymentData, error) {
+        try {
+            this.logger.info('Retrying application deployment', { app_name: deploymentData.name });
+            const appData = {
+                name: deploymentData.name,
+                short_description: deploymentData.short_description,
+                description: deploymentData.description,
+                version: deploymentData.version || '1.0.0',
+                vendor: deploymentData.vendor || 'Custom',
+                vendor_prefix: deploymentData.vendor_prefix,
+                active: deploymentData.active !== false
+            };
+            // Handle conflict retry
+            if (error.type === ErrorType.CONFLICT_ERROR && (error.retry_count || 0) > 0) {
+                appData.name = `${appData.name}_retry_${Date.now()}`;
+            }
+            const result = await this.client.createRecord('sys_app', appData);
+            return { success: true, data: result };
+        }
+        catch (appError) {
+            return {
+                success: false,
+                error: appError instanceof Error ? appError.message : String(appError)
+            };
+        }
+    }
+    /**
+     * Retry script deployment
+     */
+    async retryScriptDeployment(deploymentData, error) {
+        try {
+            this.logger.info('Retrying script deployment', { script_name: deploymentData.name });
+            const scriptData = {
+                name: deploymentData.name,
+                script: deploymentData.script,
+                description: deploymentData.description,
+                api_name: deploymentData.api_name,
+                client_callable: deploymentData.client_callable || false,
+                active: deploymentData.active !== false
+            };
+            // Handle conflict retry
+            if (error.type === ErrorType.CONFLICT_ERROR && (error.retry_count || 0) > 0) {
+                scriptData.name = `${scriptData.name}_retry_${Date.now()}`;
+            }
+            const result = await this.client.createRecord('sys_script_include', scriptData);
+            return { success: true, data: result };
+        }
+        catch (scriptError) {
+            return {
+                success: false,
+                error: scriptError instanceof Error ? scriptError.message : String(scriptError)
+            };
+        }
+    }
+    /**
+     * Generic deployment retry
+     */
+    async retryGenericDeployment(deploymentData, error) {
+        try {
+            this.logger.info('Retrying generic deployment', {
+                component_type: error.context.component_type,
+                data_keys: Object.keys(deploymentData)
+            });
+            // Determine table from component type or data
+            const table = deploymentData.table ||
+                this.getTableFromComponentType(error.context.component_type) ||
+                'sys_metadata';
+            const result = await this.client.createRecord(table, deploymentData);
+            return { success: true, data: result };
+        }
+        catch (genericError) {
+            return {
+                success: false,
+                error: genericError instanceof Error ? genericError.message : String(genericError)
+            };
+        }
+    }
+    // =====================================
+    // RESOURCE CREATION METHODS
+    // =====================================
+    /**
+     * Create missing table
+     */
+    async createMissingTable(resourceData) {
+        try {
+            const tableData = {
+                name: resourceData.table_name || resourceData.name,
+                label: resourceData.label || resourceData.table_name,
+                super_class: resourceData.super_class || 'sys_metadata',
+                is_extendable: resourceData.is_extendable !== false
+            };
+            await this.client.createRecord('sys_db_object', tableData);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    /**
+     * Create missing field
+     */
+    async createMissingField(resourceData) {
+        try {
+            const fieldData = {
+                table: resourceData.table,
+                column_name: resourceData.field_name,
+                column_label: resourceData.label || resourceData.field_name,
+                internal_type: resourceData.type || 'string',
+                max_length: resourceData.max_length || 40
+            };
+            await this.client.createRecord('sys_dictionary', fieldData);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    /**
+     * Create missing user
+     */
+    async createMissingUser(resourceData) {
+        try {
+            const userData = {
+                user_name: resourceData.user_name,
+                first_name: resourceData.first_name || 'Unknown',
+                last_name: resourceData.last_name || 'User',
+                email: resourceData.email,
+                active: resourceData.active !== false
+            };
+            await this.client.createRecord('sys_user', userData);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    /**
+     * Create missing group
+     */
+    async createMissingGroup(resourceData) {
+        try {
+            const groupData = {
+                name: resourceData.group_name || resourceData.name,
+                description: resourceData.description || `Group ${resourceData.name}`,
+                active: resourceData.active !== false
+            };
+            await this.client.createRecord('sys_user_group', groupData);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    /**
+     * Create generic resource
+     */
+    async createGenericResource(resourceData) {
+        try {
+            const table = resourceData.table || 'sys_metadata';
+            await this.client.createRecord(table, resourceData);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    // =====================================
+    // UTILITY METHODS
+    // =====================================
+    /**
+     * Get ServiceNow table name from component type
+     */
+    getTableFromComponentType(componentType) {
+        if (!componentType)
+            return null;
+        const tableMap = {
+            'widget': 'sp_widget',
+            'flow': 'sys_hub_flow',
+            'application': 'sys_app',
+            'script': 'sys_script_include',
+            'business_rule': 'sys_script',
+            'client_script': 'sys_script_client',
+            'ui_policy': 'sys_ui_policy',
+            'ui_action': 'sys_ui_action',
+            'table': 'sys_db_object',
+            'field': 'sys_dictionary',
+            'user': 'sys_user',
+            'group': 'sys_user_group'
+        };
+        return tableMap[componentType.toLowerCase()] || null;
+    }
+    /**
+     * Enhanced operation type extraction
+     */
+    extractOperationType(operation) {
+        const op = operation.toLowerCase();
+        // More specific operation detection
+        if (op.includes('deploy') || op.includes('create_') || op.includes('snow_deploy'))
+            return 'deploy';
+        if (op.includes('search') || op.includes('find') || op.includes('query') || op.includes('discover'))
+            return 'search';
+        if (op.includes('create') || op.includes('insert') || op.includes('add'))
+            return 'create';
+        if (op.includes('update') || op.includes('modify') || op.includes('edit') || op.includes('patch'))
+            return 'update';
+        if (op.includes('delete') || op.includes('remove'))
+            return 'delete';
+        if (op.includes('get') || op.includes('fetch') || op.includes('retrieve'))
+            return 'read';
+        if (op.includes('authenticate') || op.includes('login') || op.includes('auth'))
+            return 'auth';
+        if (op.includes('http') || op.includes('request') || op.includes('api'))
+            return 'http';
+        return 'generic';
+    }
+    /**
+     * Check if error type is retryable
+     */
+    isRetryableError(errorType) {
+        const retryableErrors = [
+            ErrorType.NETWORK_ERROR,
+            ErrorType.TIMEOUT_ERROR,
+            ErrorType.RATE_LIMIT_ERROR,
+            ErrorType.SERVICE_UNAVAILABLE,
+            ErrorType.API_ERROR,
+            ErrorType.CONFLICT_ERROR
+        ];
+        return retryableErrors.includes(errorType);
+    }
+    /**
+     * Get circuit breaker status for operation
+     */
+    getCircuitBreakerStatus(operation) {
+        // Simple circuit breaker implementation
+        const recentErrors = this.errorHistory
+            .filter(error => error.context.operation === operation &&
+            error.context.timestamp.getTime() > Date.now() - 300000 // Last 5 minutes
+        );
+        const failureCount = recentErrors.length;
+        const isOpen = failureCount >= 5; // Open circuit after 5 failures
+        return {
+            isOpen,
+            failureCount,
+            lastFailureTime: recentErrors.length > 0 ? recentErrors[recentErrors.length - 1].context.timestamp : undefined
+        };
+    }
 }
 exports.FlowErrorHandler = FlowErrorHandler;