paybridge 0.9.0 → 0.11.0

package/dist/cli/commands/reconcile.js

@@ -0,0 +1,341 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReconcileCommand = runReconcileCommand;
+const fs = __importStar(require("node:fs"));
+const readline = __importStar(require("node:readline"));
+const index_1 = require("../../index");
+const runners_1 = require("../runners");
+const reconcile_1 = require("../reconcile");
+const utils_1 = require("../utils");
+function parseOptions(args) {
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--input' && args[i + 1]) {
+            opts.input = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--json') {
+            opts.json = true;
+        }
+        else if (args[i] === '--webhook-url' && args[i + 1]) {
+            opts.webhookUrl = args[i + 1];
+            i++;
+        }
+    }
+    return opts;
+}
+async function parseInput(input) {
+    const lines = [];
+    if (input) {
+        const content = fs.readFileSync(input, 'utf8');
+        lines.push(...content.split('\n').filter((l) => l.trim()));
+    }
+    else {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false,
+        });
+        for await (const line of rl) {
+            if (line.trim()) {
+                lines.push(line.trim());
+            }
+        }
+    }
+    if (lines.length === 0) {
+        return [];
+    }
+    const firstLine = lines[0];
+    const isCsv = /^provider\s*,\s*reference\s*,\s*expectedStatus/i.test(firstLine);
+    const records = [];
+    if (isCsv) {
+        for (let i = 1; i < lines.length; i++) {
+            const parts = lines[i].split(',').map((s) => s.trim());
+            if (parts.length >= 3) {
+                records.push({
+                    provider: parts[0],
+                    reference: parts[1],
+                    expectedStatus: parts[2],
+                });
+            }
+        }
+    }
+    else {
+        for (const line of lines) {
+            try {
+                const obj = JSON.parse(line);
+                if (obj.provider && obj.reference && obj.expectedStatus) {
+                    records.push({
+                        provider: obj.provider,
+                        reference: obj.reference,
+                        expectedStatus: obj.expectedStatus,
+                    });
+                }
+            }
+            catch (e) {
+                console.error(`${(0, utils_1.colorize)('[!]', 'yellow')} Skipping invalid JSON line: ${line}`);
+            }
+        }
+    }
+    return records;
+}
+function buildProvider(providerName) {
+    const runner = runners_1.runners.find((r) => r.name === providerName);
+    if (!runner) {
+        throw new Error(`Unknown provider: ${providerName}`);
+    }
+    const missing = runner.envRequired.filter((key) => !process.env[key]);
+    if (missing.length > 0) {
+        throw new Error(`Missing: ${missing.join(', ')}`);
+    }
+    switch (providerName) {
+        case 'stripe':
+            return new index_1.PayBridge({
+                provider: 'stripe',
+                credentials: { apiKey: process.env.STRIPE_API_KEY },
+                sandbox: true,
+            });
+        case 'paystack':
+            return new index_1.PayBridge({
+                provider: 'paystack',
+                credentials: { apiKey: process.env.PAYSTACK_API_KEY },
+                sandbox: true,
+            });
+        case 'flutterwave':
+            return new index_1.PayBridge({
+                provider: 'flutterwave',
+                credentials: { apiKey: process.env.FLUTTERWAVE_API_KEY },
+                sandbox: true,
+            });
+        case 'adyen':
+            return new index_1.PayBridge({
+                provider: 'adyen',
+                credentials: {
+                    apiKey: process.env.ADYEN_API_KEY,
+                    merchantAccount: process.env.ADYEN_MERCHANT_ACCOUNT,
+                },
+                sandbox: true,
+            });
+        case 'softycomp':
+            return new index_1.PayBridge({
+                provider: 'softycomp',
+                credentials: {
+                    apiKey: process.env.SOFTYCOMP_API_KEY,
+                    secretKey: process.env.SOFTYCOMP_SECRET_KEY,
+                },
+                sandbox: true,
+            });
+        case 'yoco':
+            return new index_1.PayBridge({
+                provider: 'yoco',
+                credentials: { apiKey: process.env.YOCO_API_KEY },
+                sandbox: true,
+            });
+        case 'ozow':
+            return new index_1.PayBridge({
+                provider: 'ozow',
+                credentials: {
+                    apiKey: process.env.OZOW_API_KEY,
+                    siteCode: process.env.OZOW_SITE_CODE,
+                    privateKey: process.env.OZOW_PRIVATE_KEY,
+                },
+                sandbox: true,
+            });
+        case 'payfast':
+            return new index_1.PayBridge({
+                provider: 'payfast',
+                credentials: {
+                    merchantId: process.env.PAYFAST_MERCHANT_ID,
+                    merchantKey: process.env.PAYFAST_MERCHANT_KEY,
+                    passphrase: process.env.PAYFAST_PASSPHRASE,
+                },
+                sandbox: true,
+            });
+        case 'peach':
+            return new index_1.PayBridge({
+                provider: 'peach',
+                credentials: {
+                    apiKey: process.env.PEACH_ACCESS_TOKEN,
+                    secretKey: process.env.PEACH_ENTITY_ID,
+                },
+                sandbox: true,
+            });
+        case 'mercadopago':
+            return new index_1.PayBridge({
+                provider: 'mercadopago',
+                credentials: { apiKey: process.env.MERCADOPAGO_ACCESS_TOKEN },
+                sandbox: true,
+            });
+        case 'razorpay':
+            return new index_1.PayBridge({
+                provider: 'razorpay',
+                credentials: {
+                    apiKey: process.env.RAZORPAY_KEY_ID,
+                    secretKey: process.env.RAZORPAY_KEY_SECRET,
+                },
+                sandbox: true,
+            });
+        case 'mollie':
+            return new index_1.PayBridge({
+                provider: 'mollie',
+                credentials: { apiKey: process.env.MOLLIE_API_KEY },
+                sandbox: true,
+            });
+        case 'square':
+            return new index_1.PayBridge({
+                provider: 'square',
+                credentials: {
+                    apiKey: process.env.SQUARE_ACCESS_TOKEN,
+                    locationId: process.env.SQUARE_LOCATION_ID,
+                },
+                sandbox: true,
+            });
+        case 'pesapal':
+            return new index_1.PayBridge({
+                provider: 'pesapal',
+                credentials: {
+                    apiKey: process.env.PESAPAL_CONSUMER_KEY,
+                    secretKey: process.env.PESAPAL_CONSUMER_SECRET,
+                    notificationId: process.env.PESAPAL_NOTIFICATION_ID,
+                },
+                sandbox: true,
+            });
+        default:
+            throw new Error(`Provider ${providerName} not implemented in reconcile`);
+    }
+}
+function hasCredsFor(providerName) {
+    const runner = runners_1.runners.find((r) => r.name === providerName);
+    if (!runner) {
+        return false;
+    }
+    return runner.envRequired.every((key) => !!process.env[key]);
+}
+function printResult(result) {
+    const { provider, reference, classification, expectedStatus, actualStatus, errorMessage } = result;
+    let icon;
+    let message;
+    switch (classification) {
+        case 'match':
+            icon = (0, utils_1.colorize)('[✓]', 'green');
+            message = `${provider}:${reference} — ${actualStatus} (match)`;
+            break;
+        case 'mismatch':
+            icon = (0, utils_1.colorize)('[!]', 'yellow');
+            message = `${provider}:${reference} — expected ${expectedStatus}, actual ${actualStatus} (MISSED WEBHOOK)`;
+            break;
+        case 'not-found':
+            icon = (0, utils_1.colorize)('[?]', 'yellow');
+            message = `${provider}:${reference} — not-found (no provider record)`;
+            break;
+        case 'error':
+            icon = (0, utils_1.colorize)('[✗]', 'red');
+            message = `${provider}:${reference} — error (${errorMessage})`;
+            break;
+        case 'skipped':
+            icon = (0, utils_1.colorize)('[ ]', 'dim');
+            message = `${provider}:${reference} — skipped (${errorMessage})`;
+            break;
+    }
+    console.log(`${icon} ${message}`);
+}
+async function postWebhook(url, payload) {
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+        throw new Error(`Webhook POST failed: ${res.status} ${res.statusText}`);
+    }
+}
+async function runReconcileCommand(args) {
+    const opts = parseOptions(args);
+    const records = await parseInput(opts.input);
+    if (records.length === 0) {
+        console.error('No records to reconcile. Provide input via stdin or --input <file>.');
+        process.exit(1);
+    }
+    const { results, summary } = await (0, reconcile_1.runReconcile)(records, { buildProvider, hasCredsFor }, {
+        onResult: opts.json ? undefined : printResult,
+    });
+    if (opts.json) {
+        for (const result of results) {
+            console.log(JSON.stringify(result));
+        }
+        console.log(JSON.stringify({ summary }));
+    }
+    else {
+        console.log(`\nReconciled: ${summary.total}`);
+        console.log(`  Match: ${summary.match}`);
+        console.log(`  Mismatch (missed webhook): ${summary.mismatch}`);
+        console.log(`  Not found: ${summary.notFound}`);
+        console.log(`  Error: ${summary.error}`);
+        console.log(`  Skipped: ${summary.skipped}`);
+    }
+    if (opts.webhookUrl && summary.mismatch > 0) {
+        const mismatches = results.filter((r) => r.classification === 'mismatch');
+        const payload = {
+            totalReconciled: summary.total,
+            missed: summary.mismatch,
+            mismatches: mismatches.map((r) => ({
+                provider: r.provider,
+                reference: r.reference,
+                expected: r.expectedStatus,
+                actual: r.actualStatus,
+            })),
+            libVersion: '0.11.0',
+        };
+        try {
+            await postWebhook(opts.webhookUrl, payload);
+            if (!opts.json) {
+                console.log(`\n${(0, utils_1.colorize)('[webhook]', 'cyan')} Posted mismatch report to ${opts.webhookUrl}`);
+            }
+        }
+        catch (err) {
+            console.error(`${(0, utils_1.colorize)('[!]', 'yellow')} Webhook POST failed: ${err.message}`);
+        }
+    }
+    if (summary.mismatch > 0) {
+        process.exit(1);
+    }
+    else if (summary.error > 0 && summary.match === 0) {
+        process.exit(2);
+    }
+    else {
+        process.exit(0);
+    }
+}

package/dist/cli/drift-store.d.ts

@@ -0,0 +1,14 @@
+import { ProviderBaseline } from '../drift-detector';
+export interface DriftStore {
+    load(providerName: string): Promise<ProviderBaseline | null>;
+    save(baseline: ProviderBaseline): Promise<void>;
+    listProviders(): Promise<string[]>;
+}
+export declare class FileDriftStore implements DriftStore {
+    private dir;
+    constructor(dir: string);
+    private getFilePath;
+    load(providerName: string): Promise<ProviderBaseline | null>;
+    save(baseline: ProviderBaseline): Promise<void>;
+    listProviders(): Promise<string[]>;
+}

package/dist/cli/drift-store.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileDriftStore = void 0;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+class FileDriftStore {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    getFilePath(providerName) {
+        return path.join(this.dir, `${providerName}.json`);
+    }
+    async load(providerName) {
+        const filePath = this.getFilePath(providerName);
+        try {
+            const content = await node_fs_1.promises.readFile(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return null;
+            }
+            throw err;
+        }
+    }
+    async save(baseline) {
+        await node_fs_1.promises.mkdir(this.dir, { recursive: true });
+        const filePath = this.getFilePath(baseline.providerName);
+        const content = JSON.stringify(baseline, null, 2);
+        await node_fs_1.promises.writeFile(filePath, content, 'utf-8');
+    }
+    async listProviders() {
+        try {
+            const files = await node_fs_1.promises.readdir(this.dir);
+            return files
+                .filter((f) => f.endsWith('.json'))
+                .map((f) => f.slice(0, -5));
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return [];
+            }
+            throw err;
+        }
+    }
+}
+exports.FileDriftStore = FileDriftStore;

package/dist/cli/index.js

@@ -5,6 +5,9 @@ const test_1 = require("./commands/test");
 const providers_1 = require("./commands/providers");
 const webhook_1 = require("./commands/webhook");
 const quote_1 = require("./commands/quote");
+const drift_1 = require("./commands/drift");
+const drift_watch_1 = require("./commands/drift-watch");
+const reconcile_1 = require("./commands/reconcile");
 const utils_1 = require("./utils");
 async function main() {
     const [, , command, ...args] = process.argv;
@@ -21,6 +24,15 @@ async function main() {
         case 'quote':
             await (0, quote_1.runQuote)(args);
             break;
+        case 'drift-check':
+            await (0, drift_1.runDrift)(args);
+            break;
+        case 'drift-watch':
+            await (0, drift_watch_1.runDriftWatch)(args);
+            break;
+        case 'reconcile':
+            await (0, reconcile_1.runReconcileCommand)(args);
+            break;
         case '-h':
         case '--help':
         case 'help':

package/dist/cli/reconcile-types.d.ts

@@ -0,0 +1,22 @@
+export type CanonicalStatus = 'completed' | 'pending' | 'failed' | 'cancelled' | 'refunded' | 'unknown';
+export interface ReconcileRecord {
+    provider: string;
+    reference: string;
+    expectedStatus: CanonicalStatus | string;
+}
+export interface ReconcileResult {
+    provider: string;
+    reference: string;
+    expectedStatus: string;
+    actualStatus?: string;
+    classification: 'match' | 'mismatch' | 'not-found' | 'error' | 'skipped';
+    errorMessage?: string;
+}
+export interface ReconcileSummary {
+    total: number;
+    match: number;
+    mismatch: number;
+    notFound: number;
+    error: number;
+    skipped: number;
+}

package/dist/cli/reconcile-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cli/reconcile.d.ts

@@ -0,0 +1,12 @@
+import { PayBridge } from '../index';
+import { ReconcileRecord, ReconcileResult, ReconcileSummary } from './reconcile-types';
+export interface ReconcileDeps {
+    buildProvider: (providerName: string) => PayBridge;
+    hasCredsFor: (providerName: string) => boolean;
+}
+export declare function runReconcile(records: ReconcileRecord[], deps: ReconcileDeps, opts?: {
+    onResult?: (r: ReconcileResult) => void;
+}): Promise<{
+    results: ReconcileResult[];
+    summary: ReconcileSummary;
+}>;

package/dist/cli/reconcile.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReconcile = runReconcile;
+async function runReconcile(records, deps, opts = {}) {
+    const providerCache = new Map();
+    const results = [];
+    const summary = {
+        total: records.length,
+        match: 0,
+        mismatch: 0,
+        notFound: 0,
+        error: 0,
+        skipped: 0,
+    };
+    for (const record of records) {
+        if (!deps.hasCredsFor(record.provider)) {
+            const result = {
+                provider: record.provider,
+                reference: record.reference,
+                expectedStatus: record.expectedStatus,
+                classification: 'skipped',
+                errorMessage: 'missing credentials',
+            };
+            results.push(result);
+            summary.skipped++;
+            opts.onResult?.(result);
+            continue;
+        }
+        let pay;
+        if (providerCache.has(record.provider)) {
+            pay = providerCache.get(record.provider);
+        }
+        else {
+            try {
+                pay = deps.buildProvider(record.provider);
+                providerCache.set(record.provider, pay);
+            }
+            catch (err) {
+                const result = {
+                    provider: record.provider,
+                    reference: record.reference,
+                    expectedStatus: record.expectedStatus,
+                    classification: 'error',
+                    errorMessage: err.message || String(err),
+                };
+                results.push(result);
+                summary.error++;
+                opts.onResult?.(result);
+                continue;
+            }
+        }
+        try {
+            const payment = await pay.getPayment(record.reference);
+            const actualStatus = payment.status;
+            const normalized = normalizeStatus(record.expectedStatus);
+            const match = normalized === actualStatus;
+            const result = {
+                provider: record.provider,
+                reference: record.reference,
+                expectedStatus: record.expectedStatus,
+                actualStatus,
+                classification: match ? 'match' : 'mismatch',
+            };
+            results.push(result);
+            if (match) {
+                summary.match++;
+            }
+            else {
+                summary.mismatch++;
+            }
+            opts.onResult?.(result);
+        }
+        catch (err) {
+            const isNotFound = err.message?.includes('not found') ||
+                err.message?.includes('404') ||
+                err.message?.includes('No payment found');
+            const result = {
+                provider: record.provider,
+                reference: record.reference,
+                expectedStatus: record.expectedStatus,
+                classification: isNotFound ? 'not-found' : 'error',
+                errorMessage: err.message || String(err),
+            };
+            results.push(result);
+            if (isNotFound) {
+                summary.notFound++;
+            }
+            else {
+                summary.error++;
+            }
+            opts.onResult?.(result);
+        }
+    }
+    return { results, summary };
+}
+function normalizeStatus(status) {
+    const lower = status.toLowerCase();
+    if (['completed', 'pending', 'failed', 'cancelled', 'refunded'].includes(lower)) {
+        return lower;
+    }
+    return 'unknown';
+}

package/dist/cli/runners.js

@@ -6,7 +6,7 @@ const crypto_1 = require("../crypto");
 const timestamp = Date.now();
 const testCustomer = {
     name: 'Test User',
-    email: 'test@example.com',
+    email: 'paybridge-sandbox@gmail.com',
     phone: '0825551234',
 };
 const testUrls = {
@@ -111,14 +111,26 @@ exports.runners = [
                 credentials: { apiKey: process.env.PAYSTACK_API_KEY },
                 sandbox: true,
             });
-            const payment = await pay.createPayment({
-                amount: 1.0,
-                currency: 'NGN',
-                reference: `cli-test-${timestamp}`,
-                customer: testCustomer,
-                urls: testUrls,
-            });
-            return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+            const currencies = (process.env.PAYSTACK_TEST_CURRENCY || 'NGN,ZAR,GHS,KES').split(',');
+            let lastErr;
+            for (const currency of currencies) {
+                try {
+                    const payment = await pay.createPayment({
+                        amount: 100.0,
+                        currency: currency.trim(),
+                        reference: `cli-test-${timestamp}-${currency.trim()}`,
+                        customer: testCustomer,
+                        urls: testUrls,
+                    });
+                    return { id: payment.id, checkoutUrl: payment.checkoutUrl, status: payment.status };
+                }
+                catch (e) {
+                    lastErr = e;
+                    if (!/currency not supported/i.test(e.message))
+                        throw e;
+                }
+            }
+            throw lastErr ?? new Error('No currency accepted by PayStack merchant');
         },
     },
     {
@@ -289,11 +301,37 @@ exports.runners = [
         name: 'pesapal',
         envRequired: ['PESAPAL_CONSUMER_KEY', 'PESAPAL_CONSUMER_SECRET'],
         run: async () => {
+            const consumerKey = process.env.PESAPAL_CONSUMER_KEY;
+            const consumerSecret = process.env.PESAPAL_CONSUMER_SECRET;
+            let notificationId = process.env.PESAPAL_NOTIFICATION_ID;
+            if (!notificationId) {
+                const tokenRes = await fetch('https://cybqa.pesapal.com/pesapalv3/api/Auth/RequestToken', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
+                    body: JSON.stringify({ consumer_key: consumerKey, consumer_secret: consumerSecret }),
+                });
+                const tokenJson = await tokenRes.json();
+                const ipnRes = await fetch('https://cybqa.pesapal.com/pesapalv3/api/URLSetup/RegisterIPN', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json',
+                        Authorization: `Bearer ${tokenJson.token}`,
+                    },
+                    body: JSON.stringify({
+                        url: 'https://example.com/pesapal-ipn',
+                        ipn_notification_type: 'GET',
+                    }),
+                });
+                const ipnJson = await ipnRes.json();
+                notificationId = ipnJson.ipn_id;
+            }
             const pay = new index_1.PayBridge({
                 provider: 'pesapal',
                 credentials: {
-                    apiKey: process.env.PESAPAL_CONSUMER_KEY,
-                    secretKey: process.env.PESAPAL_CONSUMER_SECRET,
+                    apiKey: consumerKey,
+                    secretKey: consumerSecret,
+                    notificationId,
                 },
                 sandbox: true,
             });