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

package/src/payments/drivers/mollie-driver-code.ts

@@ -0,0 +1,618 @@
+/**
+ * Emits `utils/payments/drivers/mollie.js`: the Payments API (hosted checkout,
+ * one webhook URL per payment), refunds, and subscriptions through a FIRST
+ * payment that creates the customer's mandate.
+ *
+ * Mollie posts only `id=tr_…` to a webhook and signs nothing: the payment is
+ * always read back with the store's key, and that copy is what the store acts
+ * on. A subscription does not exist until its first payment is paid, so the
+ * webhook that learns of that payment also creates it (idempotently), with
+ * the plan the checkout stored in the payment's metadata.
+ *
+ * A subscription is addressed through its customer, so the store keeps its
+ * provider id as `<customer id>:<subscription id>`.
+ */
+export const generateMollieDriverCode = (): string => `'use strict';
+/**
+ * Mollie driver. Generated by TeleportHQ — changes are overwritten on the next export.
+ */
+module.exports = function createMollieDriver(core) {
+  var API = 'https://api.mollie.com/v2';
+  var MISSING_KEY = 'MOLLIE_API_KEY is not configured';
+  // Mollie's currencies without decimals; every other one takes two.
+  var ZERO_DECIMAL = ['ISK', 'JPY'];
+  // Mollie bills at most once a year.
+  var MAX_INTERVAL_DAYS = 365;
+
+  function apiKey() {
+    return core.credential('mollie', 'apiKey');
+  }
+
+  function amount(major, currency) {
+    var code = String(currency || '').toUpperCase();
+    var value = Number(major);
+    var safe = isFinite(value) && value > 0 ? value : 0;
+    return { currency: code, value: ZERO_DECIMAL.indexOf(code) >= 0 ? String(Math.round(safe)) : safe.toFixed(2) };
+  }
+
+  // A Mollie amount object as a number; 0 when absent.
+  function moneyValue(value) {
+    var number = Number(value && value.value);
+    return isFinite(number) ? number : 0;
+  }
+
+  function problem(data, fallback) {
+    return (data && (data.detail || data.title)) || fallback;
+  }
+
+  async function call(method, path, body, idempotencyKey) {
+    var headers = { Authorization: 'Bearer ' + apiKey(), Accept: 'application/json' };
+    if (body) {
+      headers['Content-Type'] = 'application/json';
+    }
+    if (idempotencyKey) {
+      headers['Idempotency-Key'] = String(idempotencyKey).slice(0, 255);
+    }
+    return core.request(API + path, { method: method, headers: headers, body: body ? JSON.stringify(body) : undefined });
+  }
+
+  // Mollie refuses a payment whose webhook URL it cannot reach, so a local run
+  // creates payments without one (a tunnel URL as the site origin restores it).
+  // Local means this machine, a private network (10/8, 172.16/12, 192.168/16,
+  // link-local, IPv6 unique-local) or a name only that network resolves (one
+  // with no dot, or under .local / .localhost / .internal).
+  function isLocalHost(host) {
+    var name = String(host || '').toLowerCase().replace(/\\.$/, '');
+    if (name.charAt(0) === '[') {
+      return /^\\[(::1?|f[cd][0-9a-f]*:.*|fe80:.*)\\]$/.test(name);
+    }
+    if (name.indexOf('.') === -1 || /\\.(local|localhost|internal)$/.test(name)) {
+      return true;
+    }
+    return /^(127\\.|10\\.|0\\.0\\.0\\.0$|192\\.168\\.|169\\.254\\.|172\\.(1[6-9]|2[0-9]|3[01])\\.)/.test(name);
+  }
+
+  function reachableWebhookUrl(baseUrl) {
+    var url = core.webhookUrl(baseUrl, 'mollie');
+    var host = /^https?:\\/\\/(\\[[^\\]]*\\]|[^/:?#]*)/i.exec(String(url || ''));
+    return !host || isLocalHost(host[1]) ? undefined : url;
+  }
+
+  // "1 month", "14 days": Mollie's interval, or '' for one it cannot bill.
+  function intervalOf(unit, count) {
+    var n = Math.max(1, Math.floor(Number(count) || 1));
+    var name = String(unit || 'month').toLowerCase();
+    if (name === 'year') {
+      name = 'month';
+      n = n * 12;
+    }
+    var days = name === 'day' ? n : name === 'week' ? n * 7 : name === 'month' ? n * 30 : 0;
+    if (!days || days > MAX_INTERVAL_DAYS) {
+      return '';
+    }
+    return n + ' ' + name + (n === 1 ? '' : 's');
+  }
+
+  function addInterval(date, interval) {
+    var parts = interval.split(' ');
+    var n = Number(parts[0]);
+    var unit = parts[1].replace(/s$/, '');
+    var next = new Date(date.getTime());
+    if (unit === 'day') {
+      next.setUTCDate(next.getUTCDate() + n);
+    } else if (unit === 'week') {
+      next.setUTCDate(next.getUTCDate() + n * 7);
+    } else {
+      var day = next.getUTCDate();
+      next.setUTCDate(1);
+      next.setUTCMonth(next.getUTCMonth() + n);
+      var lastDay = new Date(Date.UTC(next.getUTCFullYear(), next.getUTCMonth() + 1, 0)).getUTCDate();
+      next.setUTCDate(Math.min(day, lastDay));
+    }
+    return next;
+  }
+
+  function isoDate(date) {
+    return date.toISOString().slice(0, 10);
+  }
+
+  async function createCheckout(input) {
+    if (!apiKey()) {
+      return { checkoutUrl: '', sessionId: '', error: MISSING_KEY };
+    }
+    try {
+      var answer = await call('POST', '/payments', {
+        amount: amount(input.amount, input.currency),
+        description: String(input.description || 'Order').slice(0, 255),
+        redirectUrl: input.successUrl || undefined,
+        cancelUrl: input.cancelUrl || undefined,
+        webhookUrl: reachableWebhookUrl(input.baseUrl),
+        metadata: input.metadata || undefined,
+      });
+      if (!answer.ok || !answer.data) {
+        return { checkoutUrl: '', sessionId: '', error: problem(answer.data, 'Mollie refused the payment (HTTP ' + answer.status + ')') };
+      }
+      var links = answer.data._links || {};
+      return { checkoutUrl: (links.checkout && links.checkout.href) || '', sessionId: answer.data.id || '' };
+    } catch (err) {
+      return { checkoutUrl: '', sessionId: '', error: core.describeError(err) };
+    }
+  }
+
+  // A subscription opens with a FIRST payment that creates the mandate: the
+  // first cycle (less a gift card), or 0.00 before a free trial. The plan rides
+  // in the payment's metadata for the webhook that creates the subscription.
+  async function createSubscriptionCheckout(input) {
+    if (!apiKey()) {
+      return { checkoutUrl: '', sessionId: '', error: MISSING_KEY };
+    }
+    var interval = intervalOf(input.recurringInterval, input.recurringIntervalCount);
+    if (!interval) {
+      return { checkoutUrl: '', sessionId: '', error: 'Mollie bills a subscription at most once a year.' };
+    }
+    var regular = Number(input.amount);
+    if (!isFinite(regular) || regular <= 0) {
+      return { checkoutUrl: '', sessionId: '', error: 'A subscription needs a positive amount to bill' };
+    }
+    var trialDays = Math.max(0, Math.floor(Number(input.trialDays) || 0));
+    var due = Number(input.amountDue);
+    var firstCharge = trialDays > 0 ? 0 : isFinite(due) && due < regular ? due : regular;
+    if (trialDays === 0 && firstCharge <= 0) {
+      return { checkoutUrl: '', sessionId: '', error: 'A gift card cannot cover the whole first payment of a subscription' };
+    }
+    var metadata = input.metadata || {};
+    try {
+      var customer = await call('POST', '/customers', {
+        email: input.customerEmail ? String(input.customerEmail) : undefined,
+        metadata: { subscriptionId: metadata.subscriptionId || '' },
+      });
+      if (!customer.ok || !customer.data || !customer.data.id) {
+        return { checkoutUrl: '', sessionId: '', error: problem(customer.data, 'Mollie refused the customer (HTTP ' + customer.status + ')') };
+      }
+      var payment = await call('POST', '/payments', {
+        // 0.00 before a trial: Mollie then collects the mandate and debits
+        // nothing, which only a card or PayPal can do.
+        amount: amount(firstCharge, input.currency),
+        method: firstCharge > 0 ? undefined : ['creditcard', 'paypal'],
+        description: String(input.description || 'Subscription').slice(0, 255),
+        redirectUrl: input.successUrl || undefined,
+        cancelUrl: input.cancelUrl || undefined,
+        webhookUrl: reachableWebhookUrl(input.baseUrl),
+        sequenceType: 'first',
+        customerId: customer.data.id,
+        metadata: {
+          orderId: metadata.orderId || '',
+          subscriptionId: metadata.subscriptionId || '',
+          plan: {
+            amount: amount(regular, input.currency).value,
+            currency: String(input.currency).toUpperCase(),
+            interval: interval,
+            trialDays: trialDays,
+            description: String(input.description || 'Subscription').slice(0, 200),
+          },
+        },
+      });
+      if (!payment.ok || !payment.data) {
+        return { checkoutUrl: '', sessionId: '', error: problem(payment.data, 'Mollie refused the payment (HTTP ' + payment.status + ')') };
+      }
+      var links = payment.data._links || {};
+      return { checkoutUrl: (links.checkout && links.checkout.href) || '', sessionId: payment.data.id || '', providerSubscriptionId: '' };
+    } catch (err) {
+      return { checkoutUrl: '', sessionId: '', error: core.describeError(err) };
+    }
+  }
+
+  // What became of a payment the store opened earlier. An open one is paid on
+  // its own checkout page (a bank transfer's instructions included); pending
+  // and authorized ones are on their way; paid is paid; a canceled, expired or
+  // failed payment takes no more money, nor does one Mollie does not know.
+  async function inspectCheckout(input) {
+    var reference = String((input && input.reference) || '').trim();
+    if (reference.indexOf('tr_') !== 0) {
+      return { state: 'closed', checkoutUrl: '' };
+    }
+    if (!apiKey()) {
+      return { state: '', checkoutUrl: '', error: MISSING_KEY };
+    }
+    try {
+      var answer = await call('GET', '/payments/' + encodeURIComponent(reference));
+      if (answer.status === 404 || answer.status === 410) {
+        return { state: 'closed', checkoutUrl: '' };
+      }
+      if (!answer.ok || !answer.data) {
+        return { state: '', checkoutUrl: '', error: problem(answer.data, 'Mollie could not be asked about payment ' + reference) };
+      }
+      var found = paymentState(answer.data);
+      if (found.state === 'open' && !found.checkoutUrl) {
+        return { state: 'confirming', checkoutUrl: '' };
+      }
+      return { state: found.state, checkoutUrl: found.checkoutUrl };
+    } catch (err) {
+      return { state: '', checkoutUrl: '', error: core.describeError(err) };
+    }
+  }
+
+  function paymentState(payment) {
+    var status = String((payment && payment.status) || '');
+    if (status === 'open') {
+      var links = payment._links || {};
+      var page = links.checkout && links.checkout.href ? String(links.checkout.href) : '';
+      return { state: 'open', checkoutUrl: page, openUntil: String(payment.expiresAt || '') };
+    }
+    if (status === 'pending' || status === 'authorized') {
+      return { state: 'confirming', checkoutUrl: '', openUntil: '' };
+    }
+    if (status === 'paid') {
+      return { state: 'paid', checkoutUrl: '', openUntil: '' };
+    }
+    return { state: 'closed', checkoutUrl: '', openUntil: '' };
+  }
+
+  // Closes a payment the order no longer needs. Mollie cancels an open payment
+  // only while it says the payment is cancelable (some methods, for a while);
+  // any other open payment stays payable until it expires, and says when.
+  async function closeCheckout(input) {
+    var reference = String((input && input.reference) || '').trim();
+    if (reference.indexOf('tr_') !== 0) {
+      return { state: 'closed', checkoutUrl: '', openUntil: '' };
+    }
+    if (!apiKey()) {
+      return { state: '', error: MISSING_KEY };
+    }
+    try {
+      var path = '/payments/' + encodeURIComponent(reference);
+      var answer = await call('GET', path);
+      if (answer.status === 404 || answer.status === 410) {
+        return { state: 'closed', checkoutUrl: '', openUntil: '' };
+      }
+      if (!answer.ok || !answer.data) {
+        return { state: '', error: problem(answer.data, 'Mollie could not be asked about payment ' + reference) };
+      }
+      var found = paymentState(answer.data);
+      if (found.state !== 'open' || !answer.data.isCancelable) {
+        return found;
+      }
+      var cancelled = await call('DELETE', path);
+      if (cancelled.ok) {
+        return { state: 'closed', checkoutUrl: '', openUntil: '' };
+      }
+      var again = await call('GET', path);
+      return again.ok && again.data ? paymentState(again.data) : { state: '', error: problem(cancelled.data, 'Mollie did not cancel payment ' + reference) };
+    } catch (err) {
+      return { state: '', error: core.describeError(err) };
+    }
+  }
+
+  // The payments opened for an order around the moment it was placed (they
+  // carry the order in their metadata). Mollie lists payments newest first, so
+  // the list is read back until it passes that moment.
+  async function findCheckouts(input) {
+    var orderId = String((input && input.orderId) || '').trim();
+    var span = core.searchWindow(input && input.placedAt);
+    if (!orderId || !span) {
+      return { error: 'The order to look up names no id or no time it was placed.' };
+    }
+    if (!apiKey()) {
+      return { error: MISSING_KEY };
+    }
+    try {
+      var references = [];
+      var path = '/payments?limit=250';
+      for (var page = 0; page < core.SEARCH_PAGE_LIMIT; page++) {
+        var answer = await call('GET', path);
+        if (!answer.ok || !answer.data) {
+          return { error: problem(answer.data, 'Mollie could not list its payments') };
+        }
+        var payments = answer.data._embedded && Array.isArray(answer.data._embedded.payments) ? answer.data._embedded.payments : [];
+        var passed = false;
+        payments.forEach(function (payment) {
+          var created = new Date(String(payment.createdAt || '')).getTime();
+          if (isFinite(created) && created < span.from) {
+            passed = true;
+            return;
+          }
+          if (payment.id && String(core.readMetadata(payment.metadata).orderId || '') === orderId) {
+            references.push(String(payment.id));
+          }
+        });
+        var next = answer.data._links && answer.data._links.next && answer.data._links.next.href ? String(answer.data._links.next.href) : '';
+        if (passed || !next || payments.length === 0) {
+          return { references: references };
+        }
+        path = next.indexOf(API) === 0 ? next.slice(API.length) : next;
+      }
+      return { error: 'Mollie has more payments since this order was placed than the store can search.' };
+    } catch (err) {
+      return { error: core.describeError(err) };
+    }
+  }
+
+  // Mollie takes the price on the subscription itself: no plan to create.
+  async function ensurePlan() {
+    return { ok: 'true', planId: '', providerProductId: '', created: 'false' };
+  }
+
+  function splitSubscriptionId(value) {
+    var parts = String(value || '').split(':');
+    return parts.length === 2 && parts[0].indexOf('cst_') === 0 && parts[1].indexOf('sub_') === 0
+      ? { customerId: parts[0], subscriptionId: parts[1] }
+      : null;
+  }
+
+  // The customer's subscription the store opened as \`subscriptionId\`, read
+  // through every page; \`{ error }\` when Mollie could not list them, since
+  // an unread list is not an empty one.
+  async function findSubscription(customerId, subscriptionId) {
+    var path = '/customers/' + encodeURIComponent(customerId) + '/subscriptions?limit=250';
+    for (var page = 0; page < core.SEARCH_PAGE_LIMIT; page++) {
+      var answer = await call('GET', path);
+      if (!answer.ok || !answer.data) {
+        return { error: problem(answer.data, 'Mollie could not list the subscriptions of customer ' + customerId + ' (HTTP ' + answer.status + ')') };
+      }
+      var list = (answer.data._embedded && answer.data._embedded.subscriptions) || [];
+      for (var i = 0; i < list.length; i++) {
+        if (core.readMetadata(list[i].metadata).subscriptionId === subscriptionId) {
+          return { subscription: list[i] };
+        }
+      }
+      var next = answer.data._links && answer.data._links.next && answer.data._links.next.href ? String(answer.data._links.next.href) : '';
+      if (!next || list.length === 0) {
+        return { subscription: null };
+      }
+      path = next.indexOf(API) === 0 ? next.slice(API.length) : next;
+    }
+    return { error: 'Mollie lists more subscriptions for customer ' + customerId + ' than the store can read.' };
+  }
+
+  // Creates the subscription a paid FIRST payment opens, once: a replayed
+  // webhook finds the one it created before by the store's subscription id —
+  // cancelled or not, since a cancelled one must never be billed again. The
+  // idempotency key only lasts an hour, so the list decides: one Mollie could
+  // not read fails the activation (Mollie calls again) rather than opening a
+  // second subscription.
+  async function ensureSubscription(payment) {
+    var metadata = core.readMetadata(payment.metadata);
+    var plan = metadata.plan || {};
+    var customerId = String(payment.customerId || '');
+    if (!customerId || !metadata.subscriptionId || !plan.interval) {
+      return { error: 'The Mollie payment ' + payment.id + ' carries no subscription to start.' };
+    }
+    var existing = await findSubscription(customerId, metadata.subscriptionId);
+    if (existing.error || existing.subscription) {
+      return existing;
+    }
+    var paidAt = payment.paidAt ? new Date(payment.paidAt) : new Date();
+    var trialDays = Math.max(0, Math.floor(Number(plan.trialDays) || 0));
+    var start = new Date(paidAt.getTime());
+    if (trialDays > 0) {
+      start.setUTCDate(start.getUTCDate() + trialDays);
+    } else {
+      start = addInterval(start, String(plan.interval));
+    }
+    var subscription = {
+      amount: { currency: String(plan.currency), value: String(plan.amount) },
+      interval: String(plan.interval),
+      // Unique per customer among its active subscriptions.
+      description: String(plan.description || 'Subscription') + ' · ' + String(metadata.subscriptionId).slice(0, 8),
+      // Mollie copies this onto every renewal payment: the first order's id
+      // here would book a renewal's refund on the first order.
+      metadata: { subscriptionId: metadata.subscriptionId },
+      webhookUrl: payment.webhookUrl || undefined,
+    };
+    // A start that is already due (the webhook came, or was retried, after the
+    // paid cycle or the trial ran out) is left out, and Mollie starts the
+    // subscription on its own current date, charging the cycle due now: a
+    // past date is refused, and the refusal would be retried on every
+    // delivery. Only a date after today in UTC is sent, since UTC's today can
+    // still be yesterday where Mollie keeps its calendar.
+    if (isoDate(start) > isoDate(new Date())) {
+      subscription.startDate = isoDate(start);
+    }
+    var created = await call(
+      'POST',
+      '/customers/' + encodeURIComponent(customerId) + '/subscriptions',
+      subscription,
+      'teleport-activate-' + payment.id
+    );
+    if (!created.ok || !created.data) {
+      return { error: problem(created.data, 'Mollie refused the subscription (HTTP ' + created.status + ')') };
+    }
+    return { subscription: created.data };
+  }
+
+  function subscriptionStatus(status) {
+    var map = { active: 'active', pending: 'pending', canceled: 'cancelled', suspended: 'past_due', completed: 'expired' };
+    return map[String(status || '').toLowerCase()] || '';
+  }
+
+  function manageFailure(message) {
+    return { ok: 'false', status: '', cancelAtPeriodEnd: 'false', currentPeriodStart: '', currentPeriodEnd: '', error: message };
+  }
+
+  // Mollie charges each cycle up front and has no pause: a cancellation stops
+  // every later payment at once, the running cycle stays paid.
+  async function manageSubscription(input) {
+    if (!apiKey()) {
+      return manageFailure(MISSING_KEY);
+    }
+    var ids = splitSubscriptionId(input.subscriptionId);
+    if (!ids) {
+      return manageFailure('This is not a Mollie subscription reference.');
+    }
+    if (input.action === 'pause' || input.action === 'resume') {
+      return manageFailure('Mollie cannot pause or resume a subscription; cancel it instead.');
+    }
+    try {
+      var path = '/customers/' + encodeURIComponent(ids.customerId) + '/subscriptions/' + encodeURIComponent(ids.subscriptionId);
+      var answer = await call(input.action === 'refresh' ? 'GET' : 'DELETE', path);
+      if (!answer.ok || !answer.data) {
+        return manageFailure(problem(answer.data, 'Mollie could not ' + (input.action === 'refresh' ? 'read' : 'cancel') + ' the subscription (HTTP ' + answer.status + ')'));
+      }
+      return {
+        ok: 'true',
+        status: subscriptionStatus(answer.data.status),
+        cancelAtPeriodEnd: 'false',
+        currentPeriodStart: '',
+        currentPeriodEnd: answer.data.nextPaymentDate ? new Date(answer.data.nextPaymentDate + 'T00:00:00Z').toISOString() : '',
+      };
+    } catch (err) {
+      return manageFailure(core.describeError(err));
+    }
+  }
+
+  async function billingPortal() {
+    return { ok: 'false', url: '', error: 'Mollie 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;
+  }
+
+  // Mollie always needs an amount: an omitted one refunds what is left on the
+  // payment, read from the payment itself (its own currency, not the request's).
+  async function refund(input) {
+    var currency = String(input.currency || '').toUpperCase();
+    if (!apiKey()) {
+      return refundFailure(currency, MISSING_KEY);
+    }
+    var paymentId = String(input.paymentReference || '').trim();
+    if (paymentId.indexOf('tr_') !== 0) {
+      return refundFailure(currency, 'This is not a Mollie payment reference.');
+    }
+    try {
+      var payment = await call('GET', '/payments/' + encodeURIComponent(paymentId));
+      if (!payment.ok || !payment.data) {
+        return refundFailure(currency, problem(payment.data, 'Mollie could not find the payment ' + paymentId + '.'));
+      }
+      var paymentCurrency = String((payment.data.amount && payment.data.amount.currency) || currency).toUpperCase();
+      var remaining = Number(payment.data.amountRemaining && payment.data.amountRemaining.value);
+      var requested = input.amount > 0 ? input.amount : remaining;
+      if (!isFinite(requested) || requested <= 0) {
+        return refundFailure(paymentCurrency, 'Nothing is left to refund on this Mollie payment.');
+      }
+      var value = amount(requested, paymentCurrency);
+      if (Number(value.value) <= 0) {
+        return refundFailure(paymentCurrency, 'The amount is smaller than the smallest unit of ' + paymentCurrency + '.');
+      }
+      var body = { amount: value };
+      var note = String(input.reason || '').trim();
+      if (note) {
+        body.description = note.slice(0, 255);
+      }
+      if (input.orderId) {
+        body.metadata = { orderId: input.orderId };
+      }
+      var created = await call('POST', '/payments/' + encodeURIComponent(paymentId) + '/refunds', body, input.idempotencyKey);
+      if (!created.ok || !created.data) {
+        return refundFailure(paymentCurrency, problem(created.data, 'Mollie refused the refund (HTTP ' + created.status + ')'));
+      }
+      var status = String(created.data.status || '');
+      if (status === 'failed' || status === 'canceled') {
+        return refundFailure(paymentCurrency, 'Mollie reported the refund as ' + status + '.', { refundId: created.data.id || '', status: status });
+      }
+      return {
+        success: true,
+        refundId: created.data.id || '',
+        amount: Number(created.data.amount && created.data.amount.value) || requested,
+        currency: String((created.data.amount && created.data.amount.currency) || paymentCurrency).toUpperCase(),
+        status: status,
+        error: '',
+      };
+    } catch (err) {
+      return refundFailure(currency, core.describeError(err));
+    }
+  }
+
+  // The payment (with its refunds and chargebacks) read back with the store's
+  // key: the event the webhook hands the store. \`missing\` for an id Mollie
+  // does not know.
+  async function paymentEvent(id) {
+    if (!apiKey()) {
+      return { ok: false, retry: true, reason: MISSING_KEY };
+    }
+    try {
+      var answer = await call('GET', '/payments/' + encodeURIComponent(id) + '?embed=refunds,chargebacks');
+      if (answer.status === 404) {
+        return { ok: false, missing: true, reason: 'Mollie does not know payment ' + id + '.' };
+      }
+      if (!answer.ok || !answer.data || answer.data.id !== id) {
+        return { ok: false, retry: true, reason: problem(answer.data, 'Mollie could not be asked about ' + id + ' (HTTP ' + answer.status + ')') };
+      }
+      var payment = answer.data;
+      // A refund or a chargeback of the first payment calls the same webhook
+      // while the payment still reads "paid": it never starts the billing.
+      var givenBack = moneyValue(payment.amountRefunded) + moneyValue(payment.amountChargedBack);
+      if (payment.status === 'paid' && payment.sequenceType === 'first' && core.readMetadata(payment.metadata).plan && !(givenBack > 0)) {
+        var activation = await ensureSubscription(payment);
+        if (activation.error) {
+          // Answered 503, so Mollie calls again and the activation is retried.
+          return { ok: false, retry: true, reason: activation.error };
+        }
+        payment.teleportSubscription = activation.subscription;
+      }
+      return { ok: true, body: payment };
+    } catch (err) {
+      return { ok: false, retry: true, reason: core.describeError(err) };
+    }
+  }
+
+  // The webhook carries \`id=tr_…\` only. An id Mollie does not know — or an
+  // object the store never asked about — is answered 200 and ignored, as
+  // Mollie requires, so a stranger learns nothing.
+  async function verifyWebhook(input) {
+    var id = String((input.body && input.body.id) || '').trim();
+    if (id.indexOf('tr_') !== 0) {
+      return { ok: true, body: { resource: 'ignored', id: id } };
+    }
+    var read = await paymentEvent(id);
+    return read.missing ? { ok: true, body: { resource: 'ignored', id: id } } : read;
+  }
+
+  // A payment whose webhook never came (a local run gives Mollie no webhook
+  // URL) is settled from Mollie itself, as the webhook would have: nothing
+  // but the payment id comes from the request.
+  var PAYMENT_ID_PATTERN = /^tr_[A-Za-z0-9]{4,64}$/;
+
+  async function reconcile(request) {
+    var kind = String((request && request.kind) || '');
+    var id = String((request && request.id) || '').trim();
+    if (kind !== 'checkout' || !PAYMENT_ID_PATTERN.test(id)) {
+      return { ok: false, reason: 'The request names no Mollie payment to settle.' };
+    }
+    var read = await paymentEvent(id);
+    if (read.missing) {
+      return { ok: false, reason: read.reason };
+    }
+    if (read.ok && read.body.status === 'open') {
+      return { ok: false, reason: 'Mollie payment ' + id + ' is still open.' };
+    }
+    return read;
+  }
+
+  function reconcileKinds(reference) {
+    return PAYMENT_ID_PATTERN.test(String(reference || '').trim()) ? ['checkout'] : [];
+  }
+
+  return {
+    id: 'mollie',
+    createCheckout: createCheckout,
+    createSubscriptionCheckout: createSubscriptionCheckout,
+    inspectCheckout: inspectCheckout,
+    closeCheckout: closeCheckout,
+    findCheckouts: findCheckouts,
+    ensurePlan: ensurePlan,
+    refund: refund,
+    manageSubscription: manageSubscription,
+    billingPortal: billingPortal,
+    reconcile: reconcile,
+    reconcileKinds: reconcileKinds,
+    verifyWebhook: verifyWebhook,
+  };
+};
+`