@teleporthq/teleport-plugin-next-workflows 0.43.67 → 0.43.69

package/dist/esm/payments/drivers/razorpay-driver-code.js

@@ -0,0 +1,728 @@
+/**
+ * Emits `utils/payments/drivers/razorpay.js`: Payment Links for one-time
+ * checkouts, Plans + Subscriptions (authorised on the store's own
+ * `/pay/razorpay` page through Razorpay Checkout, which is the only way the
+ * buyer comes back to the store), refunds, subscription management, and the
+ * `X-Razorpay-Signature` webhook check the store REQUIRES.
+ *
+ * Amounts are integers in the currency's sub-unit; a three-decimal amount must
+ * end in 0, so it is rounded to one.
+ */
+export const generateRazorpayDriverCode = () => `'use strict';
+/**
+ * Razorpay driver. Generated by TeleportHQ — changes are overwritten on the next export.
+ */
+module.exports = function createRazorpayDriver(core) {
+  var API = 'https://api.razorpay.com/v1';
+  var MISSING_KEYS = 'RAZORPAY_KEY_ID and RAZORPAY_KEY_SECRET are not configured';
+  var ZERO_DECIMAL = ['BIF', 'CLP', 'DJF', 'GNF', 'ISK', 'JPY', 'KMF', 'KRW', 'PYG', 'RWF', 'UGX', 'VND', 'VUV', 'XAF', 'XOF', 'XPF'];
+  var THREE_DECIMAL = ['BHD', 'IQD', 'JOD', 'KWD', 'OMR', 'TND'];
+  var PERIODS = { day: 'daily', week: 'weekly', month: 'monthly', year: 'yearly' };
+  // A plan billed every day must bill at most once a week.
+  var MIN_DAILY_INTERVAL = 7;
+  // Razorpay needs a cycle count; a subscription may run up to 100 years.
+  var MAX_SUBSCRIPTION_YEARS = 99;
+  // An unpaid link expires after a day, so its stock is released.
+  var LINK_LIFETIME_SECONDS = 24 * 60 * 60;
+  // How many times an order's link may be opened again after the one before
+  // it expired or was cancelled: each carries the order's reference with its
+  // number (\`-1\`, \`-2\`, …), so the links of an order can be searched.
+  var LINK_REISSUE_LIMIT = 20;
+  // A subscription in either status has not started its first billing cycle.
+  var BEFORE_FIRST_CYCLE = { created: true, authenticated: true };
+  var PAUSE_ONLY_ACTIVE =
+    'Razorpay can pause only an active subscription: one still in its free trial would be cancelled for good, and one with a payment due cannot be paused.';
+  var CANCELLED_BEFORE_FIRST_CYCLE =
+    'Razorpay cannot schedule a cancellation before the first billing cycle has started, so the subscription was cancelled immediately. No payment will be taken.';
+
+  function keys() {
+    return { keyId: core.credential('razorpay', 'keyId'), keySecret: core.credential('razorpay', 'keySecret') };
+  }
+
+  function configured() {
+    var k = keys();
+    return !!(k.keyId && k.keySecret);
+  }
+
+  function minor(major, currency) {
+    var code = String(currency || '').toUpperCase();
+    var value = Number(major);
+    if (!isFinite(value) || value <= 0) {
+      return 0;
+    }
+    if (ZERO_DECIMAL.indexOf(code) >= 0) {
+      return Math.round(value);
+    }
+    if (THREE_DECIMAL.indexOf(code) >= 0) {
+      return Math.round((value * 1000) / 10) * 10;
+    }
+    return Math.round(value * 100);
+  }
+
+  function major(minorValue, currency) {
+    var code = String(currency || '').toUpperCase();
+    var value = Number(minorValue);
+    if (!isFinite(value)) {
+      return 0;
+    }
+    return ZERO_DECIMAL.indexOf(code) >= 0 ? value : THREE_DECIMAL.indexOf(code) >= 0 ? value / 1000 : value / 100;
+  }
+
+  function problem(data, fallback) {
+    return (data && data.error && (data.error.description || data.error.reason)) || fallback;
+  }
+
+  async function call(method, path, body, headers) {
+    var k = keys();
+    var allHeaders = {
+      Authorization: 'Basic ' + Buffer.from(k.keyId + ':' + k.keySecret).toString('base64'),
+      'Content-Type': 'application/json',
+    };
+    Object.keys(headers || {}).forEach(function (name) {
+      allHeaders[name] = headers[name];
+    });
+    return core.request(API + path, { method: method, headers: allHeaders, body: body ? JSON.stringify(body) : undefined });
+  }
+
+  // Notes carry at most 15 values of 255 characters each.
+  function notes(metadata) {
+    var result = {};
+    Object.keys(metadata || {}).slice(0, 15).forEach(function (key) {
+      var value = metadata[key];
+      if (value !== undefined && value !== null && typeof value !== 'object') {
+        result[key] = String(value).slice(0, 255);
+      }
+    });
+    return result;
+  }
+
+  // A link the buyer can still pay; any other status is final.
+  var PAYABLE_LINK_STATUSES = { created: true, partially_paid: true };
+
+  // A link's reference must be unique: a retried place-order finds the link it
+  // created before instead of failing on the duplicate.
+  async function findLinkByReference(reference) {
+    var answer = await call('GET', '/payment_links?reference_id=' + encodeURIComponent(reference));
+    var links = answer.ok && answer.data && Array.isArray(answer.data.payment_links) ? answer.data.payment_links : [];
+    return links.length > 0 ? links[0] : null;
+  }
+
+  // The reference of the order's link opened again for the \`n\`th time.
+  function reissuedReference(reference, n) {
+    return reference.slice(0, 32) + '-' + n;
+  }
+
+  function isDuplicateReference(answer) {
+    return !answer.ok && /reference/i.test(problem(answer.data, ''));
+  }
+
+  async function createCheckout(input) {
+    if (!configured()) {
+      return { checkoutUrl: '', sessionId: '', error: MISSING_KEYS };
+    }
+    var metadata = input.metadata || {};
+    var reference = String(metadata.orderId || '').slice(0, 40);
+    var amountMinor = minor(input.amount, input.currency);
+    if (amountMinor <= 0) {
+      return { checkoutUrl: '', sessionId: '', error: 'A payment needs a positive amount.' };
+    }
+    try {
+      var body = {
+        amount: amountMinor,
+        currency: String(input.currency || '').toUpperCase(),
+        description: String(input.description || 'Order').slice(0, 2048),
+        expire_by: Math.floor(Date.now() / 1000) + LINK_LIFETIME_SECONDS,
+        notes: notes(metadata),
+      };
+      if (reference) {
+        body.reference_id = reference;
+      }
+      if (input.successUrl) {
+        body.callback_url = input.successUrl;
+        body.callback_method = 'get';
+      }
+      var answer = await call('POST', '/payment_links', body);
+      var link = answer.ok ? answer.data : null;
+      if (!link && reference && isDuplicateReference(answer)) {
+        link = await findLinkByReference(reference);
+        // The order's first link expired or was cancelled (a buyer coming back
+        // to pay later): a new link carries the reference numbered, the next
+        // number not taken yet, or the link under a number that still takes
+        // money. The webhook names the order from the link's notes, which
+        // still carry its id.
+        for (var n = 1; n <= LINK_REISSUE_LIMIT && link && !PAYABLE_LINK_STATUSES[String(link.status || '')]; n++) {
+          body.reference_id = reissuedReference(reference, n);
+          answer = await call('POST', '/payment_links', body);
+          link = answer.ok ? answer.data : null;
+          if (!link && isDuplicateReference(answer)) {
+            link = await findLinkByReference(body.reference_id);
+          } else if (!link) {
+            break;
+          }
+        }
+        if (link && !PAYABLE_LINK_STATUSES[String(link.status || '')]) {
+          return { checkoutUrl: '', sessionId: '', error: 'This order has opened more Razorpay payment links than the store allows.' };
+        }
+      }
+      if (!link || !link.short_url) {
+        return { checkoutUrl: '', sessionId: '', error: problem(answer.data, 'Razorpay refused the payment link (HTTP ' + answer.status + ')') };
+      }
+      return { checkoutUrl: String(link.short_url), sessionId: String(link.id || '') };
+    } catch (err) {
+      return { checkoutUrl: '', sessionId: '', error: core.describeError(err) };
+    }
+  }
+
+  // What became of a payment link the store opened earlier: one still taking
+  // money is paid on its own page, a paid one is paid, and an expired or
+  // cancelled one (or one Razorpay does not know) takes no more.
+  async function inspectCheckout(input) {
+    var reference = String((input && input.reference) || '').trim();
+    if (reference.indexOf('plink_') !== 0) {
+      return { state: 'closed', checkoutUrl: '' };
+    }
+    if (!configured()) {
+      return { state: '', checkoutUrl: '', error: MISSING_KEYS };
+    }
+    try {
+      var answer = await call('GET', '/payment_links/' + encodeURIComponent(reference));
+      if (isUnknown(answer)) {
+        return { state: 'closed', checkoutUrl: '' };
+      }
+      if (!answer.ok || !answer.data) {
+        return { state: '', checkoutUrl: '', error: problem(answer.data, 'Razorpay could not be asked about payment link ' + reference) };
+      }
+      var status = String(answer.data.status || '');
+      if (PAYABLE_LINK_STATUSES[status]) {
+        return answer.data.short_url ? { state: 'open', checkoutUrl: String(answer.data.short_url) } : { state: 'confirming', checkoutUrl: '' };
+      }
+      return { state: status === 'paid' ? 'paid' : 'closed', checkoutUrl: '' };
+    } catch (err) {
+      return { state: '', checkoutUrl: '', error: core.describeError(err) };
+    }
+  }
+
+  function isUnknown(answer) {
+    return answer.status === 404 || (answer.status === 400 && /not.*(found|exist)|invalid.*id/i.test(problem(answer.data, '')));
+  }
+
+  // A link or subscription status as a checkout state: \`created\` still takes
+  // money; a link paid in part, or a subscription the buyer authorised, took some.
+  var LINK_TAKEN = { paid: 'paid', partially_paid: 'confirming' };
+  var SUBSCRIPTION_TAKEN = { authenticated: 'paid', active: 'paid', pending: 'paid', halted: 'paid', paused: 'paid' };
+
+  function checkoutState(isLink, status) {
+    if (status === 'created') {
+      return 'open';
+    }
+    return (isLink ? LINK_TAKEN : SUBSCRIPTION_TAKEN)[status] || 'closed';
+  }
+
+  // Closes a checkout the order no longer needs: a payment link still taking
+  // money is cancelled, and so is a subscription nobody authorised yet.
+  async function closeCheckout(input) {
+    var reference = String((input && input.reference) || '').trim();
+    var isLink = reference.indexOf('plink_') === 0;
+    if (!isLink && reference.indexOf('sub_') !== 0) {
+      return { state: 'closed', checkoutUrl: '', openUntil: '' };
+    }
+    if (!configured()) {
+      return { state: '', error: MISSING_KEYS };
+    }
+    try {
+      var path = (isLink ? '/payment_links/' : '/subscriptions/') + encodeURIComponent(reference);
+      var answer = await call('GET', path);
+      if (isUnknown(answer)) {
+        return { state: 'closed', checkoutUrl: '', openUntil: '' };
+      }
+      if (!answer.ok || !answer.data) {
+        return { state: '', error: problem(answer.data, 'Razorpay could not be asked about ' + reference) };
+      }
+      var state = checkoutState(isLink, String(answer.data.status || ''));
+      if (state !== 'open') {
+        return { state: state, checkoutUrl: '', openUntil: '' };
+      }
+      var cancelled = await call('POST', path + '/cancel');
+      if (cancelled.ok) {
+        return { state: 'closed', checkoutUrl: '', openUntil: '' };
+      }
+      // Paid between the read and the cancellation: answer what it became.
+      var again = await call('GET', path);
+      var after = again.ok && again.data ? checkoutState(isLink, String(again.data.status || '')) : '';
+      return after && after !== 'open'
+        ? { state: after, checkoutUrl: '', openUntil: '' }
+        : { state: '', error: problem(cancelled.data, 'Razorpay did not cancel ' + reference) };
+    } catch (err) {
+      return { state: '', error: core.describeError(err) };
+    }
+  }
+
+  // The payment link the order's placing opened carries the order as its
+  // reference, which Razorpay looks up directly; a link opened again after it
+  // carries the reference numbered, and the numbers are taken in turn, so the
+  // search stops at the first one no link carries.
+  async function findCheckouts(input) {
+    var orderId = String((input && input.orderId) || '').trim();
+    if (!orderId) {
+      return { error: 'The order to look up names no id.' };
+    }
+    if (!configured()) {
+      return { error: MISSING_KEYS };
+    }
+    try {
+      var reference = orderId.slice(0, 40);
+      var references = [];
+      for (var n = 0; n <= LINK_REISSUE_LIMIT; n++) {
+        var wanted = n === 0 ? reference : reissuedReference(reference, n);
+        var answer = await call('GET', '/payment_links?reference_id=' + encodeURIComponent(wanted));
+        if (!answer.ok || !answer.data) {
+          return { error: problem(answer.data, 'Razorpay could not look up the payment links of order ' + orderId) };
+        }
+        var links = Array.isArray(answer.data.payment_links) ? answer.data.payment_links : [];
+        if (links.length === 0) {
+          break;
+        }
+        links.forEach(function (link) {
+          if (link && link.id) {
+            references.push(String(link.id));
+          }
+        });
+      }
+      return { references: references };
+    } catch (err) {
+      return { error: core.describeError(err) };
+    }
+  }
+
+  function planFailure(message) {
+    return { ok: 'false', planId: '', providerProductId: '', created: 'false', error: message };
+  }
+
+  // Plans are immutable, so one is created per product and price and cached
+  // by the workflow (\`teleport_provider_plans\`). A plan belongs to the mode
+  // of the keys that created it: a cached plan the current keys do not know
+  // (the store moved between test and live keys) is created again under
+  // them. A cached plan that cannot be checked right now is used as it is.
+  async function ensurePlan(input) {
+    if (!configured()) {
+      return planFailure(MISSING_KEYS);
+    }
+    var cached = String(input.planId || '').trim();
+    if (cached) {
+      try {
+        var known = await call('GET', '/plans/' + encodeURIComponent(cached));
+        if (!isUnknown(known)) {
+          return { ok: 'true', planId: cached, providerProductId: '', created: 'false' };
+        }
+      } catch (_err) {
+        return { ok: 'true', planId: cached, providerProductId: '', created: 'false' };
+      }
+    }
+    var period = PERIODS[String(input.interval || 'month').toLowerCase()];
+    if (!period) {
+      return planFailure('Unknown billing interval "' + input.interval + '".');
+    }
+    var interval = Math.max(1, Math.floor(Number(input.intervalCount) || 1));
+    if (period === 'daily' && interval < MIN_DAILY_INTERVAL) {
+      return planFailure('Razorpay bills a daily plan at most once every ' + MIN_DAILY_INTERVAL + ' days.');
+    }
+    var amountMinor = minor(input.amount, input.currency);
+    if (amountMinor <= 0) {
+      return planFailure('A subscription needs a positive amount to bill.');
+    }
+    try {
+      var answer = await call('POST', '/plans', {
+        period: period,
+        interval: interval,
+        item: {
+          name: String(input.productName || 'Subscription').slice(0, 255),
+          amount: amountMinor,
+          currency: String(input.currency || '').toUpperCase(),
+        },
+        notes: notes({ productId: input.productId || '' }),
+      });
+      if (!answer.ok || !answer.data || !answer.data.id) {
+        return planFailure(problem(answer.data, 'Razorpay refused the plan (HTTP ' + answer.status + ')'));
+      }
+      return { ok: 'true', planId: String(answer.data.id), providerProductId: '', created: 'true' };
+    } catch (err) {
+      return planFailure(core.describeError(err));
+    }
+  }
+
+  function cyclesIn(years, unit, count) {
+    var perYear = { day: 365, week: 52, month: 12, year: 1 }[unit] || 12;
+    return Math.max(1, Math.floor((years * perYear) / Math.max(1, count)));
+  }
+
+  // The buyer authorises the subscription on the store's own page (Razorpay
+  // Checkout needs the subscription id and the public key id), which returns
+  // them to the order page. A trial starts the billing later; Razorpay then
+  // takes a small authorisation charge it refunds itself.
+  async function createSubscriptionCheckout(input) {
+    if (!configured()) {
+      return { checkoutUrl: '', sessionId: '', error: MISSING_KEYS };
+    }
+    var planId = String(input.planId || '').trim();
+    if (!planId) {
+      return { checkoutUrl: '', sessionId: '', error: 'No Razorpay plan was supplied for the subscription' };
+    }
+    var regular = Number(input.amount);
+    var due = Number(input.amountDue);
+    if (isFinite(due) && due < regular) {
+      return { checkoutUrl: '', sessionId: '', error: 'Razorpay cannot take a gift card toward a subscription payment.' };
+    }
+    var unit = String(input.recurringInterval || 'month').toLowerCase();
+    var count = Math.max(1, Math.floor(Number(input.recurringIntervalCount) || 1));
+    var trialDays = Math.max(0, Math.floor(Number(input.trialDays) || 0));
+    var metadata = input.metadata || {};
+    var now = Math.floor(Date.now() / 1000);
+    try {
+      var body = {
+        plan_id: planId,
+        total_count: cyclesIn(MAX_SUBSCRIPTION_YEARS, unit, count),
+        quantity: 1,
+        customer_notify: false,
+        // The buyer has a day to authorise it, as long as an unpaid link
+        // stays open; left out, Razorpay would keep it open for 30 years.
+        expire_by: now + LINK_LIFETIME_SECONDS,
+        notes: notes({
+          orderId: metadata.orderId,
+          subscriptionId: metadata.subscriptionId,
+          successUrl: input.successUrl,
+          cancelUrl: input.cancelUrl,
+        }),
+      };
+      if (trialDays > 0) {
+        body.start_at = now + trialDays * 24 * 60 * 60;
+        // Never past the moment the trial ends and billing starts.
+        body.expire_by = Math.min(body.expire_by, body.start_at);
+      }
+      var answer = await call('POST', '/subscriptions', body);
+      if (!answer.ok || !answer.data || !answer.data.id) {
+        return { checkoutUrl: '', sessionId: '', error: problem(answer.data, 'Razorpay refused the subscription (HTTP ' + answer.status + ')') };
+      }
+      var subscriptionId = String(answer.data.id);
+      return {
+        checkoutUrl: core.absoluteUrl('/pay/razorpay?subscription=' + encodeURIComponent(subscriptionId), input.baseUrl),
+        sessionId: subscriptionId,
+        providerSubscriptionId: subscriptionId,
+      };
+    } catch (err) {
+      return { checkoutUrl: '', sessionId: '', error: core.describeError(err) };
+    }
+  }
+
+  function unixToIso(value) {
+    var seconds = Number(value);
+    return isFinite(seconds) && seconds > 0 ? new Date(seconds * 1000).toISOString() : '';
+  }
+
+  function subscriptionStatus(status) {
+    var map = {
+      created: 'pending',
+      authenticated: 'trialing',
+      active: 'active',
+      pending: 'past_due',
+      halted: 'past_due',
+      paused: 'paused',
+      cancelled: 'cancelled',
+      completed: 'expired',
+      expired: 'expired',
+    };
+    return map[String(status || '').toLowerCase()] || '';
+  }
+
+  function manageFailure(message) {
+    return { ok: 'false', status: '', cancelAtPeriodEnd: 'false', currentPeriodStart: '', currentPeriodEnd: '', error: message };
+  }
+
+  // A pause and a cancellation at the cycle end read the subscription first:
+  // Razorpay pauses only an active one (a paused trial is cancelled for
+  // good), and schedules no cancellation before the first cycle has started,
+  // so a subscription still in its trial is cancelled at once and says so.
+  async function manageSubscription(input) {
+    if (!configured()) {
+      return manageFailure(MISSING_KEYS);
+    }
+    var path = '/subscriptions/' + encodeURIComponent(input.subscriptionId);
+    try {
+      var current = '';
+      if (input.action === 'pause' || input.action === 'cancel_at_period_end') {
+        var read = await call('GET', path);
+        if (!read.ok || !read.data) {
+          return manageFailure(problem(read.data, 'Razorpay could not read the subscription (HTTP ' + read.status + ')'));
+        }
+        current = String(read.data.status || '');
+      }
+      if (input.action === 'pause' && current !== 'active') {
+        return manageFailure(PAUSE_ONLY_ACTIVE);
+      }
+      var schedulesCancel = input.action === 'cancel_at_period_end' && !BEFORE_FIRST_CYCLE[current];
+      var answer;
+      if (input.action === 'refresh') {
+        answer = await call('GET', path);
+      } else if (input.action === 'cancel' || input.action === 'cancel_at_period_end') {
+        answer = await call('POST', path + '/cancel', { cancel_at_cycle_end: schedulesCancel });
+      } else if (input.action === 'pause') {
+        answer = await call('POST', path + '/pause', { pause_at: 'now' });
+      } else {
+        answer = await call('POST', path + '/resume', { resume_at: 'now' });
+      }
+      if (!answer.ok || !answer.data) {
+        return manageFailure(problem(answer.data, 'Razorpay refused the change (HTTP ' + answer.status + ')'));
+      }
+      var subscription = answer.data;
+      var scheduled = schedulesCancel || (!!subscription.has_scheduled_changes && subscription.status !== 'cancelled');
+      var result = {
+        ok: 'true',
+        status: subscriptionStatus(subscription.status),
+        cancelAtPeriodEnd: scheduled && subscription.status !== 'cancelled' ? 'true' : 'false',
+        currentPeriodStart: unixToIso(subscription.current_start),
+        currentPeriodEnd: unixToIso(subscription.current_end || subscription.charge_at),
+      };
+      if (input.action === 'cancel_at_period_end' && !schedulesCancel) {
+        result.message = CANCELLED_BEFORE_FIRST_CYCLE;
+      }
+      return result;
+    } catch (err) {
+      return manageFailure(core.describeError(err));
+    }
+  }
+
+  async function billingPortal() {
+    return { ok: 'false', url: '', error: 'Razorpay has no billing page for subscribers.' };
+  }
+
+  function refundFailure(currency, message, extra) {
+    var result = { success: false, refundId: '', amount: 0, currency: currency, status: '', error: message };
+    if (extra) {
+      Object.keys(extra).forEach(function (key) {
+        result[key] = extra[key];
+      });
+    }
+    return result;
+  }
+
+  // Refunds pay out of the merchant's Razorpay balance. The idempotency header
+  // takes letters, digits, hyphens and underscores, 10 or more.
+  async function refund(input) {
+    var currency = String(input.currency || '').toUpperCase();
+    if (!configured()) {
+      return refundFailure(currency, MISSING_KEYS);
+    }
+    var paymentId = String(input.paymentReference || '').trim();
+    try {
+      if (paymentId.indexOf('plink_') === 0) {
+        var link = await call('GET', '/payment_links/' + encodeURIComponent(paymentId));
+        var payments = link.ok && link.data && Array.isArray(link.data.payments) ? link.data.payments : [];
+        paymentId = payments.length > 0 ? String(payments[0].payment_id || '') : '';
+      }
+      if (paymentId.indexOf('pay_') !== 0) {
+        return refundFailure(currency, 'This order has no captured Razorpay payment to refund.');
+      }
+      var body = { notes: notes({ orderId: input.orderId, reason: input.reason }) };
+      if (input.amount > 0) {
+        var amountMinor = minor(input.amount, currency);
+        if (amountMinor <= 0) {
+          return refundFailure(currency, 'The amount is smaller than the smallest unit of ' + currency + '.');
+        }
+        body.amount = amountMinor;
+      }
+      var key = String(input.idempotencyKey || '').replace(/[^A-Za-z0-9_-]/g, '-');
+      var answer = await call('POST', '/payments/' + encodeURIComponent(paymentId) + '/refund', body, {
+        'X-Refund-Idempotency': key.length >= 10 ? key.slice(0, 64) : (key + '-refund-key').slice(0, 64),
+      });
+      if (!answer.ok || !answer.data) {
+        return refundFailure(currency, problem(answer.data, 'Razorpay refused the refund (HTTP ' + answer.status + ')'));
+      }
+      var created = answer.data;
+      var refundCurrency = String(created.currency || currency).toUpperCase();
+      if (created.status === 'failed') {
+        return refundFailure(refundCurrency, 'Razorpay reported the refund as failed.', { refundId: created.id || '', status: 'failed' });
+      }
+      return {
+        success: true,
+        refundId: created.id || '',
+        amount: major(created.amount, refundCurrency),
+        currency: refundCurrency,
+        status: String(created.status || ''),
+        error: '',
+      };
+    } catch (err) {
+      return refundFailure(currency, core.describeError(err));
+    }
+  }
+
+  // A checkout whose webhook never came (no webhook set up for this store's
+  // address, a wrong secret) is settled from Razorpay itself: the link or the
+  // subscription is READ with the store's keys and answered as the event
+  // Razorpay sends for its current state. Nothing but its id comes from the
+  // request.
+  var LINK_ID_PATTERN = /^plink_[A-Za-z0-9]{6,40}$/;
+  var SUBSCRIPTION_ID_PATTERN = /^sub_[A-Za-z0-9]{6,40}$/;
+
+  // \`entities\` by payload name, as Razorpay's own event carries them.
+  function settledEvent(name, entities) {
+    var payload = {};
+    Object.keys(entities).forEach(function (key) {
+      payload[key] = { entity: entities[key] };
+    });
+    return {
+      ok: true,
+      body: { entity: 'event', event: name, contains: Object.keys(entities), payload: payload, created_at: Math.floor(Date.now() / 1000) },
+    };
+  }
+
+  function unanswered(answer, fallback) {
+    return { ok: false, retry: answer.status >= 500 || answer.status === 429, reason: problem(answer.data, fallback) };
+  }
+
+  async function readPayment(paymentId) {
+    var answer = await call('GET', '/payments/' + encodeURIComponent(paymentId));
+    return answer.ok && answer.data ? { entity: answer.data } : { failure: unanswered(answer, 'Razorpay could not be asked about payment ' + paymentId) };
+  }
+
+  // The payment that paid a link: its latest attempt that did not fail (a
+  // failed one stays listed beside it).
+  function linkPaymentId(link) {
+    var payments = Array.isArray(link.payments) ? link.payments : [];
+    for (var i = payments.length - 1; i >= 0; i--) {
+      if (payments[i] && payments[i].payment_id && payments[i].status !== 'failed') {
+        return String(payments[i].payment_id);
+      }
+    }
+    return '';
+  }
+
+  async function settleLink(linkId) {
+    var answer = await call('GET', '/payment_links/' + encodeURIComponent(linkId));
+    if (!answer.ok || !answer.data) {
+      return unanswered(answer, 'Razorpay could not be asked about payment link ' + linkId);
+    }
+    var link = answer.data;
+    var status = String(link.status || '');
+    if (status === 'expired' || status === 'cancelled') {
+      return settledEvent('payment_link.' + status, { payment_link: link });
+    }
+    var paymentId = status === 'paid' ? linkPaymentId(link) : '';
+    if (!paymentId) {
+      return { ok: false, reason: 'Razorpay payment link ' + linkId + ' is ' + (status || 'not paid') + ', with no payment to settle.' };
+    }
+    var payment = await readPayment(paymentId);
+    return payment.failure || settledEvent('payment_link.paid', { payment_link: link, payment: payment.entity });
+  }
+
+  // A subscription the buyer authorised before a trial answers that mandate;
+  // one charged since answers its FIRST charge (the earliest paid invoice),
+  // which pays the order.
+  async function settleSubscription(subscriptionId) {
+    var answer = await call('GET', '/subscriptions/' + encodeURIComponent(subscriptionId));
+    if (!answer.ok || !answer.data) {
+      return unanswered(answer, 'Razorpay could not be asked about subscription ' + subscriptionId);
+    }
+    var subscription = answer.data;
+    var status = String(subscription.status || '');
+    if (status === 'authenticated') {
+      return settledEvent('subscription.authenticated', { subscription: subscription });
+    }
+    if (status === 'created') {
+      return { ok: false, reason: 'Razorpay subscription ' + subscriptionId + ' is not authorised yet.' };
+    }
+    var invoices = await call('GET', '/invoices?subscription_id=' + encodeURIComponent(subscriptionId) + '&count=100');
+    if (!invoices.ok || !invoices.data) {
+      return unanswered(invoices, 'Razorpay could not list the invoices of subscription ' + subscriptionId);
+    }
+    var first = (Array.isArray(invoices.data.items) ? invoices.data.items : [])
+      .filter(function (invoice) {
+        return invoice && invoice.status === 'paid' && invoice.payment_id;
+      })
+      .sort(function (a, b) {
+        return Number(a.paid_at || a.created_at || 0) - Number(b.paid_at || b.created_at || 0);
+      })[0];
+    if (!first) {
+      return { ok: false, reason: 'Razorpay has not charged subscription ' + subscriptionId + ' yet.' };
+    }
+    var payment = await readPayment(String(first.payment_id));
+    return payment.failure || settledEvent('subscription.charged', { subscription: subscription, payment: payment.entity });
+  }
+
+  async function reconcile(request) {
+    var kind = String((request && request.kind) || '');
+    var id = String((request && request.id) || '').trim();
+    var isLink = LINK_ID_PATTERN.test(id);
+    if (kind !== 'checkout' || (!isLink && !SUBSCRIPTION_ID_PATTERN.test(id))) {
+      return { ok: false, reason: 'The request names no Razorpay checkout to settle.' };
+    }
+    if (!configured()) {
+      return { ok: false, retry: true, reason: MISSING_KEYS };
+    }
+    try {
+      return isLink ? await settleLink(id) : await settleSubscription(id);
+    } catch (err) {
+      return { ok: false, retry: true, reason: core.describeError(err) };
+    }
+  }
+
+  function reconcileKinds(reference) {
+    var id = String(reference || '').trim();
+    return LINK_ID_PATTERN.test(id) || SUBSCRIPTION_ID_PATTERN.test(id) ? ['checkout'] : [];
+  }
+
+  // Signed with the webhook secret the merchant chose in the Razorpay
+  // Dashboard (not the key secret), over the raw body.
+  async function verifyWebhook(input) {
+    var secret = input.secret || core.credential('razorpay', 'webhookSecret');
+    if (!secret) {
+      return { ok: false, reason: 'The Razorpay webhook secret (RAZORPAY_WEBHOOK_SECRET) is not configured.' };
+    }
+    var signature = core.header(input.headers, 'x-razorpay-signature');
+    if (!signature) {
+      return { ok: false, reason: 'The X-Razorpay-Signature header is missing.' };
+    }
+    return core.safeEqual(core.hmac('sha256', secret, input.rawBody, 'hex'), signature)
+      ? { ok: true, body: input.body }
+      : { ok: false, reason: 'The Razorpay signature does not match the webhook secret.' };
+  }
+
+  // What the store's \`/pay/razorpay\` page needs to open Razorpay Checkout for
+  // a subscription: the PUBLIC key id, and where the buyer goes afterwards.
+  // Only a subscription still waiting for its authorisation (\`created\`) is
+  // opened; any other was authorised, cancelled or expired already.
+  async function checkoutPage(subscriptionId) {
+    var id = String(subscriptionId || '').trim();
+    if (id.indexOf('sub_') !== 0 || !configured()) {
+      return null;
+    }
+    var answer = await call('GET', '/subscriptions/' + encodeURIComponent(id));
+    if (!answer.ok || !answer.data || answer.data.status !== 'created') {
+      return null;
+    }
+    var saved = answer.data.notes && typeof answer.data.notes === 'object' ? answer.data.notes : {};
+    return {
+      subscriptionId: id,
+      keyId: keys().keyId,
+      successUrl: String(saved.successUrl || ''),
+      cancelUrl: String(saved.cancelUrl || ''),
+    };
+  }
+
+  return {
+    id: 'razorpay',
+    createCheckout: createCheckout,
+    createSubscriptionCheckout: createSubscriptionCheckout,
+    inspectCheckout: inspectCheckout,
+    closeCheckout: closeCheckout,
+    findCheckouts: findCheckouts,
+    ensurePlan: ensurePlan,
+    refund: refund,
+    manageSubscription: manageSubscription,
+    billingPortal: billingPortal,
+    reconcile: reconcile,
+    reconcileKinds: reconcileKinds,
+    verifyWebhook: verifyWebhook,
+    checkoutPage: checkoutPage,
+  };
+};
+`;
+//# sourceMappingURL=razorpay-driver-code.js.map