@bernierllc/retry-suite 0.1.0

package/dist/integrations/integration-manager.js

@@ -0,0 +1,108 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationManager = void 0;
+const slack_integration_1 = require("./slack-integration");
+const email_integration_1 = require("./email-integration");
+const webhook_integration_1 = require("./webhook-integration");
+class IntegrationManager {
+    constructor(config) {
+        this.integrations = new Map();
+        this.config = config;
+        this.setupIntegrations();
+    }
+    setupIntegrations() {
+        for (const integrationConfig of this.config) {
+            try {
+                const integration = this.createIntegration(integrationConfig);
+                this.integrations.set(integrationConfig.type, integration);
+            }
+            catch (error) {
+                console.error(`Failed to setup integration ${integrationConfig.type}:`, error);
+            }
+        }
+    }
+    createIntegration(config) {
+        switch (config.type) {
+            case 'slack':
+                return new slack_integration_1.SlackIntegration(config.config);
+            case 'email':
+                return new email_integration_1.EmailIntegration(config.config);
+            case 'webhook':
+                return new webhook_integration_1.WebhookIntegration(config.config);
+            case 'pagerduty':
+                // PagerDuty integration would be implemented similarly
+                throw new Error('PagerDuty integration not yet implemented');
+            default:
+                throw new Error(`Unknown integration type: ${config.type}`);
+        }
+    }
+    async sendAlert(alert) {
+        if (this.integrations.size === 0) {
+            console.log('No integrations configured, skipping alert:', alert.message);
+            return;
+        }
+        const promises = Array.from(this.integrations.values()).map(integration => integration.sendAlert(alert).catch(error => {
+            console.error(`Failed to send alert via ${integration.type}:`, error);
+        }));
+        await Promise.all(promises);
+    }
+    async sendCriticalAlert(alert) {
+        if (this.integrations.size === 0) {
+            console.error('CRITICAL ALERT - No integrations configured:', alert.message);
+            return;
+        }
+        const promises = Array.from(this.integrations.values()).map(integration => integration.sendCriticalAlert(alert).catch(error => {
+            console.error(`Failed to send critical alert via ${integration.type}:`, error);
+        }));
+        await Promise.all(promises);
+    }
+    getIntegrations() {
+        return Array.from(this.integrations.keys());
+    }
+    hasIntegration(type) {
+        return this.integrations.has(type);
+    }
+    async testIntegration(type) {
+        const integration = this.integrations.get(type);
+        if (!integration) {
+            return false;
+        }
+        try {
+            const testAlert = {
+                id: `test_${Date.now()}`,
+                type: 'info',
+                message: 'Test alert from Retry Suite',
+                severity: 'low',
+                timestamp: new Date(),
+                metadata: { test: true },
+                acknowledged: false
+            };
+            await integration.sendAlert(testAlert);
+            return true;
+        }
+        catch (error) {
+            console.error(`Integration test failed for ${type}:`, error);
+            return false;
+        }
+    }
+    async testAllIntegrations() {
+        const results = {};
+        for (const type of this.integrations.keys()) {
+            results[type] = await this.testIntegration(type);
+        }
+        return results;
+    }
+    updateConfiguration(config) {
+        this.config = config;
+        this.integrations.clear();
+        this.setupIntegrations();
+    }
+}
+exports.IntegrationManager = IntegrationManager;

package/dist/integrations/slack-integration.d.ts

@@ -0,0 +1,10 @@
+import { Alert, Integration, SlackConfig } from '../types';
+export declare class SlackIntegration implements Integration {
+    readonly type = "slack";
+    private config;
+    constructor(config: SlackConfig);
+    sendAlert(alert: Alert): Promise<void>;
+    sendCriticalAlert(alert: Alert): Promise<void>;
+    private getSeverityColor;
+    private sendToSlack;
+}

package/dist/integrations/slack-integration.js

@@ -0,0 +1,94 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackIntegration = void 0;
+class SlackIntegration {
+    constructor(config) {
+        this.type = 'slack';
+        this.config = config;
+    }
+    async sendAlert(alert) {
+        if (alert.severity === 'low') {
+            return;
+        }
+        const message = {
+            channel: this.config.channel,
+            text: `🚨 *${alert.message}*`,
+            attachments: [{
+                    color: this.getSeverityColor(alert.severity),
+                    fields: [
+                        { title: 'Type', value: alert.type, short: true },
+                        { title: 'Severity', value: alert.severity, short: true },
+                        { title: 'Time', value: alert.timestamp.toISOString(), short: true }
+                    ],
+                    footer: 'Retry Suite',
+                    ts: Math.floor(alert.timestamp.getTime() / 1000)
+                }]
+        };
+        await this.sendToSlack(message);
+    }
+    async sendCriticalAlert(alert) {
+        const channels = [this.config.channel];
+        if (this.config.criticalChannel) {
+            channels.push(this.config.criticalChannel);
+        }
+        for (const channel of channels) {
+            const message = {
+                channel,
+                text: `🚨🚨 *CRITICAL: ${alert.message}* 🚨🚨`,
+                attachments: [{
+                        color: 'danger',
+                        fields: [
+                            { title: 'Type', value: alert.type, short: true },
+                            { title: 'Severity', value: alert.severity, short: true },
+                            { title: 'Time', value: alert.timestamp.toISOString(), short: true },
+                            { title: 'Details', value: JSON.stringify(alert.metadata, null, 2) }
+                        ],
+                        footer: 'Retry Suite - CRITICAL ALERT',
+                        ts: Math.floor(alert.timestamp.getTime() / 1000)
+                    }]
+            };
+            await this.sendToSlack(message);
+        }
+    }
+    getSeverityColor(severity) {
+        switch (severity) {
+            case 'low': return '#36a64f';
+            case 'medium': return '#ffa500';
+            case 'high': return '#ff0000';
+            case 'critical': return '#8b0000';
+            default: return '#36a64f';
+        }
+    }
+    async sendToSlack(message) {
+        try {
+            const response = await fetch('https://slack.com/api/chat.postMessage', {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.config.token}`,
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(message)
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`Slack API error: ${response.status} - ${error}`);
+            }
+            const result = await response.json();
+            if (!result.ok) {
+                throw new Error(`Slack API error: ${result.error}`);
+            }
+        }
+        catch (error) {
+            console.error('Failed to send Slack message:', error);
+            throw error;
+        }
+    }
+}
+exports.SlackIntegration = SlackIntegration;

package/dist/integrations/webhook-integration.d.ts

@@ -0,0 +1,10 @@
+import { Alert, Integration, WebhookConfig } from '../types';
+export declare class WebhookIntegration implements Integration {
+    readonly type = "webhook";
+    private config;
+    constructor(config: WebhookConfig);
+    sendAlert(alert: Alert): Promise<void>;
+    sendCriticalAlert(alert: Alert): Promise<void>;
+    private sendWebhook;
+    testConnection(): Promise<boolean>;
+}

package/dist/integrations/webhook-integration.js

@@ -0,0 +1,82 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebhookIntegration = void 0;
+class WebhookIntegration {
+    constructor(config) {
+        this.type = 'webhook';
+        this.config = config;
+    }
+    async sendAlert(alert) {
+        const payload = {
+            type: 'alert',
+            alert,
+            timestamp: new Date().toISOString(),
+            source: 'retry-suite'
+        };
+        await this.sendWebhook(payload);
+    }
+    async sendCriticalAlert(alert) {
+        const payload = {
+            type: 'critical_alert',
+            alert,
+            timestamp: new Date().toISOString(),
+            source: 'retry-suite',
+            priority: 'critical'
+        };
+        await this.sendWebhook(payload);
+    }
+    async sendWebhook(payload) {
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+                'User-Agent': 'BernierLLC-RetrySuite/0.1.0',
+                ...this.config.headers
+            };
+            const controller = new AbortController();
+            const timeout = this.config.timeout || 10000;
+            const timeoutId = setTimeout(() => {
+                controller.abort();
+            }, timeout);
+            const response = await fetch(this.config.url, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(payload),
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Webhook request failed: ${response.status} - ${errorText}`);
+            }
+            console.log(`[WEBHOOK] Alert sent successfully to ${this.config.url}`);
+        }
+        catch (error) {
+            console.error(`[WEBHOOK] Failed to send webhook to ${this.config.url}:`, error);
+            throw error;
+        }
+    }
+    async testConnection() {
+        try {
+            const testPayload = {
+                type: 'test',
+                message: 'Test webhook from Retry Suite',
+                timestamp: new Date().toISOString(),
+                source: 'retry-suite'
+            };
+            await this.sendWebhook(testPayload);
+            return true;
+        }
+        catch (error) {
+            console.error('Webhook test failed:', error);
+            return false;
+        }
+    }
+}
+exports.WebhookIntegration = WebhookIntegration;

package/dist/retry-suite.d.ts

@@ -0,0 +1,34 @@
+import { RetrySuiteConfig, RetryOptions, RetryResult, RetryStatus, RetryMetrics, Alert, PerformanceReport, MetricsOptions, AlertOptions, ReportOptions, ScheduleResult, CancelResult, PauseResult, ResumeResult, ConfigResult, ValidationResult } from './types';
+export declare class RetrySuite {
+    private retryManager;
+    private adminServer;
+    private integrationManager;
+    private configManager;
+    private config;
+    private retryStates;
+    private metrics;
+    constructor(config: RetrySuiteConfig);
+    executeWithRetry<T>(id: string, fn: () => Promise<T>, options?: RetryOptions): Promise<RetryResult<T>>;
+    retryWithBackoff<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+    scheduleRetry(id: string, fn: () => Promise<any>, scheduleTime: Date): Promise<ScheduleResult>;
+    getRetryStatus(id: string): Promise<RetryStatus | null>;
+    cancelRetry(id: string): Promise<CancelResult>;
+    pauseRetry(id: string): Promise<PauseResult>;
+    resumeRetry(id: string): Promise<ResumeResult>;
+    getMetrics(options?: MetricsOptions): Promise<RetryMetrics>;
+    getAlerts(options?: AlertOptions): Promise<Alert[]>;
+    getPerformanceReport(options?: ReportOptions): Promise<PerformanceReport>;
+    updateConfiguration(config: Partial<RetrySuiteConfig>): Promise<ConfigResult>;
+    getConfiguration(): RetrySuiteConfig;
+    validateConfiguration(config: RetrySuiteConfig): ValidationResult;
+    startAdminServer(port?: number): Promise<void>;
+    stopAdminServer(): Promise<void>;
+    getAdminUrl(): string;
+    private generateRetryId;
+    private initializeMetrics;
+    private updateMetrics;
+    private sendFailureAlert;
+    private sendCriticalAlert;
+    private generateRecommendations;
+    private setupEventListeners;
+}

package/dist/retry-suite.js

@@ -0,0 +1,328 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetrySuite = void 0;
+// import { RetryManager } from '@bernierllc/retry-manager';
+// Mock RetryManager for now since the dependency may not be available
+class MockRetryManager {
+    constructor(config) {
+        this.config = config;
+    }
+    async executeWithRetry(id, fn, options) {
+        try {
+            const result = await fn();
+            return {
+                success: true,
+                result,
+                attempts: 1,
+                error: null
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                result: null,
+                attempts: options?.maxRetries || 3,
+                error
+            };
+        }
+    }
+    createInitialState(id, options) {
+        return {
+            id,
+            attempts: 0,
+            maxAttempts: options?.maxRetries || 3,
+            status: 'pending',
+            createdAt: new Date()
+        };
+    }
+}
+const RetryManager = MockRetryManager;
+const admin_server_1 = require("./admin/admin-server");
+const integration_manager_1 = require("./integrations/integration-manager");
+const configuration_manager_1 = require("./config/configuration-manager");
+class RetrySuite {
+    constructor(config) {
+        this.retryStates = new Map();
+        this.config = config;
+        this.configManager = new configuration_manager_1.ConfigurationManager(config);
+        this.retryManager = new MockRetryManager({
+            maxRetries: config.retryManager.defaultOptions.maxRetries,
+            baseDelay: config.retryManager.defaultOptions.initialDelayMs,
+            maxDelay: config.retryManager.defaultOptions.maxDelayMs,
+            backoffFactor: config.retryManager.defaultOptions.backoffFactor,
+            jitter: config.retryManager.defaultOptions.jitter
+        });
+        this.adminServer = new admin_server_1.AdminServer(config.admin, this);
+        this.integrationManager = new integration_manager_1.IntegrationManager(config.integrations);
+        this.metrics = this.initializeMetrics();
+        this.setupEventListeners();
+    }
+    async executeWithRetry(id, fn, options) {
+        const startTime = Date.now();
+        try {
+            const retryStatus = {
+                id,
+                status: 'running',
+                attempts: 0,
+                maxAttempts: options?.maxRetries || this.config.retryManager.defaultOptions.maxRetries,
+                lastAttempt: new Date(),
+                metadata: options?.metadata || {}
+            };
+            this.retryStates.set(id, retryStatus);
+            const result = await this.retryManager.executeWithRetry(id, fn, {
+                maxRetries: options?.maxRetries,
+                baseDelay: options?.initialDelayMs,
+                maxDelay: options?.maxDelayMs,
+                backoffFactor: options?.backoffFactor,
+                jitter: options?.jitter
+            });
+            const totalTime = Date.now() - startTime;
+            retryStatus.status = result.success ? 'completed' : 'failed';
+            retryStatus.attempts = result.attempts;
+            retryStatus.result = result.result;
+            retryStatus.error = result.error?.message;
+            this.updateMetrics(result, totalTime);
+            if (!result.success) {
+                await this.sendFailureAlert(id, result.error);
+            }
+            return {
+                success: result.success,
+                result: result.result,
+                error: result.error,
+                attempts: result.attempts,
+                totalTime
+            };
+        }
+        catch (error) {
+            await this.sendCriticalAlert(id, error);
+            throw error;
+        }
+    }
+    async retryWithBackoff(fn, options) {
+        const id = this.generateRetryId();
+        const result = await this.executeWithRetry(id, fn, options);
+        if (!result.success) {
+            throw result.error || new Error('Retry failed');
+        }
+        return result.result;
+    }
+    async scheduleRetry(id, fn, scheduleTime) {
+        const delay = scheduleTime.getTime() - Date.now();
+        if (delay <= 0) {
+            return {
+                success: false,
+                error: 'Schedule time must be in the future'
+            };
+        }
+        const scheduleId = `scheduled_${id}_${Date.now()}`;
+        setTimeout(async () => {
+            try {
+                await this.executeWithRetry(id, fn);
+            }
+            catch (error) {
+                console.error(`Scheduled retry ${id} failed:`, error);
+            }
+        }, delay);
+        return {
+            success: true,
+            scheduleId,
+            scheduledTime: scheduleTime
+        };
+    }
+    async getRetryStatus(id) {
+        return this.retryStates.get(id) || null;
+    }
+    async cancelRetry(id) {
+        const status = this.retryStates.get(id);
+        if (!status) {
+            return {
+                success: false,
+                message: `Retry ${id} not found`
+            };
+        }
+        if (status.status === 'completed' || status.status === 'failed') {
+            return {
+                success: false,
+                message: `Retry ${id} has already finished`
+            };
+        }
+        status.status = 'cancelled';
+        this.retryStates.set(id, status);
+        return {
+            success: true,
+            message: `Retry ${id} cancelled successfully`
+        };
+    }
+    async pauseRetry(id) {
+        const status = this.retryStates.get(id);
+        if (!status) {
+            return {
+                success: false,
+                message: `Retry ${id} not found`
+            };
+        }
+        if (status.status !== 'running') {
+            return {
+                success: false,
+                message: `Retry ${id} is not currently running`
+            };
+        }
+        status.status = 'paused';
+        this.retryStates.set(id, status);
+        return {
+            success: true,
+            message: `Retry ${id} paused successfully`
+        };
+    }
+    async resumeRetry(id) {
+        const status = this.retryStates.get(id);
+        if (!status) {
+            return {
+                success: false,
+                message: `Retry ${id} not found`
+            };
+        }
+        if (status.status !== 'paused') {
+            return {
+                success: false,
+                message: `Retry ${id} is not paused`
+            };
+        }
+        status.status = 'running';
+        this.retryStates.set(id, status);
+        return {
+            success: true,
+            message: `Retry ${id} resumed successfully`
+        };
+    }
+    async getMetrics(options) {
+        return { ...this.metrics };
+    }
+    async getAlerts(options) {
+        // For now, return empty array - would integrate with monitoring service
+        return [];
+    }
+    async getPerformanceReport(options) {
+        const metrics = await this.getMetrics();
+        const alerts = await this.getAlerts();
+        return {
+            period: {
+                startDate: options?.startDate || new Date(Date.now() - 24 * 60 * 60 * 1000),
+                endDate: options?.endDate || new Date()
+            },
+            summary: metrics,
+            trends: [],
+            recommendations: this.generateRecommendations(metrics),
+            alerts
+        };
+    }
+    async updateConfiguration(config) {
+        return this.configManager.updateConfiguration(config);
+    }
+    getConfiguration() {
+        return this.configManager.getConfiguration();
+    }
+    validateConfiguration(config) {
+        return this.configManager.validateConfiguration(config);
+    }
+    async startAdminServer(port) {
+        const serverPort = port || this.config.admin.port;
+        await this.adminServer.start(serverPort);
+    }
+    async stopAdminServer() {
+        await this.adminServer.stop();
+    }
+    getAdminUrl() {
+        return this.adminServer.getUrl();
+    }
+    generateRetryId() {
+        return `retry_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    initializeMetrics() {
+        return {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            averageRetryTime: 0,
+            retrySuccessRate: 0,
+            activeRetries: 0,
+            topFailureReasons: [],
+            performanceByHour: [],
+            storageUsage: {
+                totalEntries: 0,
+                sizeBytes: 0,
+                oldestEntry: new Date(),
+                newestEntry: new Date()
+            }
+        };
+    }
+    updateMetrics(result, totalTime) {
+        this.metrics.totalRetries += 1;
+        if (result.success) {
+            this.metrics.successfulRetries += 1;
+        }
+        else {
+            this.metrics.failedRetries += 1;
+        }
+        this.metrics.retrySuccessRate = (this.metrics.successfulRetries / this.metrics.totalRetries) * 100;
+        this.metrics.averageRetryTime = (this.metrics.averageRetryTime + totalTime) / 2;
+    }
+    async sendFailureAlert(id, error) {
+        const alert = {
+            id: `retry_failure_${id}`,
+            type: 'warning',
+            message: `Retry operation ${id} failed: ${error.message}`,
+            severity: 'medium',
+            timestamp: new Date(),
+            metadata: { retryId: id, error: error.message },
+            acknowledged: false
+        };
+        await this.integrationManager.sendAlert(alert);
+    }
+    async sendCriticalAlert(id, error) {
+        const alert = {
+            id: `retry_critical_${id}`,
+            type: 'error',
+            message: `Critical error in retry operation ${id}: ${error.message}`,
+            severity: 'critical',
+            timestamp: new Date(),
+            metadata: { retryId: id, error: error.message },
+            acknowledged: false
+        };
+        await this.integrationManager.sendCriticalAlert(alert);
+    }
+    generateRecommendations(metrics) {
+        const recommendations = [];
+        if (metrics.retrySuccessRate < 80) {
+            recommendations.push({
+                type: 'configuration',
+                priority: 'high',
+                title: 'Low Success Rate',
+                description: `Current success rate is ${metrics.retrySuccessRate.toFixed(1)}%`,
+                action: 'Consider adjusting retry parameters or investigating root causes'
+            });
+        }
+        if (metrics.averageRetryTime > 5000) {
+            recommendations.push({
+                type: 'performance',
+                priority: 'medium',
+                title: 'High Average Retry Time',
+                description: `Average retry time is ${metrics.averageRetryTime}ms`,
+                action: 'Consider optimizing retry delays or investigating performance bottlenecks'
+            });
+        }
+        return recommendations;
+    }
+    setupEventListeners() {
+        // Setup event listeners for retry manager events
+        // This would integrate with the actual retry manager events
+    }
+}
+exports.RetrySuite = RetrySuite;