paybridge 0.3.1 → 0.5.0

package/dist/router.js

@@ -8,6 +8,8 @@ const routing_types_1 = require("./routing-types");
 const strategies_1 = require("./strategies");
 const circuit_breaker_1 = require("./circuit-breaker");
 const fetch_1 = require("./utils/fetch");
+const router_events_1 = require("./router-events");
+const tracer_1 = require("./tracer");
 function sanitizeErrorMessage(msg) {
     if (!msg)
         return 'unknown error';
@@ -27,6 +29,7 @@ class WebhookDuplicateError extends Error {
 exports.WebhookDuplicateError = WebhookDuplicateError;
 class PayBridgeRouter {
     constructor(config) {
+        this.events = new router_events_1.RouterEventEmitter();
         this.rrIndex = 0;
         this.config = config;
         this.providers = config.providers.map(p => ({
@@ -41,12 +44,36 @@ class PayBridgeRouter {
             retryDelayMs: config.fallback?.retryDelayMs ?? 250,
         };
         this.idempotencyStore = config.idempotencyStore;
+        this.ledger = config.ledger;
+        this.tracer = config.tracer ?? tracer_1.noopTracer;
         this.circuitBreakers = new Map();
         for (const p of this.providers) {
             const name = p.instance.getProviderName();
-            this.circuitBreakers.set(name, new circuit_breaker_1.CircuitBreaker(name, {
+            const breaker = new circuit_breaker_1.CircuitBreaker(name, {
                 store: config.circuitBreakerStore,
-            }));
+            });
+            breaker.events.on('opened', (key) => {
+                this.events.emitEvent({
+                    type: 'circuit.opened',
+                    provider: key,
+                    timestamp: new Date().toISOString(),
+                });
+            });
+            breaker.events.on('half_opened', (key) => {
+                this.events.emitEvent({
+                    type: 'circuit.half_opened',
+                    provider: key,
+                    timestamp: new Date().toISOString(),
+                });
+            });
+            breaker.events.on('closed', (key) => {
+                this.events.emitEvent({
+                    type: 'circuit.closed',
+                    provider: key,
+                    timestamp: new Date().toISOString(),
+                });
+            });
+            this.circuitBreakers.set(name, breaker);
         }
     }
     async createPayment(params) {
@@ -82,9 +109,24 @@ class PayBridgeRouter {
                 continue;
             }
             const startTime = Date.now();
+            const span = this.tracer.startSpan('paybridge.router.createPayment', {
+                'paybridge.provider': providerName,
+                'paybridge.strategy': this.strategy,
+                'paybridge.attempt': attempts.length + 1,
+            });
+            this.events.emitEvent({
+                type: 'attempt.start',
+                provider: providerName,
+                operation: 'createPayment',
+                reference: params.reference,
+                attempt: attempts.length + 1,
+                timestamp: new Date().toISOString(),
+            });
             try {
                 const result = await providerMeta.instance.createPayment(params);
                 const latencyMs = Date.now() - startTime;
+                span.setAttribute('paybridge.payment.id', result.id);
+                span.setAttribute('paybridge.payment.status', result.status);
                 if (breaker)
                     await breaker.recordSuccess();
                 attempts.push({
@@ -92,21 +134,59 @@ class PayBridgeRouter {
                     status: 'success',
                     latencyMs,
                 });
+                this.events.emitEvent({
+                    type: 'attempt.success',
+                    provider: providerName,
+                    operation: 'createPayment',
+                    reference: params.reference,
+                    durationMs: latencyMs,
+                    attempt: attempts.length,
+                    timestamp: new Date().toISOString(),
+                });
+                this.events.emitEvent({
+                    type: 'request.success',
+                    provider: providerName,
+                    operation: 'createPayment',
+                    reference: params.reference,
+                    durationMs: latencyMs,
+                    timestamp: new Date().toISOString(),
+                });
+                await this.recordLedgerEntry({
+                    id: `${providerName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                    timestamp: new Date().toISOString(),
+                    operation: 'createPayment',
+                    provider: providerName,
+                    reference: params.reference,
+                    providerId: result.id,
+                    status: 'success',
+                    amount: params.amount,
+                    currency: params.currency,
+                    durationMs: latencyMs,
+                });
                 const routingMeta = {
                     attempts,
                     chosenProvider: providerName,
                     strategy: this.strategy,
                 };
+                span.end();
                 return {
                     ...result,
                     routingMeta,
                 };
             }
             catch (error) {
+                span.recordException?.(error instanceof Error ? error : new Error(String(error)));
                 const latencyMs = Date.now() - startTime;
                 lastError = error;
                 const isRateLimited = error instanceof fetch_1.HttpError &&
                     (error.status === 429 || (error.status === 503 && error.retryAfterMs !== undefined));
+                let errorCode = error.code;
+                if (error instanceof fetch_1.FetchTimeoutError) {
+                    errorCode = 'TIMEOUT';
+                }
+                else if (isRateLimited) {
+                    errorCode = 'RATE_LIMITED';
+                }
                 if (isRateLimited) {
                     attempts.push({
                         provider: providerName,
@@ -115,14 +195,34 @@ class PayBridgeRouter {
                         errorMessage: sanitizeErrorMessage(error.message),
                         latencyMs,
                     });
+                    this.events.emitEvent({
+                        type: 'attempt.rate_limited',
+                        provider: providerName,
+                        operation: 'createPayment',
+                        reference: params.reference,
+                        durationMs: latencyMs,
+                        errorCode: 'RATE_LIMITED',
+                        errorMessage: sanitizeErrorMessage(error.message),
+                        attempt: attempts.length,
+                        timestamp: new Date().toISOString(),
+                    });
+                    await this.recordLedgerEntry({
+                        id: `${providerName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                        timestamp: new Date().toISOString(),
+                        operation: 'createPayment',
+                        provider: providerName,
+                        reference: params.reference,
+                        status: 'rate_limited',
+                        amount: params.amount,
+                        currency: params.currency,
+                        durationMs: latencyMs,
+                        errorCode: 'RATE_LIMITED',
+                        errorMessage: sanitizeErrorMessage(error.message),
+                    });
                 }
                 else {
                     if (breaker)
                         await breaker.recordFailure();
-                    let errorCode = error.code;
-                    if (error instanceof fetch_1.FetchTimeoutError) {
-                        errorCode = 'TIMEOUT';
-                    }
                     attempts.push({
                         provider: providerName,
                         status: 'failed',
@@ -130,13 +230,48 @@ class PayBridgeRouter {
                         errorMessage: sanitizeErrorMessage(error.message),
                         latencyMs,
                     });
+                    const eventType = error instanceof fetch_1.FetchTimeoutError ? 'attempt.timeout' : 'attempt.failure';
+                    this.events.emitEvent({
+                        type: eventType,
+                        provider: providerName,
+                        operation: 'createPayment',
+                        reference: params.reference,
+                        durationMs: latencyMs,
+                        errorCode,
+                        errorMessage: sanitizeErrorMessage(error.message),
+                        attempt: attempts.length,
+                        timestamp: new Date().toISOString(),
+                    });
+                    const ledgerStatus = error instanceof fetch_1.FetchTimeoutError ? 'timeout' : 'failed';
+                    await this.recordLedgerEntry({
+                        id: `${providerName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                        timestamp: new Date().toISOString(),
+                        operation: 'createPayment',
+                        provider: providerName,
+                        reference: params.reference,
+                        status: ledgerStatus,
+                        amount: params.amount,
+                        currency: params.currency,
+                        durationMs: latencyMs,
+                        errorCode,
+                        errorMessage: sanitizeErrorMessage(error.message),
+                    });
                 }
+                span.setAttribute('paybridge.error.code', errorCode ?? 'unknown');
+                span.end();
                 if (!this.fallback.enabled || attempts.length >= (this.fallback.maxAttempts ?? 3)) {
                     break;
                 }
                 await this.sleep(this.fallback.retryDelayMs ?? 250);
             }
         }
+        this.events.emitEvent({
+            type: 'request.failure',
+            operation: 'createPayment',
+            reference: params.reference,
+            errorMessage: lastError?.message || 'All providers failed',
+            timestamp: new Date().toISOString(),
+        });
         throw new routing_types_1.RoutingError(`All providers failed: ${lastError?.message || 'Unknown error'}`, attempts);
     }
     async createSubscription(params) {
@@ -169,6 +304,14 @@ class PayBridgeRouter {
                 continue;
             }
             const startTime = Date.now();
+            this.events.emitEvent({
+                type: 'attempt.start',
+                provider: providerName,
+                operation: 'createSubscription',
+                reference: params.reference,
+                attempt: attempts.length + 1,
+                timestamp: new Date().toISOString(),
+            });
             try {
                 const result = await providerMeta.instance.createSubscription(params);
                 const latencyMs = Date.now() - startTime;
@@ -179,6 +322,35 @@ class PayBridgeRouter {
                     status: 'success',
                     latencyMs,
                 });
+                this.events.emitEvent({
+                    type: 'attempt.success',
+                    provider: providerName,
+                    operation: 'createSubscription',
+                    reference: params.reference,
+                    durationMs: latencyMs,
+                    attempt: attempts.length,
+                    timestamp: new Date().toISOString(),
+                });
+                this.events.emitEvent({
+                    type: 'request.success',
+                    provider: providerName,
+                    operation: 'createSubscription',
+                    reference: params.reference,
+                    durationMs: latencyMs,
+                    timestamp: new Date().toISOString(),
+                });
+                await this.recordLedgerEntry({
+                    id: `${providerName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                    timestamp: new Date().toISOString(),
+                    operation: 'createSubscription',
+                    provider: providerName,
+                    reference: params.reference,
+                    providerId: result.id,
+                    status: 'success',
+                    amount: params.amount,
+                    currency: params.currency,
+                    durationMs: latencyMs,
+                });
                 return result;
             }
             catch (error) {
@@ -194,6 +366,30 @@ class PayBridgeRouter {
                         errorMessage: sanitizeErrorMessage(error.message),
                         latencyMs,
                     });
+                    this.events.emitEvent({
+                        type: 'attempt.rate_limited',
+                        provider: providerName,
+                        operation: 'createSubscription',
+                        reference: params.reference,
+                        durationMs: latencyMs,
+                        errorCode: 'RATE_LIMITED',
+                        errorMessage: sanitizeErrorMessage(error.message),
+                        attempt: attempts.length,
+                        timestamp: new Date().toISOString(),
+                    });
+                    await this.recordLedgerEntry({
+                        id: `${providerName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                        timestamp: new Date().toISOString(),
+                        operation: 'createSubscription',
+                        provider: providerName,
+                        reference: params.reference,
+                        status: 'rate_limited',
+                        amount: params.amount,
+                        currency: params.currency,
+                        durationMs: latencyMs,
+                        errorCode: 'RATE_LIMITED',
+                        errorMessage: sanitizeErrorMessage(error.message),
+                    });
                 }
                 else {
                     if (breaker)
@@ -209,6 +405,32 @@ class PayBridgeRouter {
                         errorMessage: sanitizeErrorMessage(error.message),
                         latencyMs,
                     });
+                    const eventType = error instanceof fetch_1.FetchTimeoutError ? 'attempt.timeout' : 'attempt.failure';
+                    this.events.emitEvent({
+                        type: eventType,
+                        provider: providerName,
+                        operation: 'createSubscription',
+                        reference: params.reference,
+                        durationMs: latencyMs,
+                        errorCode,
+                        errorMessage: sanitizeErrorMessage(error.message),
+                        attempt: attempts.length,
+                        timestamp: new Date().toISOString(),
+                    });
+                    const ledgerStatus = error instanceof fetch_1.FetchTimeoutError ? 'timeout' : 'failed';
+                    await this.recordLedgerEntry({
+                        id: `${providerName}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                        timestamp: new Date().toISOString(),
+                        operation: 'createSubscription',
+                        provider: providerName,
+                        reference: params.reference,
+                        status: ledgerStatus,
+                        amount: params.amount,
+                        currency: params.currency,
+                        durationMs: latencyMs,
+                        errorCode,
+                        errorMessage: sanitizeErrorMessage(error.message),
+                    });
                 }
                 if (!this.fallback.enabled || attempts.length >= (this.fallback.maxAttempts ?? 3)) {
                     break;
@@ -216,6 +438,13 @@ class PayBridgeRouter {
                 await this.sleep(this.fallback.retryDelayMs ?? 250);
             }
         }
+        this.events.emitEvent({
+            type: 'request.failure',
+            operation: 'createSubscription',
+            reference: params.reference,
+            errorMessage: lastError?.message || 'All providers failed',
+            timestamp: new Date().toISOString(),
+        });
         throw new routing_types_1.RoutingError(`All providers failed for subscription: ${lastError?.message || 'Unknown error'}`, attempts);
     }
     async getPayment(id, provider) {
@@ -269,6 +498,13 @@ class PayBridgeRouter {
                 const ttlMs = 24 * 60 * 60 * 1000;
                 const isNew = await this.idempotencyStore.recordIfNew(key, ttlMs);
                 if (!isNew) {
+                    this.events.emitEvent({
+                        type: 'webhook.duplicate',
+                        provider: providerName,
+                        operation: 'parseWebhook',
+                        reference: eventId,
+                        timestamp: new Date().toISOString(),
+                    });
                     throw new WebhookDuplicateError(providerName, eventId);
                 }
             }
@@ -300,5 +536,21 @@ class PayBridgeRouter {
     sleep(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
+    async recordLedgerEntry(entry) {
+        if (!this.ledger)
+            return;
+        try {
+            await this.ledger.append(entry);
+        }
+        catch (err) {
+            this.events.emitEvent({
+                type: 'attempt.failure',
+                operation: entry.operation,
+                provider: entry.provider,
+                errorMessage: 'Ledger write failed',
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
 }
 exports.PayBridgeRouter = PayBridgeRouter;

package/dist/stores/redis-ledger.d.ts

@@ -0,0 +1,8 @@
+import type { RedisLike } from './redis';
+import type { LedgerStore } from '../ledger';
+export interface RedisLedgerStoreOptions {
+    redis: RedisLike;
+    keyPrefix?: string;
+    maxEntries?: number;
+}
+export declare function createRedisLedgerStore(opts: RedisLedgerStoreOptions): LedgerStore;

package/dist/stores/redis-ledger.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRedisLedgerStore = createRedisLedgerStore;
+function createRedisLedgerStore(opts) {
+    const prefix = opts.keyPrefix ?? 'pb:ledger:';
+    const maxEntries = opts.maxEntries ?? 100000;
+    const listKey = `${prefix}list`;
+    const refIndexPrefix = `${prefix}ref:`;
+    if (!opts.redis.lpush || !opts.redis.ltrim || !opts.redis.lrange || !opts.redis.sadd || !opts.redis.smembers || !opts.redis.expire) {
+        throw new Error('Redis client does not support required list/set operations for ledger store');
+    }
+    return {
+        async append(entry) {
+            const serialized = JSON.stringify(entry);
+            await opts.redis.lpush(listKey, serialized);
+            await opts.redis.ltrim(listKey, 0, maxEntries - 1);
+            if (entry.reference) {
+                const refKey = `${refIndexPrefix}${entry.reference}`;
+                await opts.redis.sadd(refKey, entry.id);
+                await opts.redis.expire(refKey, 86400 * 30);
+            }
+        },
+        async query(filter) {
+            let entries = [];
+            if (filter.reference) {
+                const refKey = `${refIndexPrefix}${filter.reference}`;
+                const ids = await opts.redis.smembers(refKey);
+                if (!ids || ids.length === 0)
+                    return [];
+                const allEntries = await opts.redis.lrange(listKey, 0, -1);
+                entries = allEntries
+                    .map((s) => JSON.parse(s))
+                    .filter((e) => ids.includes(e.id));
+            }
+            else {
+                const allEntries = await opts.redis.lrange(listKey, 0, -1);
+                entries = allEntries.map((s) => JSON.parse(s));
+            }
+            if (filter.provider)
+                entries = entries.filter(e => e.provider === filter.provider);
+            if (filter.status)
+                entries = entries.filter(e => e.status === filter.status);
+            if (filter.fromTimestamp)
+                entries = entries.filter(e => e.timestamp >= filter.fromTimestamp);
+            if (filter.toTimestamp)
+                entries = entries.filter(e => e.timestamp <= filter.toTimestamp);
+            if (filter.limit)
+                entries = entries.slice(0, filter.limit);
+            return entries;
+        },
+    };
+}

package/dist/stores/redis.d.ts

@@ -10,6 +10,12 @@ export interface RedisLike {
     get(key: string): Promise<string | null>;
     set(key: string, value: string, ...args: any[]): Promise<any>;
     del(key: string): Promise<any>;
+    lpush?(key: string, ...values: string[]): Promise<number>;
+    ltrim?(key: string, start: number, stop: number): Promise<string>;
+    lrange?(key: string, start: number, stop: number): Promise<string[]>;
+    sadd?(key: string, ...members: string[]): Promise<number>;
+    smembers?(key: string): Promise<string[]>;
+    expire?(key: string, seconds: number): Promise<number>;
 }
 export interface RedisStoreOptions {
     prefix?: string;

package/dist/tracer.d.ts

@@ -0,0 +1,9 @@
+export interface SpanLike {
+    setAttribute(key: string, value: string | number | boolean): void;
+    recordException?(error: Error): void;
+    end(): void;
+}
+export interface TracerLike {
+    startSpan(name: string, attributes?: Record<string, string | number | boolean>): SpanLike;
+}
+export declare const noopTracer: TracerLike;

package/dist/tracer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noopTracer = void 0;
+exports.noopTracer = {
+    startSpan: () => ({
+        setAttribute: () => { },
+        recordException: () => { },
+        end: () => { },
+    }),
+};

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * PayBridge — Unified payment SDK types
  */
-export type Provider = 'softycomp' | 'yoco' | 'ozow' | 'payfast' | 'paystack' | 'stripe' | 'peach' | 'flutterwave';
+export type Provider = 'softycomp' | 'yoco' | 'ozow' | 'payfast' | 'paystack' | 'stripe' | 'peach' | 'flutterwave' | 'adyen' | 'mercadopago' | 'razorpay';
 export type PaymentStatus = 'pending' | 'completed' | 'failed' | 'cancelled' | 'refunded';
 export type SubscriptionInterval = 'weekly' | 'monthly' | 'yearly';
 export type Currency = 'ZAR' | 'USD' | 'EUR' | 'GBP' | 'NGN' | 'KES' | 'UGX' | 'GHS' | string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paybridge",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "One API for fiat + crypto payments. Multi-provider routing, automatic failover, MoonPay on/off-ramp. SA-first, global-ready.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,12 @@
     "payment-integration",
     "unified-api",
     "zar",
-    "payment-sdk"
+    "payment-sdk",
+    "adyen",
+    "mercadopago",
+    "razorpay",
+    "india",
+    "latam"
   ],
   "author": "Kobie Wentzel",
   "license": "MIT",