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

package/dist/cjs/payments/drivers/paddle-driver-code.js

@@ -0,0 +1,683 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePaddleDriverCode = void 0;
+/**
+ * Emits `utils/payments/drivers/paddle.js`: Paddle Billing, the merchant of
+ * record. A checkout is a transaction of non-catalog items opened by Paddle.js
+ * on the store's own `/pay/paddle` page; subscriptions, refunds (adjustments,
+ * which Paddle may have to approve) and the customer portal go through the
+ * API; webhooks carry a `Paddle-Signature` the store REQUIRES.
+ *
+ * Prices are sent tax-inclusive: the buyer pays exactly the store's total and
+ * Paddle, as the seller, remits the tax out of it.
+ */
+const generatePaddleDriverCode = () => `'use strict';
+/**
+ * Paddle driver. Generated by TeleportHQ — changes are overwritten on the next export.
+ */
+module.exports = function createPaddleDriver(core) {
+  var LIVE = 'https://api.paddle.com';
+  var SANDBOX = 'https://sandbox-api.paddle.com';
+  var MISSING_KEY = 'PADDLE_API_KEY is not configured';
+  // Paddle's currencies without decimals.
+  var ZERO_DECIMAL = ['CLP', 'JPY', 'KRW', 'VND'];
+  // A signature older than this is refused. Paddle's SDKs use five seconds; a
+  // retried delivery may reuse its first timestamp, so the store allows more.
+  var SIGNATURE_TOLERANCE_SECONDS = 300;
+  var INTERVALS = ['day', 'week', 'month', 'year'];
+
+  function apiKey() {
+    return core.credential('paddle', 'apiKey');
+  }
+
+  function clientToken() {
+    return core.credential('paddle', 'clientToken');
+  }
+
+  // Current keys name their environment; a legacy key (no prefix) follows the
+  // client-side token, which always does.
+  function isSandbox() {
+    var key = apiKey();
+    if (key.indexOf('pdl_sdbx_') === 0) {
+      return true;
+    }
+    if (key.indexOf('pdl_live_') === 0) {
+      return false;
+    }
+    return clientToken().indexOf('test_') === 0;
+  }
+
+  function minor(major, currency) {
+    var code = String(currency || '').toUpperCase();
+    var value = Number(major);
+    if (!isFinite(value) || value <= 0) {
+      return '0';
+    }
+    return String(Math.round(ZERO_DECIMAL.indexOf(code) >= 0 ? value : value * 100));
+  }
+
+  function major(minorValue, currency) {
+    var value = Number(minorValue);
+    if (!isFinite(value)) {
+      return 0;
+    }
+    return ZERO_DECIMAL.indexOf(String(currency || '').toUpperCase()) >= 0 ? value : value / 100;
+  }
+
+  function problem(data, fallback) {
+    var error = data && data.error;
+    if (!error) {
+      return fallback;
+    }
+    var fields = Array.isArray(error.errors)
+      ? error.errors.map(function (entry) {
+          return entry.field + ' ' + entry.message;
+        })
+      : [];
+    return (error.detail || fallback) + (fields.length ? ' (' + fields.join('; ') + ')' : '');
+  }
+
+  async function call(method, path, body) {
+    return core.request((isSandbox() ? SANDBOX : LIVE) + path, {
+      method: method,
+      headers: {
+        Authorization: 'Bearer ' + apiKey(),
+        'Content-Type': 'application/json',
+        'Paddle-Version': '1',
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+  }
+
+  function taxCategory() {
+    return core.credential('paddle', 'taxCategory') || 'standard';
+  }
+
+  // One non-catalog item per order line, at the price the store charges
+  // (tax included). \`billingCycle\` makes it the recurring item.
+  function item(name, unitAmount, quantity, currency, billingCycle, trialDays) {
+    var label = String(name || 'Item').trim() || 'Item';
+    var price = {
+      description: (label.length >= 2 ? label : label + ' item').slice(0, 500),
+      name: label.slice(0, 150),
+      unit_price: { amount: minor(unitAmount, currency), currency_code: String(currency).toUpperCase() },
+      tax_mode: 'internal',
+      product: { name: label.slice(0, 200), tax_category: taxCategory() },
+    };
+    if (billingCycle) {
+      price.billing_cycle = billingCycle;
+      if (trialDays > 0) {
+        price.trial_period = { interval: 'day', frequency: trialDays };
+      }
+    }
+    return { quantity: Math.max(1, Math.floor(Number(quantity) || 1)), price: price };
+  }
+
+  function errorCode(data) {
+    return String((data && data.error && data.error.code) || '');
+  }
+
+  // The store's own page opens the checkout: Paddle appends \`_ptxn\` to it.
+  // Where the buyer lands afterwards rides in the transaction's custom data,
+  // which the page reads back server-side.
+  async function openTransaction(items, input) {
+    var metadata = input.metadata || {};
+    var body = {
+      items: items,
+      currency_code: String(input.currency || '').toUpperCase(),
+      custom_data: {
+        orderId: String(metadata.orderId || ''),
+        orderNumber: String(metadata.orderNumber || ''),
+        subscriptionId: String(metadata.subscriptionId || ''),
+        successUrl: String(input.successUrl || ''),
+        cancelUrl: String(input.cancelUrl || ''),
+      },
+    };
+    var page = input.baseUrl ? core.absoluteUrl('/pay/paddle', input.baseUrl) : '';
+    var answer = await call('POST', '/transactions', page ? Object.assign({ checkout: { url: page } }, body) : body);
+    // The address the buyer is on is not one Paddle approved (a local store, a
+    // second domain): the checkout opens on the account's default payment
+    // link instead, which the merchant points at this store's payment page.
+    if (page && errorCode(answer.data) === 'transaction_checkout_url_domain_is_not_approved') {
+      answer = await call('POST', '/transactions', body);
+    }
+    if (!answer.ok || !answer.data || !answer.data.data) {
+      return { checkoutUrl: '', sessionId: '', error: problem(answer.data, 'Paddle refused the transaction (HTTP ' + answer.status + ')') };
+    }
+    var transaction = answer.data.data;
+    return { checkoutUrl: (transaction.checkout && transaction.checkout.url) || '', sessionId: transaction.id || '' };
+  }
+
+  async function createCheckout(input) {
+    if (!apiKey()) {
+      return { checkoutUrl: '', sessionId: '', error: MISSING_KEY };
+    }
+    try {
+      var lines = Array.isArray(input.lineItems) && input.lineItems.length > 0 ? input.lineItems : [{ name: input.description, unitAmount: input.amount, quantity: 1 }];
+      return await openTransaction(
+        lines.map(function (line) {
+          return item(line.name, line.unitAmount, line.quantity, input.currency, null, 0);
+        }),
+        input
+      );
+    } catch (err) {
+      return { checkoutUrl: '', sessionId: '', error: core.describeError(err) };
+    }
+  }
+
+  // What became of a transaction the store opened earlier. A draft or ready
+  // one is paid on its own checkout (the store's page, with the transaction
+  // named); a billed or past-due one waits on money; a paid or completed one
+  // is paid; a canceled one takes no more, nor does one Paddle does not know.
+  async function inspectCheckout(input) {
+    var reference = String((input && input.reference) || '').trim();
+    if (reference.indexOf('txn_') !== 0) {
+      return { state: 'closed', checkoutUrl: '' };
+    }
+    if (!apiKey()) {
+      return { state: '', checkoutUrl: '', error: MISSING_KEY };
+    }
+    try {
+      var answer = await call('GET', '/transactions/' + encodeURIComponent(reference));
+      if (answer.status === 404) {
+        return { state: 'closed', checkoutUrl: '' };
+      }
+      if (!answer.ok || !answer.data || !answer.data.data) {
+        return { state: '', checkoutUrl: '', error: problem(answer.data, 'Paddle could not be asked about transaction ' + reference) };
+      }
+      var transaction = answer.data.data;
+      var state = transactionState(transaction);
+      if (state === 'open') {
+        var page = transaction.checkout && transaction.checkout.url ? String(transaction.checkout.url) : '';
+        return page ? { state: 'open', checkoutUrl: page } : { state: 'closed', checkoutUrl: '' };
+      }
+      return { state: state, checkoutUrl: '' };
+    } catch (err) {
+      return { state: '', checkoutUrl: '', error: core.describeError(err) };
+    }
+  }
+
+  function transactionState(transaction) {
+    var status = String((transaction && transaction.status) || '');
+    if (status === 'draft' || status === 'ready') {
+      return 'open';
+    }
+    if (status === 'billed' || status === 'past_due') {
+      return 'confirming';
+    }
+    return status === 'paid' || status === 'completed' ? 'paid' : 'closed';
+  }
+
+  // Closes a transaction the order no longer needs: a draft or ready one is
+  // canceled, so its checkout takes no money.
+  async function closeCheckout(input) {
+    var reference = String((input && input.reference) || '').trim();
+    if (reference.indexOf('txn_') !== 0) {
+      return { state: 'closed', checkoutUrl: '', openUntil: '' };
+    }
+    if (!apiKey()) {
+      return { state: '', error: MISSING_KEY };
+    }
+    try {
+      var path = '/transactions/' + encodeURIComponent(reference);
+      var answer = await call('GET', path);
+      if (answer.status === 404) {
+        return { state: 'closed', checkoutUrl: '', openUntil: '' };
+      }
+      if (!answer.ok || !answer.data || !answer.data.data) {
+        return { state: '', error: problem(answer.data, 'Paddle could not be asked about transaction ' + reference) };
+      }
+      var state = transactionState(answer.data.data);
+      if (state !== 'open') {
+        return { state: state, checkoutUrl: '', openUntil: '' };
+      }
+      var cancelled = await call('PATCH', path, { status: 'canceled' });
+      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 && again.data.data ? transactionState(again.data.data) : '';
+      return after && after !== 'open'
+        ? { state: after, checkoutUrl: '', openUntil: '' }
+        : { state: '', error: problem(cancelled.data, 'Paddle did not cancel transaction ' + reference) };
+    } catch (err) {
+      return { state: '', error: core.describeError(err) };
+    }
+  }
+
+  // The transactions opened for an order around the moment it was placed
+  // (they carry the order in their custom data).
+  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 = [];
+      // Paddle serves at most 30 transactions a page; the store's checkouts
+      // are the ones it created through the API.
+      var path =
+        '/transactions?per_page=30&origin=api&created_at[GTE]=' +
+        encodeURIComponent(core.isoTime(span.from)) +
+        '&created_at[LT]=' +
+        encodeURIComponent(core.isoTime(span.to));
+      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, 'Paddle could not list its transactions') };
+        }
+        var transactions = Array.isArray(answer.data.data) ? answer.data.data : [];
+        transactions.forEach(function (transaction) {
+          var custom = transaction && transaction.custom_data ? transaction.custom_data : {};
+          if (transaction && transaction.id && String(custom.orderId || '') === orderId) {
+            references.push(String(transaction.id));
+          }
+        });
+        var pagination = answer.data.meta && answer.data.meta.pagination ? answer.data.meta.pagination : {};
+        var next = pagination.has_more && pagination.next ? String(pagination.next) : '';
+        if (!next || transactions.length === 0) {
+          return { references: references };
+        }
+        path = next.replace(/^https?:\\/\\/[^/]+/, '');
+      }
+      return { error: 'Paddle has more transactions around the time this order was placed than the store can search.' };
+    } catch (err) {
+      return { error: core.describeError(err) };
+    }
+  }
+
+  // Paddle bills the plan every cycle from the first charge on, so a gift card
+  // cannot pay part of that charge.
+  async function createSubscriptionCheckout(input) {
+    if (!apiKey()) {
+      return { checkoutUrl: '', sessionId: '', error: MISSING_KEY };
+    }
+    var interval = String(input.recurringInterval || 'month').toLowerCase();
+    if (INTERVALS.indexOf(interval) === -1) {
+      return { checkoutUrl: '', sessionId: '', error: 'Unknown billing interval "' + interval + '"' };
+    }
+    var regular = Number(input.amount);
+    if (!isFinite(regular) || regular <= 0) {
+      return { checkoutUrl: '', sessionId: '', error: 'A subscription needs a positive amount to bill' };
+    }
+    var due = Number(input.amountDue);
+    if (isFinite(due) && due < regular) {
+      return { checkoutUrl: '', sessionId: '', error: 'Paddle cannot take a gift card toward a subscription payment.' };
+    }
+    try {
+      var frequency = Math.max(1, Math.floor(Number(input.recurringIntervalCount) || 1));
+      var trialDays = Math.max(0, Math.floor(Number(input.trialDays) || 0));
+      var result = await openTransaction(
+        [item(input.description, regular, 1, input.currency, { interval: interval, frequency: frequency }, trialDays)],
+        input
+      );
+      return result.error ? result : { checkoutUrl: result.checkoutUrl, sessionId: result.sessionId, providerSubscriptionId: '' };
+    } catch (err) {
+      return { checkoutUrl: '', sessionId: '', error: core.describeError(err) };
+    }
+  }
+
+  // The price travels on each transaction: no plan to create.
+  async function ensurePlan() {
+    return { ok: 'true', planId: '', providerProductId: '', created: 'false' };
+  }
+
+  function subscriptionStatus(status) {
+    var map = { active: 'active', trialing: 'trialing', past_due: 'past_due', paused: 'paused', canceled: 'cancelled' };
+    return map[String(status || '').toLowerCase()] || '';
+  }
+
+  function manageFailure(message) {
+    return { ok: 'false', status: '', cancelAtPeriodEnd: 'false', currentPeriodStart: '', currentPeriodEnd: '', error: message };
+  }
+
+  function manageResult(subscription) {
+    var period = subscription.current_billing_period || {};
+    var scheduled = subscription.scheduled_change || null;
+    return {
+      ok: 'true',
+      status: subscriptionStatus(subscription.status),
+      cancelAtPeriodEnd: scheduled && scheduled.action === 'cancel' ? 'true' : 'false',
+      currentPeriodStart: period.starts_at ? String(period.starts_at) : '',
+      currentPeriodEnd: period.ends_at ? String(period.ends_at) : subscription.next_billed_at ? String(subscription.next_billed_at) : '',
+    };
+  }
+
+  // A resume also withdraws a scheduled cancellation or pause, as on Stripe.
+  async function manageSubscription(input) {
+    if (!apiKey()) {
+      return manageFailure(MISSING_KEY);
+    }
+    var path = '/subscriptions/' + encodeURIComponent(input.subscriptionId);
+    try {
+      var answer;
+      if (input.action === 'refresh') {
+        answer = await call('GET', path);
+      } else if (input.action === 'cancel') {
+        answer = await call('POST', path + '/cancel', { effective_from: 'immediately' });
+      } else if (input.action === 'cancel_at_period_end') {
+        answer = await call('POST', path + '/cancel', { effective_from: 'next_billing_period' });
+      } else if (input.action === 'pause') {
+        answer = await call('POST', path + '/pause', { effective_from: 'immediately' });
+      } else {
+        var current = await call('GET', path);
+        if (!current.ok || !current.data || !current.data.data) {
+          return manageFailure(problem(current.data, 'Paddle could not read the subscription (HTTP ' + current.status + ')'));
+        }
+        answer =
+          current.data.data.status === 'paused'
+            ? await call('POST', path + '/resume', { effective_from: 'immediately' })
+            : await call('PATCH', path, { scheduled_change: null });
+      }
+      if (!answer.ok || !answer.data || !answer.data.data) {
+        return manageFailure(problem(answer.data, 'Paddle refused the change (HTTP ' + answer.status + ')'));
+      }
+      return manageResult(answer.data.data);
+    } catch (err) {
+      return manageFailure(core.describeError(err));
+    }
+  }
+
+  // A portal session for the subscriber's own Paddle customer: payment method,
+  // invoices, and the subscription itself. Single use; opened right away.
+  async function billingPortal(input) {
+    var failure = function (message) {
+      return { ok: 'false', url: '', error: message };
+    };
+    var customerId = String(input.customerId || '').trim();
+    if (!customerId) {
+      return failure('No Paddle customer is attached to this subscription yet.');
+    }
+    if (!apiKey()) {
+      return failure(MISSING_KEY);
+    }
+    try {
+      var body = input.subscriptionId ? { subscription_ids: [String(input.subscriptionId)] } : {};
+      var answer = await call('POST', '/customers/' + encodeURIComponent(customerId) + '/portal-sessions', body);
+      var urls = answer.ok && answer.data && answer.data.data ? answer.data.data.urls || {} : null;
+      var overview = urls && urls.general ? urls.general.overview : '';
+      if (!overview) {
+        return failure(problem(answer.data, 'Paddle did not return a portal link (HTTP ' + answer.status + ')'));
+      }
+      return { ok: 'true', url: String(overview) };
+    } catch (err) {
+      return failure(core.describeError(err));
+    }
+  }
+
+  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;
+  }
+
+  // What earlier adjustments took off each line of a transaction, by item id,
+  // in the smallest unit: refunds and credits (approved or awaiting approval)
+  // and chargebacks. A rejected or reversed one took nothing.
+  function takenByItem(adjustments) {
+    var taken = {};
+    (Array.isArray(adjustments) ? adjustments : []).forEach(function (adjustment) {
+      if (['refund', 'credit', 'chargeback'].indexOf(adjustment.action) === -1 || adjustment.status === 'rejected' || adjustment.status === 'reversed') {
+        return;
+      }
+      (adjustment.items || []).forEach(function (entry) {
+        var value = Number(entry.amount !== undefined ? entry.amount : entry.totals && entry.totals.total);
+        if (entry.item_id && isFinite(value) && value > 0) {
+          taken[entry.item_id] = (taken[entry.item_id] || 0) + value;
+        }
+      });
+    });
+    return taken;
+  }
+
+  // Paddle takes no idempotency key, so the refund's key rides in its reason
+  // as a short marker (the same one the editor writes), and a retried refund
+  // finds the adjustment it created before instead of refunding twice. '' for
+  // a refund without a key.
+  function refundMarker(key) {
+    var value = String(key || '');
+    return value ? '[ref ' + core.hmac('sha256', 'paddle-refund', value, 'hex').slice(0, 12) + ']' : '';
+  }
+
+  // The adjustment an earlier attempt with this marker created; a rejected
+  // one gave nothing back, so it does not stand in for a new refund.
+  function markedRefund(adjustments, marker) {
+    var list = marker && Array.isArray(adjustments) ? adjustments : [];
+    for (var i = 0; i < list.length; i++) {
+      var adjustment = list[i] || {};
+      if (adjustment.action === 'refund' && adjustment.status !== 'rejected' && String(adjustment.reason || '').indexOf(marker) !== -1) {
+        return adjustment;
+      }
+    }
+    return null;
+  }
+
+  function refundOutcome(adjustment, currency) {
+    var adjustmentCurrency = String(adjustment.currency_code || currency).toUpperCase();
+    if (adjustment.status === 'rejected') {
+      return refundFailure(adjustmentCurrency, 'Paddle rejected the refund.', { refundId: adjustment.id || '', status: 'rejected' });
+    }
+    return {
+      success: true,
+      refundId: adjustment.id || '',
+      amount: major(adjustment.totals && adjustment.totals.total, adjustmentCurrency),
+      currency: adjustmentCurrency,
+      status: String(adjustment.status || ''),
+      error: '',
+    };
+  }
+
+  // A refund is an adjustment of the transaction: the whole grand total, or an
+  // amount spread over what its lines have left (most first), so no line is
+  // asked for more than earlier adjustments left on it. Those come from the
+  // transaction read with its adjustments; one that read does not list is not
+  // subtracted, and Paddle then refuses a line amount above what is left.
+  // Live refunds usually wait for Paddle's approval; \`pending_approval\` is
+  // reported as the status, and the adjustment webhook records a rejection.
+  async function refund(input) {
+    var currency = String(input.currency || '').toUpperCase();
+    if (!apiKey()) {
+      return refundFailure(currency, MISSING_KEY);
+    }
+    var transactionId = String(input.paymentReference || '').trim();
+    if (transactionId.indexOf('txn_') !== 0) {
+      return refundFailure(currency, 'This is not a Paddle transaction reference.');
+    }
+    var marker = refundMarker(input.idempotencyKey);
+    var text = String(input.reason || '').trim() || 'Refund requested by the store';
+    var reason = marker ? text.slice(0, 254 - marker.length) + ' ' + marker : text.slice(0, 255);
+    try {
+      var body = { action: 'refund', transaction_id: transactionId, reason: reason, type: 'full' };
+      var transaction = null;
+      if (marker || input.amount > 0) {
+        transaction = await call('GET', '/transactions/' + encodeURIComponent(transactionId) + '?include=adjustments');
+        if (!transaction.ok || !transaction.data || !transaction.data.data) {
+          return refundFailure(currency, problem(transaction.data, 'Paddle could not find the transaction ' + transactionId + '.'));
+        }
+        var earlier = markedRefund(transaction.data.data.adjustments, marker);
+        if (earlier) {
+          return refundOutcome(earlier, currency);
+        }
+      }
+      if (input.amount > 0) {
+        var details = transaction.data.data.details || {};
+        var taken = takenByItem(transaction.data.data.adjustments);
+        var lines = (details.line_items || [])
+          .map(function (line) {
+            var total = Number((line.totals && line.totals.total) || 0);
+            return { id: line.id, left: isFinite(total) ? total - (taken[line.id] || 0) : 0 };
+          })
+          .sort(function (a, b) {
+            return b.left - a.left;
+          });
+        var remaining = Number(minor(input.amount, currency));
+        if (!(remaining > 0)) {
+          return refundFailure(currency, 'The amount is smaller than the smallest unit of ' + currency + '.');
+        }
+        var items = [];
+        for (var i = 0; i < lines.length && remaining > 0; i++) {
+          var share = Math.min(lines[i].left, remaining);
+          if (share > 0) {
+            items.push({ item_id: lines[i].id, type: 'partial', amount: String(share) });
+            remaining -= share;
+          }
+        }
+        if (remaining > 0) {
+          return refundFailure(currency, 'The amount is more than this Paddle transaction can refund.');
+        }
+        body = { action: 'refund', transaction_id: transactionId, reason: reason, type: 'partial', items: items };
+      }
+      var answer = await call('POST', '/adjustments', body);
+      if (!answer.ok || !answer.data || !answer.data.data) {
+        return refundFailure(currency, problem(answer.data, 'Paddle refused the refund (HTTP ' + answer.status + ')'));
+      }
+      return refundOutcome(answer.data.data, currency);
+    } catch (err) {
+      return refundFailure(currency, core.describeError(err));
+    }
+  }
+
+  function signatureMatches(rawBody, header, secret) {
+    var timestamp = '';
+    var signatures = [];
+    String(header || '')
+      .split(';')
+      .forEach(function (part) {
+        var eq = part.indexOf('=');
+        var key = eq >= 0 ? part.slice(0, eq).trim() : '';
+        var value = eq >= 0 ? part.slice(eq + 1).trim() : '';
+        if (key === 'ts') {
+          timestamp = value;
+        } else if (key === 'h1') {
+          signatures.push(value);
+        }
+      });
+    if (!timestamp || signatures.length === 0) {
+      return false;
+    }
+    if (Math.abs(Math.floor(Date.now() / 1000) - Number(timestamp)) > SIGNATURE_TOLERANCE_SECONDS) {
+      return false;
+    }
+    var expected = core.hmac('sha256', secret, timestamp + ':' + rawBody.toString('utf8'), 'hex');
+    return signatures.some(function (signature) {
+      return core.safeEqual(expected, signature);
+    });
+  }
+
+  // Paddle signs every notification with the destination's secret, and the
+  // store accepts nothing unsigned.
+  async function verifyWebhook(input) {
+    var secret = input.secret || core.credential('paddle', 'webhookSecret');
+    if (!secret) {
+      return { ok: false, reason: 'The Paddle notification secret (PADDLE_WEBHOOK_SECRET) is not configured.' };
+    }
+    var header = core.header(input.headers, 'paddle-signature');
+    if (!header) {
+      return { ok: false, reason: 'The Paddle-Signature header is missing.' };
+    }
+    return signatureMatches(input.rawBody, header, secret)
+      ? { ok: true, body: input.body }
+      : { ok: false, reason: 'The Paddle signature does not match the notification secret.' };
+  }
+
+  // A transaction whose notification never came (no destination for this
+  // store's address, a secret of another one) is settled from Paddle itself:
+  // it is READ with the store's key and answered as the notification Paddle
+  // sends for its current status. Nothing but its id comes from the request.
+  var TRANSACTION_ID_PATTERN = /^txn_[A-Za-z0-9]{8,64}$/;
+  // A draft, ready or billed transaction took no money yet: nothing to settle.
+  var SETTLED_TRANSACTION_EVENTS = {
+    completed: 'transaction.completed',
+    paid: 'transaction.paid',
+    past_due: 'transaction.past_due',
+    canceled: 'transaction.canceled',
+  };
+
+  async function reconcile(request) {
+    var kind = String((request && request.kind) || '');
+    var id = String((request && request.id) || '').trim();
+    if (kind !== 'checkout' || !TRANSACTION_ID_PATTERN.test(id)) {
+      return { ok: false, reason: 'The request names no Paddle transaction to settle.' };
+    }
+    if (!apiKey()) {
+      return { ok: false, retry: true, reason: MISSING_KEY };
+    }
+    try {
+      var answer = await call('GET', '/transactions/' + encodeURIComponent(id));
+      if (!answer.ok || !answer.data || !answer.data.data) {
+        return {
+          ok: false,
+          retry: answer.status >= 500 || answer.status === 429,
+          reason: problem(answer.data, 'Paddle could not be asked about transaction ' + id),
+        };
+      }
+      var transaction = answer.data.data;
+      var eventType = SETTLED_TRANSACTION_EVENTS[String(transaction.status || '')];
+      if (!eventType) {
+        return { ok: false, reason: 'Paddle transaction ' + id + ' is ' + (transaction.status || 'open') + ', with nothing to settle yet.' };
+      }
+      var eventId = 'teleport-settle:' + String(transaction.id || id);
+      return {
+        ok: true,
+        body: { event_id: eventId, event_type: eventType, occurred_at: new Date().toISOString(), notification_id: eventId, data: transaction },
+      };
+    } catch (err) {
+      return { ok: false, retry: true, reason: core.describeError(err) };
+    }
+  }
+
+  function reconcileKinds(reference) {
+    return TRANSACTION_ID_PATTERN.test(String(reference || '').trim()) ? ['checkout'] : [];
+  }
+
+  // What the store's \`/pay/paddle\` page needs to open a transaction's
+  // checkout — only for one still taking money (\`draft\` or \`ready\`); a paid,
+  // billed or canceled one is not opened again.
+  async function checkoutPage(transactionId) {
+    var id = String(transactionId || '').trim();
+    if (id.indexOf('txn_') !== 0 || !apiKey() || !clientToken()) {
+      return null;
+    }
+    var answer = await call('GET', '/transactions/' + encodeURIComponent(id));
+    if (!answer.ok || !answer.data || !answer.data.data || transactionState(answer.data.data) !== 'open') {
+      return null;
+    }
+    var data = answer.data.data.custom_data || {};
+    return {
+      transactionId: id,
+      token: clientToken(),
+      sandbox: isSandbox(),
+      successUrl: String(data.successUrl || ''),
+      cancelUrl: String(data.cancelUrl || ''),
+    };
+  }
+
+  return {
+    id: 'paddle',
+    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,
+  };
+};
+`;
+exports.generatePaddleDriverCode = generatePaddleDriverCode;
+//# sourceMappingURL=paddle-driver-code.js.map

package/dist/cjs/payments/drivers/paddle-driver-code.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paddle-driver-code.js","sourceRoot":"","sources":["../../../../src/payments/drivers/paddle-driver-code.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACI,MAAM,wBAAwB,GAAG,GAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2pBrD,CAAA;AA3pBY,QAAA,wBAAwB,4BA2pBpC"}