@bernierllc/retry-suite 0.1.0

package/dist/config/configuration-manager.js

@@ -0,0 +1,309 @@
+"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.ConfigurationManager = void 0;
+class ConfigurationManager {
+    constructor(initialConfig) {
+        this.configValidators = new Map();
+        this.config = { ...initialConfig };
+        this.setupValidators();
+    }
+    setupValidators() {
+        this.configValidators.set('retryManager', this.validateRetryManager.bind(this));
+        this.configValidators.set('retryStorage', this.validateRetryStorage.bind(this));
+        this.configValidators.set('retryMonitoring', this.validateRetryMonitoring.bind(this));
+        this.configValidators.set('admin', this.validateAdmin.bind(this));
+        this.configValidators.set('integrations', this.validateIntegrations.bind(this));
+        this.configValidators.set('logging', this.validateLogging.bind(this));
+    }
+    async updateConfiguration(updates) {
+        const newConfig = { ...this.config, ...updates };
+        const validation = this.validateConfiguration(newConfig);
+        if (!validation.isValid) {
+            return {
+                success: false,
+                errors: validation.errors
+            };
+        }
+        try {
+            const oldConfig = { ...this.config };
+            this.config = newConfig;
+            await this.notifyConfigurationChange(oldConfig, newConfig);
+            return {
+                success: true,
+                message: 'Configuration updated successfully'
+            };
+        }
+        catch (error) {
+            this.config = { ...this.config };
+            return {
+                success: false,
+                errors: [`Failed to apply configuration: ${error.message}`]
+            };
+        }
+    }
+    getConfiguration() {
+        return JSON.parse(JSON.stringify(this.config));
+    }
+    validateConfiguration(config) {
+        const errors = [];
+        for (const [key, validator] of this.configValidators) {
+            if (config[key]) {
+                const validationErrors = validator(config[key]);
+                errors.push(...validationErrors);
+            }
+            else {
+                errors.push(`${key} configuration is required`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors
+        };
+    }
+    validateRetryManager(config) {
+        const errors = [];
+        if (!config.defaultOptions) {
+            errors.push('retryManager.defaultOptions is required');
+            return errors;
+        }
+        const opts = config.defaultOptions;
+        if (typeof opts.maxRetries !== 'number' || opts.maxRetries < 0) {
+            errors.push('retryManager.defaultOptions.maxRetries must be a non-negative number');
+        }
+        if (typeof opts.initialDelayMs !== 'number' || opts.initialDelayMs < 0) {
+            errors.push('retryManager.defaultOptions.initialDelayMs must be a non-negative number');
+        }
+        if (typeof opts.backoffFactor !== 'number' || opts.backoffFactor < 1) {
+            errors.push('retryManager.defaultOptions.backoffFactor must be >= 1');
+        }
+        if (opts.maxDelayMs !== undefined) {
+            if (typeof opts.maxDelayMs !== 'number' || opts.maxDelayMs < opts.initialDelayMs) {
+                errors.push('retryManager.defaultOptions.maxDelayMs must be >= initialDelayMs');
+            }
+        }
+        return errors;
+    }
+    validateRetryStorage(config) {
+        const errors = [];
+        if (!config.type) {
+            errors.push('retryStorage.type is required');
+        }
+        else if (!['memory', 'redis', 'file'].includes(config.type)) {
+            errors.push('retryStorage.type must be one of: memory, redis, file');
+        }
+        if (!config.options || typeof config.options !== 'object') {
+            errors.push('retryStorage.options must be an object');
+        }
+        if (config.type === 'redis' && config.options) {
+            if (!config.options.url && !config.options.host) {
+                errors.push('retryStorage.options must include url or host for redis type');
+            }
+        }
+        if (config.type === 'file' && config.options) {
+            if (!config.options.path) {
+                errors.push('retryStorage.options.path is required for file type');
+            }
+        }
+        return errors;
+    }
+    validateRetryMonitoring(config) {
+        const errors = [];
+        if (typeof config.enabled !== 'boolean') {
+            errors.push('retryMonitoring.enabled must be a boolean');
+        }
+        if (typeof config.metricsInterval !== 'number' || config.metricsInterval < 1000) {
+            errors.push('retryMonitoring.metricsInterval must be >= 1000ms');
+        }
+        if (!config.alertThresholds) {
+            errors.push('retryMonitoring.alertThresholds is required');
+        }
+        else {
+            const thresholds = config.alertThresholds;
+            if (typeof thresholds.failureRate !== 'number' ||
+                thresholds.failureRate < 0 ||
+                thresholds.failureRate > 1) {
+                errors.push('retryMonitoring.alertThresholds.failureRate must be between 0 and 1');
+            }
+            if (typeof thresholds.averageRetryTime !== 'number' ||
+                thresholds.averageRetryTime < 0) {
+                errors.push('retryMonitoring.alertThresholds.averageRetryTime must be >= 0');
+            }
+        }
+        return errors;
+    }
+    validateAdmin(config) {
+        const errors = [];
+        if (typeof config.port !== 'number' ||
+            config.port < 1 ||
+            config.port > 65535) {
+            errors.push('admin.port must be between 1 and 65535');
+        }
+        if (typeof config.host !== 'string' || !config.host) {
+            errors.push('admin.host must be a non-empty string');
+        }
+        if (!config.auth || typeof config.auth !== 'object') {
+            errors.push('admin.auth configuration is required');
+        }
+        else {
+            if (typeof config.auth.enabled !== 'boolean') {
+                errors.push('admin.auth.enabled must be a boolean');
+            }
+            if (config.auth.enabled) {
+                if (!config.auth.username || typeof config.auth.username !== 'string') {
+                    errors.push('admin.auth.username is required when auth is enabled');
+                }
+                if (!config.auth.password || typeof config.auth.password !== 'string') {
+                    errors.push('admin.auth.password is required when auth is enabled');
+                }
+                if (config.auth.password && config.auth.password.length < 8) {
+                    errors.push('admin.auth.password must be at least 8 characters long');
+                }
+            }
+        }
+        return errors;
+    }
+    validateIntegrations(config) {
+        const errors = [];
+        if (!Array.isArray(config)) {
+            errors.push('integrations must be an array');
+            return errors;
+        }
+        for (let i = 0; i < config.length; i++) {
+            const integration = config[i];
+            const prefix = `integrations[${i}]`;
+            if (!integration.type) {
+                errors.push(`${prefix}.type is required`);
+                continue;
+            }
+            if (!['slack', 'pagerduty', 'email', 'webhook'].includes(integration.type)) {
+                errors.push(`${prefix}.type must be one of: slack, pagerduty, email, webhook`);
+                continue;
+            }
+            if (!integration.config || typeof integration.config !== 'object') {
+                errors.push(`${prefix}.config is required and must be an object`);
+                continue;
+            }
+            // Validate specific integration configs
+            switch (integration.type) {
+                case 'slack':
+                    if (!integration.config.token) {
+                        errors.push(`${prefix}.config.token is required for Slack integration`);
+                    }
+                    if (!integration.config.channel) {
+                        errors.push(`${prefix}.config.channel is required for Slack integration`);
+                    }
+                    break;
+                case 'email':
+                    if (!integration.config.provider) {
+                        errors.push(`${prefix}.config.provider is required for email integration`);
+                    }
+                    if (!integration.config.from) {
+                        errors.push(`${prefix}.config.from is required for email integration`);
+                    }
+                    if (!Array.isArray(integration.config.to) || integration.config.to.length === 0) {
+                        errors.push(`${prefix}.config.to must be a non-empty array for email integration`);
+                    }
+                    break;
+                case 'webhook':
+                    if (!integration.config.url) {
+                        errors.push(`${prefix}.config.url is required for webhook integration`);
+                    }
+                    else {
+                        try {
+                            new URL(integration.config.url);
+                        }
+                        catch {
+                            errors.push(`${prefix}.config.url must be a valid URL for webhook integration`);
+                        }
+                    }
+                    break;
+                case 'pagerduty':
+                    if (!integration.config.apiKey) {
+                        errors.push(`${prefix}.config.apiKey is required for PagerDuty integration`);
+                    }
+                    if (!integration.config.serviceId) {
+                        errors.push(`${prefix}.config.serviceId is required for PagerDuty integration`);
+                    }
+                    break;
+            }
+        }
+        return errors;
+    }
+    validateLogging(config) {
+        const errors = [];
+        if (!['debug', 'info', 'warn', 'error'].includes(config.level)) {
+            errors.push('logging.level must be one of: debug, info, warn, error');
+        }
+        if (!['json', 'text'].includes(config.format)) {
+            errors.push('logging.format must be one of: json, text');
+        }
+        return errors;
+    }
+    async notifyConfigurationChange(oldConfig, newConfig) {
+        console.log('Configuration updated:', {
+            timestamp: new Date().toISOString(),
+            changes: this.getConfigChanges(oldConfig, newConfig)
+        });
+    }
+    getConfigChanges(oldConfig, newConfig) {
+        const changes = {};
+        for (const key of Object.keys(newConfig)) {
+            if (JSON.stringify(oldConfig[key]) !== JSON.stringify(newConfig[key])) {
+                changes[key] = {
+                    old: oldConfig[key],
+                    new: newConfig[key]
+                };
+            }
+        }
+        return changes;
+    }
+    resetToDefaults() {
+        this.config = this.getDefaultConfiguration();
+        return this.getConfiguration();
+    }
+    getDefaultConfiguration() {
+        return {
+            retryManager: {
+                defaultOptions: {
+                    maxRetries: 5,
+                    initialDelayMs: 1000,
+                    backoffFactor: 2,
+                    maxDelayMs: 30000,
+                    jitter: true
+                }
+            },
+            retryStorage: {
+                type: 'memory',
+                options: {}
+            },
+            retryMonitoring: {
+                enabled: true,
+                metricsInterval: 60000,
+                alertThresholds: {
+                    failureRate: 0.1,
+                    averageRetryTime: 5000
+                }
+            },
+            admin: {
+                port: 3000,
+                host: 'localhost',
+                auth: {
+                    enabled: false
+                }
+            },
+            integrations: [],
+            logging: {
+                level: 'info',
+                format: 'json'
+            }
+        };
+    }
+}
+exports.ConfigurationManager = ConfigurationManager;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { RetrySuite } from './retry-suite';
+export { AdminServer } from './admin/admin-server';
+export { IntegrationManager } from './integrations/integration-manager';
+export { ConfigurationManager } from './config/configuration-manager';
+export { SlackIntegration } from './integrations/slack-integration';
+export { EmailIntegration } from './integrations/email-integration';
+export { WebhookIntegration } from './integrations/webhook-integration';
+export { RetryDashboard, MetricsOverview, AlertsList, RetriesList } from './components/retry-dashboard';
+export type { RetrySuiteConfig, RetryManagerConfig, RetryStorageConfig, RetryMonitoringConfig, AdminConfig, IntegrationConfig, LoggingConfig, RetryStatus, RetryOptions, RetryResult, RetryMetrics, FailureReason, HourlyMetrics, StorageMetrics, Alert, PerformanceReport, TrendData, Recommendation, MetricsOptions, AlertOptions, ReportOptions, ScheduleResult, CancelResult, PauseResult, ResumeResult, ConfigResult, ValidationResult, Integration, SlackConfig, PagerDutyConfig, EmailConfig, WebhookConfig } from './types';

package/dist/index.js

@@ -0,0 +1,32 @@
+"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.RetriesList = exports.AlertsList = exports.MetricsOverview = exports.RetryDashboard = exports.WebhookIntegration = exports.EmailIntegration = exports.SlackIntegration = exports.ConfigurationManager = exports.IntegrationManager = exports.AdminServer = exports.RetrySuite = void 0;
+// Main classes
+var retry_suite_1 = require("./retry-suite");
+Object.defineProperty(exports, "RetrySuite", { enumerable: true, get: function () { return retry_suite_1.RetrySuite; } });
+var admin_server_1 = require("./admin/admin-server");
+Object.defineProperty(exports, "AdminServer", { enumerable: true, get: function () { return admin_server_1.AdminServer; } });
+var integration_manager_1 = require("./integrations/integration-manager");
+Object.defineProperty(exports, "IntegrationManager", { enumerable: true, get: function () { return integration_manager_1.IntegrationManager; } });
+var configuration_manager_1 = require("./config/configuration-manager");
+Object.defineProperty(exports, "ConfigurationManager", { enumerable: true, get: function () { return configuration_manager_1.ConfigurationManager; } });
+// Integration classes
+var slack_integration_1 = require("./integrations/slack-integration");
+Object.defineProperty(exports, "SlackIntegration", { enumerable: true, get: function () { return slack_integration_1.SlackIntegration; } });
+var email_integration_1 = require("./integrations/email-integration");
+Object.defineProperty(exports, "EmailIntegration", { enumerable: true, get: function () { return email_integration_1.EmailIntegration; } });
+var webhook_integration_1 = require("./integrations/webhook-integration");
+Object.defineProperty(exports, "WebhookIntegration", { enumerable: true, get: function () { return webhook_integration_1.WebhookIntegration; } });
+// React components
+var retry_dashboard_1 = require("./components/retry-dashboard");
+Object.defineProperty(exports, "RetryDashboard", { enumerable: true, get: function () { return retry_dashboard_1.RetryDashboard; } });
+Object.defineProperty(exports, "MetricsOverview", { enumerable: true, get: function () { return retry_dashboard_1.MetricsOverview; } });
+Object.defineProperty(exports, "AlertsList", { enumerable: true, get: function () { return retry_dashboard_1.AlertsList; } });
+Object.defineProperty(exports, "RetriesList", { enumerable: true, get: function () { return retry_dashboard_1.RetriesList; } });

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

@@ -0,0 +1,12 @@
+import { Alert, Integration, EmailConfig } from '../types';
+export declare class EmailIntegration implements Integration {
+    readonly type = "email";
+    private config;
+    constructor(config: EmailConfig);
+    sendAlert(alert: Alert): Promise<void>;
+    sendCriticalAlert(alert: Alert): Promise<void>;
+    private generateEmailTemplate;
+    private generateCriticalEmailTemplate;
+    private getSeverityColor;
+    private sendEmail;
+}

package/dist/integrations/email-integration.js

@@ -0,0 +1,215 @@
+"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.EmailIntegration = void 0;
+class EmailIntegration {
+    constructor(config) {
+        this.type = 'email';
+        this.config = config;
+    }
+    async sendAlert(alert) {
+        if (alert.severity === 'low') {
+            return;
+        }
+        const subject = `[${alert.severity.toUpperCase()}] ${alert.message}`;
+        const htmlContent = this.generateEmailTemplate(alert);
+        await this.sendEmail({
+            to: this.config.to,
+            subject,
+            html: htmlContent
+        });
+    }
+    async sendCriticalAlert(alert) {
+        const subject = `[CRITICAL ALERT] ${alert.message}`;
+        const htmlContent = this.generateCriticalEmailTemplate(alert);
+        await this.sendEmail({
+            to: this.config.to,
+            subject,
+            html: htmlContent,
+            priority: 'high'
+        });
+    }
+    generateEmailTemplate(alert) {
+        const severityColor = this.getSeverityColor(alert.severity);
+        return `
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <meta charset="utf-8">
+        <title>Retry Suite Alert</title>
+        <style>
+          body { font-family: Arial, sans-serif; margin: 0; padding: 20px; }
+          .alert-container { 
+            max-width: 600px; 
+            margin: 0 auto; 
+            border: 1px solid #ddd; 
+            border-radius: 8px; 
+            overflow: hidden; 
+          }
+          .alert-header { 
+            background-color: ${severityColor}; 
+            color: white; 
+            padding: 20px; 
+            text-align: center; 
+          }
+          .alert-body { padding: 20px; }
+          .alert-field { margin: 10px 0; }
+          .alert-field strong { color: #333; }
+          .footer { 
+            background-color: #f5f5f5; 
+            padding: 15px 20px; 
+            font-size: 12px; 
+            color: #666; 
+          }
+        </style>
+      </head>
+      <body>
+        <div class="alert-container">
+          <div class="alert-header">
+            <h1>Retry Suite Alert</h1>
+            <h2>${alert.message}</h2>
+          </div>
+          <div class="alert-body">
+            <div class="alert-field">
+              <strong>Type:</strong> ${alert.type}
+            </div>
+            <div class="alert-field">
+              <strong>Severity:</strong> ${alert.severity}
+            </div>
+            <div class="alert-field">
+              <strong>Time:</strong> ${alert.timestamp.toISOString()}
+            </div>
+            <div class="alert-field">
+              <strong>Alert ID:</strong> ${alert.id}
+            </div>
+            ${Object.keys(alert.metadata).length > 0 ? `
+            <div class="alert-field">
+              <strong>Details:</strong>
+              <pre>${JSON.stringify(alert.metadata, null, 2)}</pre>
+            </div>
+            ` : ''}
+          </div>
+          <div class="footer">
+            This alert was generated by Retry Suite monitoring system.
+          </div>
+        </div>
+      </body>
+      </html>
+    `;
+    }
+    generateCriticalEmailTemplate(alert) {
+        return `
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <meta charset="utf-8">
+        <title>CRITICAL ALERT - Retry Suite</title>
+        <style>
+          body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background-color: #ffe6e6; }
+          .alert-container { 
+            max-width: 600px; 
+            margin: 0 auto; 
+            border: 3px solid #ff0000; 
+            border-radius: 8px; 
+            overflow: hidden; 
+            background-color: white;
+          }
+          .alert-header { 
+            background-color: #ff0000; 
+            color: white; 
+            padding: 20px; 
+            text-align: center; 
+          }
+          .critical-banner {
+            background-color: #8b0000;
+            color: white;
+            padding: 10px;
+            text-align: center;
+            font-weight: bold;
+            font-size: 18px;
+          }
+          .alert-body { padding: 20px; }
+          .alert-field { margin: 15px 0; }
+          .alert-field strong { color: #333; }
+          .footer { 
+            background-color: #f5f5f5; 
+            padding: 15px 20px; 
+            font-size: 12px; 
+            color: #666; 
+          }
+        </style>
+      </head>
+      <body>
+        <div class="alert-container">
+          <div class="critical-banner">
+            🚨 CRITICAL SYSTEM ALERT 🚨
+          </div>
+          <div class="alert-header">
+            <h1>IMMEDIATE ATTENTION REQUIRED</h1>
+            <h2>${alert.message}</h2>
+          </div>
+          <div class="alert-body">
+            <div class="alert-field">
+              <strong>Type:</strong> ${alert.type}
+            </div>
+            <div class="alert-field">
+              <strong>Severity:</strong> <span style="color: red; font-weight: bold;">${alert.severity.toUpperCase()}</span>
+            </div>
+            <div class="alert-field">
+              <strong>Time:</strong> ${alert.timestamp.toISOString()}
+            </div>
+            <div class="alert-field">
+              <strong>Alert ID:</strong> ${alert.id}
+            </div>
+            <div class="alert-field">
+              <strong>Details:</strong>
+              <pre style="background-color: #f5f5f5; padding: 10px; border-radius: 4px;">${JSON.stringify(alert.metadata, null, 2)}</pre>
+            </div>
+          </div>
+          <div class="footer">
+            <strong>This is a critical alert that requires immediate attention.</strong><br>
+            Generated by Retry Suite monitoring system at ${alert.timestamp.toISOString()}.
+          </div>
+        </div>
+      </body>
+      </html>
+    `;
+    }
+    getSeverityColor(severity) {
+        switch (severity) {
+            case 'low': return '#36a64f';
+            case 'medium': return '#ffa500';
+            case 'high': return '#ff0000';
+            case 'critical': return '#8b0000';
+            default: return '#36a64f';
+        }
+    }
+    async sendEmail(params) {
+        try {
+            // This would integrate with an actual email service like SendGrid, SES, etc.
+            // For now, we'll simulate the email sending
+            console.log(`[EMAIL] Sending email to: ${params.to.join(', ')}`);
+            console.log(`[EMAIL] Subject: ${params.subject}`);
+            console.log(`[EMAIL] Priority: ${params.priority || 'normal'}`);
+            // In a real implementation, you would use a service like:
+            // - SendGrid
+            // - Amazon SES
+            // - Mailgun
+            // - SMTP server
+            // Simulate network delay
+            await new Promise(resolve => setTimeout(resolve, 100));
+            console.log('[EMAIL] Email sent successfully');
+        }
+        catch (error) {
+            console.error('Failed to send email:', error);
+            throw error;
+        }
+    }
+}
+exports.EmailIntegration = EmailIntegration;

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

@@ -0,0 +1,15 @@
+import { IntegrationConfig, Alert } from '../types';
+export declare class IntegrationManager {
+    private integrations;
+    private config;
+    constructor(config: IntegrationConfig[]);
+    private setupIntegrations;
+    private createIntegration;
+    sendAlert(alert: Alert): Promise<void>;
+    sendCriticalAlert(alert: Alert): Promise<void>;
+    getIntegrations(): string[];
+    hasIntegration(type: string): boolean;
+    testIntegration(type: string): Promise<boolean>;
+    testAllIntegrations(): Promise<Record<string, boolean>>;
+    updateConfiguration(config: IntegrationConfig[]): void;
+}