paybridge 0.8.0 → 0.10.0

package/README.md

@@ -8,6 +8,8 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue)](https://www.typescriptlang.org/)
 [![Discord](https://img.shields.io/badge/Discord-Join%20Chat-5865F2?logo=discord&logoColor=white)](https://discord.gg/Y2jCXNGgE)
 
+📚 **[Documentation](https://kobie3717.github.io/paybridge/)** — full guides, provider reference, CLI docs, migration guides, examples.
+
 Unified payment SDK for Node.js that works with multiple payment providers through a single, consistent API. Focus on South African providers first, with support for international gateways.
 
 **WaSP is to WhatsApp what PayBridge is to payments** — one SDK, multiple backends, zero friction.
@@ -59,6 +61,46 @@ Runnable integrations for common Node.js frameworks:
 
 Each example uses `PayBridgeRouter` with Stripe + PayStack and demonstrates webhook signature verification, idempotency, and provider-specific routing.
 
+## Drift Detection
+
+Payment providers change their APIs without notice. A field gets renamed, an endpoint moves, a type changes from `string` to `number`. Your integration silently breaks.
+
+PayBridge includes **drift detection** — capture the shape of every provider's sandbox response, store it as a baseline, and get alerted the moment something changes.
+
+### Quick Start
+
+```bash
+# Capture baselines (one-time setup)
+npx paybridge drift-check --capture
+
+# Check for drift
+npx paybridge drift-check
+
+# Watch continuously (6-hour interval)
+npx paybridge drift-watch --interval 6h --webhook-url https://hooks.slack.com/...
+```
+
+### Example Output
+
+```
+=== Drift Detection ===
+
+[✓] stripe — no drift
+[⚠] mollie — drift detected:
+    + new keys: data.expiresAt, _links.dashboard.href
+    - removed keys: data.metadata.legacy
+    ! type changed: data.amount.value (string → number)
+[⚠] square — drift detected:
+    + new keys: payment_link.created_at_iso
+[ ] paystack — Missing: PAYSTACK_API_KEY
+```
+
+Exit code 1 if drift detected, 0 if clean. Perfect for CI/CD pipelines or cron jobs.
+
+### Why It Matters
+
+The Square `/checkout/payment-links → /online-checkout/payment-links` endpoint change would have shipped silently to production. With `drift-check` running daily, you get a Slack alert the moment it happens.
+
 ## Quick Start
 
 > **Upgrading from 0.1 or 0.2?** See [docs/migration.md](docs/migration.md).

package/dist/cli/commands/drift-watch.d.ts

@@ -0,0 +1 @@
+export declare function runDriftWatch(args: string[]): Promise<void>;

package/dist/cli/commands/drift-watch.js

@@ -0,0 +1,118 @@
+"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.runDriftWatch = runDriftWatch;
+const path = __importStar(require("node:path"));
+const runners_1 = require("../runners");
+const drift_store_1 = require("../drift-store");
+const drift_1 = require("./drift");
+const utils_1 = require("../utils");
+const INTERVALS = {
+    '30m': 30 * 60 * 1000,
+    '1h': 60 * 60 * 1000,
+    '6h': 6 * 60 * 60 * 1000,
+    '12h': 12 * 60 * 60 * 1000,
+    '24h': 24 * 60 * 60 * 1000,
+};
+function parseInterval(str) {
+    const interval = INTERVALS[str];
+    if (!interval) {
+        throw new Error(`Invalid interval: ${str}. Supported: ${Object.keys(INTERVALS).join(', ')}`);
+    }
+    return interval;
+}
+async function runDriftWatch(args) {
+    const intervalArg = args.find((a, i) => args[i - 1] === '--interval') || '6h';
+    const interval = parseInterval(intervalArg);
+    const once = args.includes('--once');
+    const webhookUrl = args.find((a, i) => args[i - 1] === '--webhook-url');
+    const baselineDir = args.find((a, i) => args[i - 1] === '--baseline-dir') ||
+        path.join(process.cwd(), '.paybridge', 'drift-baseline');
+    const store = new drift_store_1.FileDriftStore(baselineDir);
+    let running = true;
+    const cleanup = () => {
+        running = false;
+        console.log('\nStopping drift watch...');
+        process.exit(0);
+    };
+    process.on('SIGTERM', cleanup);
+    process.on('SIGINT', cleanup);
+    const runCheck = async () => {
+        const timestamp = new Date().toISOString();
+        console.log(`\n${(0, utils_1.colorize)('[drift-watch]', 'cyan')} Running check at ${timestamp}\n`);
+        try {
+            const results = await (0, drift_1.runDriftCheck)(runners_1.runners, store, { webhookUrl });
+            const driftCount = results.filter((r) => r.status === 'drift').length;
+            const noDriftCount = results.filter((r) => r.status === 'no-drift').length;
+            const skippedCount = results.filter((r) => r.status === 'skipped').length;
+            const errorCount = results.filter((r) => r.status === 'error').length;
+            for (const res of results) {
+                if (res.status === 'drift' && res.report) {
+                    console.log(`${(0, utils_1.colorize)('[⚠]', 'yellow')} ${res.provider} — drift detected`);
+                    if (res.report.addedKeys.length > 0) {
+                        console.log(`    + new keys: ${res.report.addedKeys.join(', ')}`);
+                    }
+                    if (res.report.removedKeys.length > 0) {
+                        console.log(`    - removed keys: ${res.report.removedKeys.join(', ')}`);
+                    }
+                    if (res.report.typeChanges.length > 0) {
+                        for (const change of res.report.typeChanges) {
+                            console.log(`    ! type changed: ${change.key} (${change.oldType} → ${change.newType})`);
+                        }
+                    }
+                }
+                else if (res.status === 'error') {
+                    console.log(`${(0, utils_1.colorize)('[✗]', 'red')} ${res.provider} ERROR: ${res.message}`);
+                }
+            }
+            console.log(`\n${(0, utils_1.colorize)('[summary]', 'cyan')} drift: ${driftCount}, clean: ${noDriftCount}, skipped: ${skippedCount}, errors: ${errorCount}`);
+        }
+        catch (err) {
+            console.error(`${(0, utils_1.colorize)('[!]', 'red')} Check failed: ${err.message}`);
+        }
+    };
+    await runCheck();
+    if (once) {
+        process.exit(0);
+    }
+    console.log(`\n${(0, utils_1.colorize)('[drift-watch]', 'cyan')} Watching every ${intervalArg}. Press Ctrl+C to stop.\n`);
+    const timer = setInterval(() => {
+        if (running) {
+            runCheck();
+        }
+    }, interval);
+    timer.unref();
+    await new Promise(() => { });
+}

package/dist/cli/commands/drift.d.ts

@@ -0,0 +1,20 @@
+import { ProviderRunner } from '../runners';
+import { DriftStore } from '../drift-store';
+import { DriftReport } from '../../drift-detector';
+interface DriftCheckOptions {
+    capture?: boolean;
+    baselineDir?: string;
+    json?: boolean;
+    webhookUrl?: string;
+    providers?: string[];
+}
+interface DriftCheckResult {
+    provider: string;
+    status: 'captured' | 'no-baseline' | 'no-drift' | 'drift' | 'skipped' | 'error';
+    message?: string;
+    report?: DriftReport;
+    keyCount?: number;
+}
+export declare function runDriftCheck(providedRunners: ProviderRunner[], store: DriftStore, opts: DriftCheckOptions): Promise<DriftCheckResult[]>;
+export declare function runDrift(args: string[]): Promise<void>;
+export {};

package/dist/cli/commands/drift.js

@@ -0,0 +1,212 @@
+"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.runDriftCheck = runDriftCheck;
+exports.runDrift = runDrift;
+const path = __importStar(require("node:path"));
+const runners_1 = require("../runners");
+const drift_store_1 = require("../drift-store");
+const drift_detector_1 = require("../../drift-detector");
+const utils_1 = require("../utils");
+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 runDriftCheck(providedRunners, store, opts) {
+    const libVersion = '0.10.0';
+    const results = [];
+    for (const runner of providedRunners) {
+        const missing = runner.envRequired.filter((key) => !process.env[key]);
+        if (missing.length > 0) {
+            results.push({
+                provider: runner.name,
+                status: 'skipped',
+                message: `Missing: ${missing.join(', ')}`,
+            });
+            continue;
+        }
+        try {
+            const response = await runner.run();
+            const shape = (0, drift_detector_1.captureShape)(response);
+            shape.status = response.status;
+            if (opts.capture) {
+                const baseline = {
+                    providerName: runner.name,
+                    operation: 'createPayment',
+                    shape,
+                    libVersion,
+                };
+                await store.save(baseline);
+                results.push({
+                    provider: runner.name,
+                    status: 'captured',
+                    keyCount: shape.keys.length,
+                });
+            }
+            else {
+                const baseline = await store.load(runner.name);
+                if (!baseline) {
+                    results.push({
+                        provider: runner.name,
+                        status: 'no-baseline',
+                        message: 'No baseline found (run with --capture to create)',
+                    });
+                }
+                else {
+                    const report = (0, drift_detector_1.diffBaseline)(baseline, shape, runner.name);
+                    if (report.driftDetected) {
+                        results.push({
+                            provider: runner.name,
+                            status: 'drift',
+                            report,
+                        });
+                        if (opts.webhookUrl) {
+                            try {
+                                await postWebhook(opts.webhookUrl, { provider: runner.name, drift: report, libVersion });
+                            }
+                            catch (err) {
+                                console.error(`${(0, utils_1.colorize)('[!]', 'yellow')} ${runner.name} webhook failed: ${err.message}`);
+                            }
+                        }
+                    }
+                    else {
+                        results.push({
+                            provider: runner.name,
+                            status: 'no-drift',
+                        });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            results.push({
+                provider: runner.name,
+                status: 'error',
+                message: error.message || String(error),
+            });
+        }
+    }
+    return results;
+}
+async function runDrift(args) {
+    const capture = args.includes('--capture');
+    const jsonOutput = args.includes('--json');
+    const baselineDir = args.find((a, i) => args[i - 1] === '--baseline-dir') ||
+        path.join(process.cwd(), '.paybridge', 'drift-baseline');
+    const webhookUrl = args.find((a, i) => args[i - 1] === '--webhook-url');
+    const providerNames = args.filter((a) => !a.startsWith('--') && a !== 'drift-check');
+    let selectedRunners = runners_1.runners;
+    if (providerNames.length > 0) {
+        selectedRunners = runners_1.runners.filter((r) => providerNames.includes(r.name));
+        const unknownProviders = providerNames.filter((p) => !runners_1.runners.find((r) => r.name === p));
+        if (unknownProviders.length > 0) {
+            console.error(`Unknown providers: ${unknownProviders.join(', ')}`);
+            console.error(`Available: ${runners_1.runners.map((r) => r.name).join(', ')}`);
+            process.exit(1);
+        }
+    }
+    const store = new drift_store_1.FileDriftStore(baselineDir);
+    const results = await runDriftCheck(selectedRunners, store, { capture, baselineDir, json: jsonOutput, webhookUrl });
+    if (jsonOutput) {
+        console.log(JSON.stringify(results, null, 2));
+    }
+    else {
+        if (capture) {
+            console.log('\n=== Drift Baseline Capture ===\n');
+            for (const res of results) {
+                if (res.status === 'captured') {
+                    console.log(`${(0, utils_1.colorize)('[saved]', 'green')} ${res.provider} baseline (${res.keyCount} keys)`);
+                }
+                else if (res.status === 'skipped') {
+                    console.log(`${(0, utils_1.colorize)('[ ]', 'dim')} ${res.provider} — ${res.message}`);
+                }
+                else if (res.status === 'error') {
+                    console.log(`${(0, utils_1.colorize)('[✗]', 'red')} ${res.provider} ERROR: ${res.message}`);
+                }
+            }
+        }
+        else {
+            console.log('\n=== Drift Detection ===\n');
+            for (const res of results) {
+                if (res.status === 'no-drift') {
+                    console.log(`${(0, utils_1.colorize)('[✓]', 'green')} ${res.provider} — no drift`);
+                }
+                else if (res.status === 'no-baseline') {
+                    console.log(`${(0, utils_1.colorize)('[ ]', 'dim')} ${res.provider} — ${res.message}`);
+                }
+                else if (res.status === 'skipped') {
+                    console.log(`${(0, utils_1.colorize)('[ ]', 'dim')} ${res.provider} — ${res.message}`);
+                }
+                else if (res.status === 'drift' && res.report) {
+                    console.log(`${(0, utils_1.colorize)('[⚠]', 'yellow')} ${res.provider} — drift detected:`);
+                    if (res.report.addedKeys.length > 0) {
+                        console.log(`    ${(0, utils_1.colorize)('+', 'green')} new keys: ${res.report.addedKeys.join(', ')}`);
+                    }
+                    if (res.report.removedKeys.length > 0) {
+                        console.log(`    ${(0, utils_1.colorize)('-', 'red')} removed keys: ${res.report.removedKeys.join(', ')}`);
+                    }
+                    if (res.report.typeChanges.length > 0) {
+                        for (const change of res.report.typeChanges) {
+                            console.log(`    ${(0, utils_1.colorize)('!', 'yellow')} type changed: ${change.key} (${change.oldType} → ${change.newType})`);
+                        }
+                    }
+                    if (res.report.statusChanged) {
+                        console.log(`    ${(0, utils_1.colorize)('!', 'yellow')} status changed: ${res.report.statusChanged.old} → ${res.report.statusChanged.new}`);
+                    }
+                }
+                else if (res.status === 'error') {
+                    console.log(`${(0, utils_1.colorize)('[✗]', 'red')} ${res.provider} ERROR: ${res.message}`);
+                }
+            }
+        }
+    }
+    const driftCount = results.filter((r) => r.status === 'drift').length;
+    const errorCount = results.filter((r) => r.status === 'error').length;
+    if (errorCount > 0) {
+        process.exit(2);
+    }
+    else if (driftCount > 0) {
+        process.exit(1);
+    }
+    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,8 @@ 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 utils_1 = require("./utils");
 async function main() {
     const [, , command, ...args] = process.argv;
@@ -21,6 +23,12 @@ 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 '-h':
         case '--help':
         case 'help':

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,
             });

package/dist/cli/utils.js

@@ -70,9 +70,20 @@ COMMANDS
   webhook verify <p>      Verify webhook signature (raw body from stdin)
   webhook parse <p>       Parse webhook event (raw body from stdin)
   quote <p> [opts]        Get a crypto on/off-ramp quote
+  drift-check [opts]      Capture/compare provider response shapes (drift detection)
+  drift-watch [opts]      Run drift-check on a loop (long-running monitor)
   help, -h, --help        Print this help
   version, -v             Print version
 
+DRIFT DETECTION
+  drift-check [provider]           Check all/single provider for API drift
+  drift-check --capture            Capture baseline snapshots (init mode)
+  drift-check --json               Output JSON instead of human-readable
+  drift-check --baseline-dir <p>   Custom baseline location (default: .paybridge/drift-baseline)
+  drift-check --webhook-url <url>  POST drift report to URL on detection
+  drift-watch --interval <6h|1h>   Run every interval (default: 6h)
+  drift-watch --once               Alias for drift-check (don't loop)
+
 PROVIDER ENV VARS
   See SETUP.md or run 'paybridge test --all' for the full list.
 
@@ -82,6 +93,9 @@ EXAMPLES
   STRIPE_API_KEY=sk_test_... paybridge test stripe
   echo '{"id":"evt_x"}' | paybridge webhook parse paystack \\
     --header x-paystack-signature=abc
+  paybridge drift-check --capture
+  paybridge drift-check stripe
+  paybridge drift-watch --interval 1h --webhook-url https://hooks.slack.com/...
 
 Docs: https://github.com/kobie3717/paybridge
 `.trim();

package/dist/drift-detector.d.ts

@@ -0,0 +1,40 @@
+export interface ResponseShape {
+    keys: string[];
+    types: Record<string, 'string' | 'number' | 'boolean' | 'object' | 'array' | 'null'>;
+    status?: string;
+    capturedAt: string;
+}
+export interface ProviderBaseline {
+    providerName: string;
+    operation: string;
+    shape: ResponseShape;
+    libVersion: string;
+}
+export interface DriftReport {
+    providerName: string;
+    driftDetected: boolean;
+    addedKeys: string[];
+    removedKeys: string[];
+    typeChanges: Array<{
+        key: string;
+        oldType: string;
+        newType: string;
+    }>;
+    statusChanged?: {
+        old: string;
+        new: string;
+    };
+    baselineCapturedAt: string;
+    newCapturedAt: string;
+}
+export declare function captureShape(response: unknown): ResponseShape;
+export declare function compareShapes(baseline: ResponseShape, current: ResponseShape): {
+    addedKeys: string[];
+    removedKeys: string[];
+    typeChanges: Array<{
+        key: string;
+        oldType: string;
+        newType: string;
+    }>;
+};
+export declare function diffBaseline(baseline: ProviderBaseline, currentShape: ResponseShape, providerName: string): DriftReport;

package/dist/drift-detector.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureShape = captureShape;
+exports.compareShapes = compareShapes;
+exports.diffBaseline = diffBaseline;
+function getType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+function flattenKeys(obj, prefix = '') {
+    const result = [];
+    if (obj === null || obj === undefined) {
+        return result;
+    }
+    if (Array.isArray(obj)) {
+        if (obj.length === 0) {
+            return result;
+        }
+        for (const item of obj) {
+            const nested = flattenKeys(item, `${prefix}[*]`);
+            result.push(...nested);
+        }
+    }
+    else if (typeof obj === 'object') {
+        for (const [key, value] of Object.entries(obj)) {
+            const path = prefix ? `${prefix}.${key}` : key;
+            const valueType = getType(value);
+            if (valueType === 'object' || valueType === 'array') {
+                const nested = flattenKeys(value, path);
+                result.push(...nested);
+            }
+            else {
+                result.push({ path, type: valueType });
+            }
+        }
+    }
+    return result;
+}
+function deduplicateKeys(entries) {
+    const seen = new Map();
+    for (const entry of entries) {
+        if (!seen.has(entry.path)) {
+            seen.set(entry.path, entry.type);
+        }
+    }
+    return Array.from(seen.entries()).map(([path, type]) => ({ path, type }));
+}
+function captureShape(response) {
+    const entries = flattenKeys(response);
+    const deduplicated = deduplicateKeys(entries);
+    const sorted = deduplicated.sort((a, b) => a.path.localeCompare(b.path));
+    const keys = sorted.map((e) => e.path);
+    const types = {};
+    for (const entry of sorted) {
+        types[entry.path] = entry.type;
+    }
+    return {
+        keys,
+        types,
+        capturedAt: new Date().toISOString(),
+    };
+}
+function compareShapes(baseline, current) {
+    const baselineSet = new Set(baseline.keys);
+    const currentSet = new Set(current.keys);
+    const addedKeys = current.keys.filter((k) => !baselineSet.has(k));
+    const removedKeys = baseline.keys.filter((k) => !currentSet.has(k));
+    const typeChanges = [];
+    for (const key of current.keys) {
+        if (baselineSet.has(key)) {
+            const oldType = baseline.types[key];
+            const newType = current.types[key];
+            if (oldType !== newType) {
+                typeChanges.push({ key, oldType, newType });
+            }
+        }
+    }
+    return { addedKeys, removedKeys, typeChanges };
+}
+function diffBaseline(baseline, currentShape, providerName) {
+    const diff = compareShapes(baseline.shape, currentShape);
+    let statusChanged;
+    if (baseline.shape.status && currentShape.status && baseline.shape.status !== currentShape.status) {
+        statusChanged = { old: baseline.shape.status, new: currentShape.status };
+    }
+    const driftDetected = diff.addedKeys.length > 0 ||
+        diff.removedKeys.length > 0 ||
+        diff.typeChanges.length > 0 ||
+        !!statusChanged;
+    return {
+        providerName,
+        driftDetected,
+        addedKeys: diff.addedKeys,
+        removedKeys: diff.removedKeys,
+        typeChanges: diff.typeChanges,
+        statusChanged,
+        baselineCapturedAt: baseline.shape.capturedAt,
+        newCapturedAt: currentShape.capturedAt,
+    };
+}

package/dist/providers/square.js

@@ -91,7 +91,7 @@ class SquareProvider extends base_1.PaymentProvider {
                 buyer_email: params.customer.email,
             },
         };
-        const response = await this.apiRequest('POST', '/checkout/payment-links', requestBody);
+        const response = await this.apiRequest('POST', '/online-checkout/payment-links', requestBody);
         const link = response.payment_link;
         return {
             id: link.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paybridge",
-  "version": "0.8.0",
+  "version": "0.10.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",
@@ -14,7 +14,7 @@
     "cli": "node dist/cli/index.js",
     "prepack": "npm run clean && npm run build:cli",
     "prepublishOnly": "npm run clean && npm run build:cli",
-    "test": "tsc && tsc --project tsconfig.test.json && node --test 'dist-test/**/*.test.js'",
+    "test": "tsc && tsc --project tsconfig.test.json && find dist-test -name '*.test.js' -exec node --test {} +",
     "test:e2e:moonpay": "tsx tests/e2e/moonpay-sandbox.ts",
     "test:e2e:yellowcard": "tsx tests/e2e/yellowcard-sandbox.ts",
     "test:e2e:sandbox": "tsx tests/e2e/sandbox-validate.ts"
@@ -46,7 +46,10 @@
     "ramp",
     "east-africa",
     "cli",
-    "command-line"
+    "command-line",
+    "drift-detection",
+    "monitoring",
+    "api-validation"
   ],
   "author": "Kobie Wentzel",
   "license": "MIT",