failover-sdk/dist/provider-override.js

One-line API failover with zero downtime. Native Rust performance with TypeScript interface.

"use strict";
// Provider override system - routes calls through existing failover-js based on cached config
Object.defineProperty(exports, "__esModule", { value: true });
exports.setupProviderOverrides = setupProviderOverrides;
exports.setupFallbackInterceptor = setupFallbackInterceptor;
const providers_1 = require("./providers");
const config_loader_1 = require("./config-loader");
// Store original functions for fallback
let originalPayments;
let originalEmail;
/**
 * Setup provider overrides based on cached SaaS config
 */
function setupProviderOverrides() {
    try {
        // Store originals for fallback
        originalPayments = providers_1.payments;
        originalEmail = providers_1.email;
        // Override global payments function
        global.payments = () => {
            const config = (0, config_loader_1.getCachedConfig)();
            const activeProvider = config.services.payments.active;
            const enabledProviders = config.services.payments.enabled || [activeProvider];
            console.log(`[Failover] Using payment providers: ${enabledProviders.join(', ')} (primary: ${activeProvider})`);
            // Route to enabled providers based on config
            const allProviders = originalPayments();
            const enabledProvidersObj = {};
            enabledProviders.forEach(provider => {
                if (allProviders[provider]) {
                    enabledProvidersObj[provider] = allProviders[provider];
                }
            });
            return enabledProvidersObj;
        };
        // Override global email function
        global.email = () => {
            const config = (0, config_loader_1.getCachedConfig)();
            const activeProvider = config.services.email.active;
            const enabledProviders = config.services.email.enabled || [activeProvider];
            console.log(`[Failover] Using email providers: ${enabledProviders.join(', ')} (primary: ${activeProvider})`);
            // Route to enabled providers based on config
            const allProviders = originalEmail();
            const enabledProvidersObj = {};
            enabledProviders.forEach(provider => {
                if (allProviders[provider]) {
                    enabledProvidersObj[provider] = allProviders[provider];
                }
            });
            return enabledProvidersObj;
        };
        console.log('[Failover] Provider overrides activated');
    }
    catch (error) {
        console.error('[Failover] Failed to setup provider overrides:', error);
    }
}
/**
 * Fallback HTTP interceptor for additional safety
 * Only activates if the configured provider also fails
 */
function setupFallbackInterceptor() {
    try {
        // Store original fetch for fallback
        const originalFetch = globalThis.fetch;
        globalThis.fetch = async (input, init) => {
            const urlString = input.toString();
            try {
                // Try the original request first
                return await originalFetch(input, init);
            }
            catch (error) {
                // Only intercept known provider URLs that failed
                if (shouldInterceptFailedRequest(urlString)) {
                    console.log(`[Failover] Primary provider failed, attempting failover for: ${urlString}`);
                    return await attemptFailover(urlString, init);
                }
                // Re-throw error for non-intercepted requests
                throw error;
            }
        };
        console.log('[Failover] Fallback interceptor activated');
    }
    catch (error) {
        console.error('[Failover] Failed to setup fallback interceptor:', error);
    }
}
/**
 * Check if we should intercept a failed request
 */
function shouldInterceptFailedRequest(url) {
    const knownProviders = [
        'api.stripe.com',
        'api.sendgrid.com',
        'connect.squareup.com',
        'api-m.paypal.com',
        'api.resend.com',
        'api.mailgun.net',
        'api.postmarkapp.com',
    ];
    return knownProviders.some(provider => url.includes(provider));
}
/**
 * Attempt failover using existing failover-js logic
 */
async function attemptFailover(url, _options) {
    // Parse the request and route through existing failover-js providers
    // This is a simplified version - in practice would need full request parsing
    if (url.includes('api.stripe.com')) {
        // Route through existing payments system
        const config = (0, config_loader_1.getCachedConfig)();
        const fallbackProvider = config.services.payments.active === 'stripe' ? 'square' : config.services.payments.active;
        console.log(`[Failover] Routing Stripe request through ${fallbackProvider}`);
        // For now, return a mock response - full implementation would parse the request
        // and call the appropriate provider through existing failover-js
        return new Response(JSON.stringify({
            id: 'failover_mock_response',
            provider_used: fallbackProvider,
            note: 'Request routed through failover system',
        }), {
            status: 200,
            headers: { 'Content-Type': 'application/json' },
        });
    }
    // Fallback: re-throw the original error
    throw new Error(`Failover not implemented for: ${url}`);
}
//# sourceMappingURL=provider-override.js.map