Migrate from another provider

// payment-gateway.js — single interface
class PaymentGateway {
async initializeCheckout(order) { throw new Error('Not implemented'); }
async verifyTransaction(reference) { throw new Error('Not implemented'); }
async refundTransaction(reference, amount) { throw new Error('Not implemented'); }
processWebhook(payload, signature) { throw new Error('Not implemented'); }
}

// wajub-adapter.js — no official SDK yet, calling the REST API directly
const BASE_URL = 'https://api.wajub.com';

class WajubAdapter extends PaymentGateway {
constructor() {
  super();
  this.publicKey = process.env.WAJUB_PUBLIC_KEY;
  this.secretKey = process.env.WAJUB_SECRET_KEY;
  this.webhookSecret = process.env.WAJUB_WEBHOOK_SECRET;
}

async initializeCheckout(order) {
  const res = await fetch(`${BASE_URL}/payments`, {
    method: 'POST',
    headers: { Authorization: this.publicKey, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      amount: order.amount,
      currency: order.currency,
      email: order.email,
      phone: order.phone,
      reference: `ORDER-${order.id}`,
      callback: `${process.env.BASE_URL}/payment/return`,
    }),
  }).then(r => r.json());
  return { id: res.transaction.id, redirectUrl: res.authorization_url };
}

async verifyTransaction(id) {
  const res = await fetch(`${BASE_URL}/payments/${id}`, {
    headers: { Authorization: this.publicKey },
  }).then(r => r.json());
  return { status: res.transaction.status, amount: res.transaction.amount };
}

async refundTransaction(paymentId, amount) {
  const res = await fetch(`${BASE_URL}/refunds`, {
    method: 'POST',
    headers: { Authorization: this.secretKey, 'Content-Type': 'application/json' },
    body: JSON.stringify({ payment: paymentId, amount, reason: 'requested_by_customer' }),
  }).then(r => r.json());
  return { id: res.refund.id, status: res.refund.status };
}

// See /tools/webhooks/signature-verification for the full HMAC implementation
processWebhook(rawBody, timestamp, signatureHeader) {
  return verifyWajubSignature(rawBody, timestamp, signatureHeader, this.webhookSecret);
}
}

const legacyGateway = new LegacyProviderAdapter();
const wajubGateway = new WajubAdapter();

async function initializeCheckout(order) {
// Always send to the old provider
const legacy = await legacyGateway.initializeCheckout(order);

// Dual write to Wajub (sandbox)
if (process.env.WAJUB_DUAL_WRITE === 'true') {
  try {
    const wajub = await wajubGateway.initializeCheckout(order);
    console.log('Wajub (sandbox):', {
      legacyRef: legacy.reference,
      wajubRef: wajub.reference,
    });
  } catch (err) {
    console.error('Wajub dual write skipped:', err.message);
  }
}

// If toggle is on, use Wajub
if (process.env.PAYMENT_PROVIDER === 'wajub') {
  const wajub = await wajubGateway.initializeCheckout(order);
  return wajub.redirectUrl;
}

return legacy.redirectUrl;
}

function shouldUseWajub(orderId) {
const percentage = parseInt(process.env.WAJUB_ROLLOUT_PERCENT, 10) || 0;

// Deterministic hash based on order ID
const hash = crypto
  .createHash('md5')
  .update(orderId)
  .digest('hex');

const bucket = parseInt(hash.slice(0, 8), 16) % 100;
return bucket < percentage;
}

// Usage
const gateway = shouldUseWajub(order.id)
? wajubGateway
: legacyGateway;

const { redirectUrl } = await gateway.initializeCheckout(order);