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

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

@@ -0,0 +1,778 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStripeDriverCode = void 0;
+/**
+ * Emits `utils/payments/drivers/stripe.js`: hosted Checkout (one-time and
+ * subscription), refunds, subscription management, the billing portal and
+ * webhook verification, through the official SDK.
+ *
+ * `payment_method_types` is never sent: Stripe then shows every method the
+ * merchant enabled in the Dashboard (cards, wallets, Link, bank debits and the
+ * stablecoin `crypto` method) — which is also why an asynchronous method can
+ * complete a session unpaid and settle later (see the webhook extract script).
+ */
+const generateStripeDriverCode = () => `'use strict';
+/**
+ * Stripe driver. Generated by TeleportHQ — changes are overwritten on the next export.
+ */
+module.exports = function createStripeDriver(core) {
+  // An older store's test key, read after the names the editor saves.
+  var LEGACY_SECRET_KEY_NAMES = ['STRIPE_TEST_KEY'];
+  var MISSING_KEY = 'STRIPE_SECRET_KEY is not configured';
+  var INTERVALS = ['day', 'week', 'month', 'year'];
+  // Checkout tolerates a signature this old, as Stripe's own libraries do.
+  var SIGNATURE_TOLERANCE_SECONDS = 300;
+  // Three-decimal currencies Stripe takes only in whole tens of the smallest unit.
+  var TENS_ONLY = ['BHD', 'JOD', 'KWD', 'OMR', 'TND'];
+
+  function secretKey() {
+    return core.credential('stripe', 'secretKey', LEGACY_SECRET_KEY_NAMES);
+  }
+
+  // An amount in Stripe's smallest unit: the thousandth first, as everywhere,
+  // then the nearest ten where Stripe requires it.
+  function minorUnits(major, currency) {
+    var value = core.toMinor(major, currency);
+    return TENS_ONLY.indexOf(String(currency || '').toUpperCase()) >= 0 ? Math.round(value / 10) * 10 : value;
+  }
+
+  function client(key) {
+    var Stripe = require('stripe');
+    return new Stripe(key);
+  }
+
+  function idOf(value) {
+    if (typeof value === 'string') {
+      return value;
+    }
+    return value && value.id ? String(value.id) : '';
+  }
+
+  function unixToIso(value) {
+    var seconds = Number(value);
+    return isFinite(seconds) && seconds > 0 ? new Date(seconds * 1000).toISOString() : '';
+  }
+
+  async function createCheckout(input) {
+    var key = secretKey();
+    if (!key) {
+      return { checkoutUrl: '', sessionId: '', error: MISSING_KEY };
+    }
+    try {
+      var stripe = client(key);
+      var currency = input.currency;
+      var params = {
+        mode: 'payment',
+        success_url: input.successUrl || undefined,
+        cancel_url: input.cancelUrl || undefined,
+      };
+      var lineItems = input.lineItems;
+      if (lineItems && Array.isArray(lineItems) && lineItems.length > 0) {
+        params.line_items = lineItems.map(function (item) {
+          var productData = { name: item.name || 'Item' };
+          // The options the shopper chose, under the line on Stripe's page and
+          // receipt. Stripe rejects an empty description and caps it at 500.
+          var lineDescription = typeof item.description === 'string' ? item.description.trim().slice(0, 500) : '';
+          if (lineDescription) {
+            productData.description = lineDescription;
+          }
+          return {
+            price_data: {
+              currency: currency,
+              product_data: productData,
+              unit_amount: minorUnits(item.unitAmount, currency),
+            },
+            quantity: Number(item.quantity) || 1,
+          };
+        });
+      } else {
+        params.line_items = [
+          {
+            price_data: {
+              currency: currency,
+              product_data: { name: input.description },
+              unit_amount: minorUnits(input.amount, currency),
+            },
+            quantity: 1,
+          },
+        ];
+      }
+      if (input.metadata) {
+        params.metadata = input.metadata;
+        // On the PaymentIntent too, which Stripe copies onto the charge: a
+        // refund event carries the CHARGE, and without this it names no order.
+        params.payment_intent_data = { metadata: input.metadata };
+      }
+      if (input.customerEmail) {
+        params.customer_email = String(input.customerEmail);
+      }
+      var session = await stripe.checkout.sessions.create(params);
+      return { checkoutUrl: session.url || '', sessionId: session.id || '' };
+    } catch (err) {
+      return { checkoutUrl: '', sessionId: '', error: err && err.message ? err.message : String(err) };
+    }
+  }
+
+  // ONE recurring line, priced inline (\`price_data.recurring\`), so no price
+  // object has to exist first. \`amountDue\` below \`amount\` is what the FIRST
+  // invoice charges after a gift card paid the rest: a one-shot coupon.
+  async function createSubscriptionCheckout(input) {
+    var key = secretKey();
+    if (!key) {
+      return { checkoutUrl: '', sessionId: '', error: MISSING_KEY };
+    }
+    var currency = input.currency;
+    var interval = String(input.recurringInterval || 'month').toLowerCase();
+    if (INTERVALS.indexOf(interval) === -1) {
+      return { checkoutUrl: '', sessionId: '', error: 'Unknown billing interval "' + interval + '"' };
+    }
+    var intervalCount = Math.max(1, Math.floor(Number(input.recurringIntervalCount) || 1));
+    var trialDays = Math.max(0, Math.floor(Number(input.trialDays) || 0));
+    var unitAmount = minorUnits(input.amount, currency);
+    if (unitAmount <= 0) {
+      return { checkoutUrl: '', sessionId: '', error: 'A subscription needs a positive amount to bill' };
+    }
+    var firstChargeDue = Number(input.amountDue);
+    var firstChargeAmount =
+      isFinite(firstChargeDue) && firstChargeDue < Number(input.amount) ? minorUnits(firstChargeDue, currency) : unitAmount;
+    if (firstChargeAmount <= 0) {
+      // The tender rule leaves at least the provider minimum due; a first charge
+      // of nothing would collect no payment method for the cycles after it.
+      return { checkoutUrl: '', sessionId: '', error: 'A gift card cannot cover the whole first payment of a subscription' };
+    }
+    try {
+      var stripe = client(key);
+      var subscriptionData = {};
+      if (trialDays > 0) {
+        subscriptionData.trial_period_days = trialDays;
+      }
+      if (input.metadata) {
+        // On the subscription too, so every later invoice names the order.
+        subscriptionData.metadata = input.metadata;
+      }
+      var params = {
+        mode: 'subscription',
+        success_url: input.successUrl || undefined,
+        cancel_url: input.cancelUrl || undefined,
+        line_items: [
+          {
+            price_data: {
+              currency: currency,
+              product_data: { name: input.description },
+              unit_amount: unitAmount,
+              recurring: { interval: interval, interval_count: intervalCount },
+            },
+            quantity: 1,
+          },
+        ],
+        subscription_data: subscriptionData,
+      };
+      if (input.customerEmail) {
+        params.customer_email = String(input.customerEmail);
+      }
+      if (input.metadata) {
+        params.metadata = input.metadata;
+      }
+      if (firstChargeAmount < unitAmount) {
+        var coupon = await stripe.coupons.create({
+          amount_off: unitAmount - firstChargeAmount,
+          currency: currency,
+          duration: 'once',
+          max_redemptions: 1,
+          name: 'Gift card',
+          metadata: input.metadata || {},
+        });
+        params.discounts = [{ coupon: coupon.id }];
+      }
+      var session = await stripe.checkout.sessions.create(params);
+      return { checkoutUrl: session.url || '', sessionId: session.id || '', providerSubscriptionId: '' };
+    } catch (err) {
+      return { checkoutUrl: '', sessionId: '', error: err && err.message ? err.message : String(err) };
+    }
+  }
+
+  // Checkout takes the price inline, so Stripe needs no plan of its own.
+  async function ensurePlan() {
+    return { ok: 'true', planId: '', providerProductId: '', created: 'false' };
+  }
+
+  // What became of a Checkout Session the store opened earlier: still open (its
+  // page is where the buyer pays), complete (paid, or an asynchronous method
+  // still settling) or expired. A reference that is no session, or one Stripe
+  // does not know, can take no more money.
+  async function inspectCheckout(input) {
+    var reference = String((input && input.reference) || '').trim();
+    if (reference.indexOf('cs_') !== 0) {
+      return { state: 'closed', checkoutUrl: '' };
+    }
+    var key = secretKey();
+    if (!key) {
+      return { state: '', checkoutUrl: '', error: MISSING_KEY };
+    }
+    try {
+      var stripe = client(key);
+      var session = await stripe.checkout.sessions.retrieve(reference);
+      var found = await sessionState(stripe, session);
+      return { state: found.state, checkoutUrl: found.checkoutUrl };
+    } catch (err) {
+      if (isMissing(err)) {
+        return { state: 'closed', checkoutUrl: '' };
+      }
+      return { state: '', checkoutUrl: '', error: core.describeError(err) };
+    }
+  }
+
+  function isMissing(err) {
+    return !!err && (err.statusCode === 404 || err.code === 'resource_missing');
+  }
+
+  // A session as a checkout state: open (with the page and when it runs out),
+  // complete (paid, or an asynchronous method still settling) or expired.
+  async function sessionState(stripe, session) {
+    var status = String((session && session.status) || '');
+    if (status === 'open' && session.url) {
+      return { state: 'open', checkoutUrl: String(session.url), openUntil: unixToIso(session.expires_at) };
+    }
+    if (status === 'complete') {
+      var paid = String(session.payment_status || '') !== 'unpaid';
+      return { state: paid ? 'paid' : await unpaidSessionState(stripe, session), checkoutUrl: '', openUntil: '' };
+    }
+    return { state: 'closed', checkoutUrl: '', openUntil: '' };
+  }
+
+  // A session an asynchronous method completed UNPAID stays that way whether
+  // the money settles or not: its PaymentIntent says which. One whose payment
+  // failed or was cancelled takes no more money (its page is complete); one
+  // still processing, or waiting for the buyer's transfer, is on its way. A
+  // session with no intent (a subscription's) is settled by its invoice.
+  async function unpaidSessionState(stripe, session) {
+    var intent = session.payment_intent;
+    if (!intent) {
+      return 'confirming';
+    }
+    if (typeof intent === 'string') {
+      intent = await stripe.paymentIntents.retrieve(intent);
+    }
+    var status = String((intent && intent.status) || '');
+    if (status === 'succeeded') {
+      return 'paid';
+    }
+    if (status === 'requires_payment_method' || status === 'canceled') {
+      return 'closed';
+    }
+    return 'confirming';
+  }
+
+  // Closes a session the order no longer needs: an open one is expired, so its
+  // page takes no more money. A buyer who finished paying between the read and
+  // the expiry leaves it complete, and that is what is answered.
+  async function closeCheckout(input) {
+    var reference = String((input && input.reference) || '').trim();
+    if (reference.indexOf('cs_') !== 0) {
+      return { state: 'closed', checkoutUrl: '', openUntil: '' };
+    }
+    var key = secretKey();
+    if (!key) {
+      return { state: '', error: MISSING_KEY };
+    }
+    try {
+      var stripe = client(key);
+      var session = await stripe.checkout.sessions.retrieve(reference);
+      if (String(session.status || '') === 'open') {
+        try {
+          session = await stripe.checkout.sessions.expire(reference);
+        } catch (_expireError) {
+          session = await stripe.checkout.sessions.retrieve(reference);
+        }
+      }
+      var found = await sessionState(stripe, session);
+      if (found.state === 'open') {
+        return { state: '', error: 'Stripe did not expire checkout ' + reference + '.' };
+      }
+      return found;
+    } catch (err) {
+      if (isMissing(err)) {
+        return { state: 'closed', checkoutUrl: '', openUntil: '' };
+      }
+      return { state: '', error: core.describeError(err) };
+    }
+  }
+
+  // The Checkout Sessions opened for an order around the moment it was placed
+  // (sessions carry the order in their metadata): how an order that recorded
+  // no checkout finds the one its placing opened.
+  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.' };
+    }
+    var key = secretKey();
+    if (!key) {
+      return { error: MISSING_KEY };
+    }
+    try {
+      var stripe = client(key);
+      var references = [];
+      var startingAfter = '';
+      for (var page = 0; page < core.SEARCH_PAGE_LIMIT; page++) {
+        var params = { created: { gte: Math.floor(span.from / 1000), lte: Math.ceil(span.to / 1000) }, limit: 100 };
+        if (startingAfter) {
+          params.starting_after = startingAfter;
+        }
+        var list = await stripe.checkout.sessions.list(params);
+        var sessions = list && Array.isArray(list.data) ? list.data : [];
+        sessions.forEach(function (session) {
+          if (session && session.id && String(core.readMetadata(session.metadata).orderId || '') === orderId) {
+            references.push(String(session.id));
+          }
+        });
+        if (!list || !list.has_more || sessions.length === 0) {
+          return { references: references };
+        }
+        startingAfter = String(sessions[sessions.length - 1].id);
+      }
+      return { error: 'Stripe has more checkouts around the time this order was placed than the store can search.' };
+    } catch (err) {
+      return { error: core.describeError(err) };
+    }
+  }
+
+  // The payment behind a subscription invoice: \`payment_intent\` on the classic
+  // shape, \`payments.data[0].payment.payment_intent\` from the 2025 versions,
+  // only \`charge\` on the oldest rows.
+  function invoicePaymentTarget(invoice) {
+    if (!invoice) {
+      return null;
+    }
+    var classic = idOf(invoice.payment_intent);
+    if (classic) {
+      return { paymentIntent: classic };
+    }
+    var payments = invoice.payments && invoice.payments.data ? invoice.payments.data : [];
+    var latest = payments.length > 0 && payments[0].payment ? idOf(payments[0].payment.payment_intent) : '';
+    if (latest) {
+      return { paymentIntent: latest };
+    }
+    var charge = idOf(invoice.charge);
+    return charge ? { charge: charge } : null;
+  }
+
+  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;
+  }
+
+  // The order row stores whatever the webhook saw — a PaymentIntent, a Checkout
+  // Session, a Charge, a subscription Invoice — and \`refunds.create\` takes an
+  // intent or a charge, so each is resolved to one first.
+  async function refund(input) {
+    var currency = input.currency;
+    var key = secretKey();
+    if (!key) {
+      return refundFailure(currency, MISSING_KEY);
+    }
+    var reference = input.paymentReference;
+    try {
+      var stripe = client(key);
+      var params = {};
+      if (reference.indexOf('ch_') === 0 || reference.indexOf('py_') === 0) {
+        params.charge = reference;
+      } else if (reference.indexOf('cs_') === 0) {
+        var session = await stripe.checkout.sessions.retrieve(reference);
+        var intentId = session ? idOf(session.payment_intent) : '';
+        if (!intentId) {
+          return refundFailure(currency, 'The Stripe checkout session for this order has no payment to refund.');
+        }
+        params.payment_intent = intentId;
+      } else if (reference.indexOf('in_') === 0) {
+        var target = invoicePaymentTarget(await stripe.invoices.retrieve(reference));
+        if (!target) {
+          return refundFailure(currency, 'This Stripe invoice has no payment to refund.');
+        }
+        if (target.charge) {
+          params.charge = target.charge;
+        } else {
+          params.payment_intent = target.paymentIntent;
+        }
+      } else if (reference.indexOf('sub_') === 0) {
+        return refundFailure(currency, "A subscription id cannot be refunded; refund the order's invoice instead.");
+      } else if (reference.indexOf('re_') === 0) {
+        return refundFailure(currency, 'This payment reference is already a refund id, so there is nothing to refund.');
+      } else {
+        params.payment_intent = reference;
+      }
+      var minor = minorUnits(input.amount, currency);
+      if (input.amount > 0 && minor <= 0) {
+        // A missing amount means "refund everything", so an amount too small
+        // to express in this currency is refused rather than rounded away.
+        return refundFailure(currency, 'The amount is smaller than the smallest unit of ' + String(currency || '').toUpperCase() + '.');
+      }
+      if (minor > 0) {
+        params.amount = minor;
+      }
+      // Stripe accepts three reasons and rejects the call for anything else;
+      // the merchant's free text stays in the store's own record.
+      var normalizedReason = String(input.reason || '').trim().toLowerCase().replace(/\\s+/g, '_');
+      if (['duplicate', 'fraudulent', 'requested_by_customer'].indexOf(normalizedReason) >= 0) {
+        params.reason = normalizedReason;
+      }
+      if (input.orderId) {
+        params.metadata = { orderId: input.orderId };
+      }
+      var created = await stripe.refunds.create(params, { idempotencyKey: input.idempotencyKey });
+      var refundCurrency = String(created.currency || currency).toUpperCase();
+      var status = String(created.status || '');
+      if (status === 'failed' || status === 'canceled') {
+        var detail = created.failure_reason ? ': ' + String(created.failure_reason).replace(/_/g, ' ') : '';
+        return refundFailure(refundCurrency, 'Stripe reported the refund as ' + status + detail + '.', {
+          refundId: created.id || '',
+          status: status,
+        });
+      }
+      if (status === 'requires_action') {
+        // Some payment methods need the buyer to name where the money goes
+        // back to (Stripe asks them); none has gone back yet, and the refund
+        // is cancelled if they never answer.
+        return refundFailure(
+          refundCurrency,
+          'Stripe is waiting for the buyer to act before it can pay this refund out, so nothing has been refunded yet.',
+          { refundId: created.id || '', status: status }
+        );
+      }
+      return {
+        success: true,
+        refundId: created.id || '',
+        amount: core.fromMinor(created.amount, refundCurrency),
+        currency: refundCurrency,
+        status: status,
+        error: '',
+      };
+    } catch (err) {
+      return refundFailure(currency, err && err.message ? err.message : String(err));
+    }
+  }
+
+  // A paused collection is Stripe's own status with \`pause_collection\` set,
+  // which the store calls paused; an ended subscription stays ended. A status
+  // the store does not know is '' (keep what the store has).
+  function subscriptionStatus(status, pauseCollection) {
+    var value = String(status || '').toLowerCase();
+    var map = {
+      active: 'active',
+      trialing: 'trialing',
+      past_due: 'past_due',
+      unpaid: 'past_due',
+      paused: 'paused',
+      canceled: 'cancelled',
+      incomplete_expired: 'expired',
+      incomplete: 'pending',
+    };
+    var mapped = map[value] || '';
+    if (pauseCollection && pauseCollection.behavior && mapped !== 'cancelled' && mapped !== 'expired') {
+      return 'paused';
+    }
+    return mapped;
+  }
+
+  // 2025 API versions carry the period on the item, not the subscription.
+  function periodOf(subscription, field) {
+    var firstItem = subscription && subscription.items && subscription.items.data && subscription.items.data[0];
+    return (subscription && subscription[field]) || (firstItem && firstItem[field]);
+  }
+
+  // The Dashboard can schedule a cancellation as a DATE (\`cancel_at\`); a date
+  // inside the current period is the same as cancel-at-period-end. An ended
+  // subscription has nothing left to cancel.
+  function cancelScheduled(subscription, status) {
+    if (status === 'cancelled') {
+      return false;
+    }
+    if (subscription && subscription.cancel_at_period_end) {
+      return true;
+    }
+    var cancelAt = Number(subscription && subscription.cancel_at);
+    var periodEnd = Number(periodOf(subscription, 'current_period_end'));
+    return isFinite(cancelAt) && cancelAt > 0 && (!(periodEnd > 0) || cancelAt <= periodEnd);
+  }
+
+  function manageFailure(message) {
+    return { ok: 'false', status: '', cancelAtPeriodEnd: 'false', currentPeriodStart: '', currentPeriodEnd: '', error: message };
+  }
+
+  async function manageSubscription(input) {
+    var key = secretKey();
+    if (!key) {
+      return manageFailure(MISSING_KEY);
+    }
+    var subscriptionId = input.subscriptionId;
+    var action = input.action;
+    try {
+      var stripe = client(key);
+      var subscription;
+      if (action === 'refresh') {
+        subscription = await stripe.subscriptions.retrieve(subscriptionId);
+      } else if (action === 'cancel') {
+        subscription = await stripe.subscriptions.cancel(subscriptionId);
+      } else if (action === 'cancel_at_period_end') {
+        subscription = await stripe.subscriptions.update(subscriptionId, { cancel_at_period_end: true });
+      } else if (action === 'pause') {
+        // Collection pauses; \`void\` marks the paused invoices uncollectible.
+        subscription = await stripe.subscriptions.update(subscriptionId, { pause_collection: { behavior: 'void' } });
+      } else {
+        subscription = await stripe.subscriptions.update(subscriptionId, { pause_collection: '', cancel_at_period_end: false });
+      }
+      var status = subscriptionStatus(subscription && subscription.status, subscription && subscription.pause_collection);
+      return {
+        ok: 'true',
+        status: status,
+        cancelAtPeriodEnd: cancelScheduled(subscription, status) ? 'true' : 'false',
+        currentPeriodStart: unixToIso(periodOf(subscription, 'current_period_start')),
+        currentPeriodEnd: unixToIso(periodOf(subscription, 'current_period_end')),
+      };
+    } catch (err) {
+      return manageFailure(err && err.message ? err.message : String(err));
+    }
+  }
+
+  // An account whose portal settings were never saved has no default
+  // configuration; the store creates (once) its own: payment methods and
+  // invoices only, so the subscription itself changes from the store.
+  async function ensurePortalConfiguration(stripe) {
+    var tag = 'teleport-store-billing-portal';
+    var existing = await stripe.billingPortal.configurations.list({ active: true, limit: 100 });
+    var list = (existing && existing.data) || [];
+    for (var i = 0; i < list.length; i++) {
+      var metadata = list[i] && list[i].metadata;
+      if (metadata && metadata.teleport === tag) {
+        return String(list[i].id);
+      }
+    }
+    var created = await stripe.billingPortal.configurations.create({
+      business_profile: { headline: 'Manage your payment method and invoices' },
+      features: { payment_method_update: { enabled: true }, invoice_history: { enabled: true } },
+      metadata: { teleport: tag },
+    });
+    return String(created.id);
+  }
+
+  async function billingPortal(input) {
+    var failure = function (message) {
+      return { ok: 'false', url: '', error: message };
+    };
+    var customerId = String(input.customerId || '').trim();
+    var returnUrl = String(input.returnUrl || '').trim();
+    if (!customerId) {
+      return failure('No Stripe customer is attached to this subscription yet.');
+    }
+    if (!/^https?:\\/\\/[^\\s]+$/i.test(returnUrl)) {
+      return failure('A return URL (http or https) is required to open the billing portal.');
+    }
+    var key = secretKey();
+    if (!key) {
+      return failure(MISSING_KEY);
+    }
+    try {
+      var stripe = client(key);
+      var cache = globalThis;
+      var createSession = function (configurationId) {
+        return stripe.billingPortal.sessions.create(
+          configurationId
+            ? { customer: customerId, return_url: returnUrl, configuration: configurationId }
+            : { customer: customerId, return_url: returnUrl }
+        );
+      };
+      var session;
+      try {
+        session = await createSession(cache.__stripeBillingPortalConfigurationId || '');
+      } catch (err) {
+        // Only a missing (or since-deleted) configuration is worth a retry.
+        if (!/configuration/i.test(String(err && err.message))) {
+          throw err;
+        }
+        cache.__stripeBillingPortalConfigurationId = await ensurePortalConfiguration(stripe);
+        session = await createSession(cache.__stripeBillingPortalConfigurationId);
+      }
+      if (!session || !session.url) {
+        return failure('Stripe did not return a billing portal link.');
+      }
+      return { ok: 'true', url: String(session.url) };
+    } catch (err) {
+      return failure(err && err.message ? err.message : String(err));
+    }
+  }
+
+  // A checkout whose webhook never came (a store Stripe cannot reach, an
+  // endpoint missing an event) is settled from Stripe itself: the session is
+  // READ with the store's key and answered as the event Stripe sends for its
+  // current state. Nothing but the session id comes from the request.
+  var SESSION_ID_PATTERN = /^cs_[A-Za-z0-9_]{8,250}$/;
+  // What an asynchronous method did with a session it completed unpaid.
+  var ASYNC_SESSION_EVENTS = {
+    paid: 'checkout.session.async_payment_succeeded',
+    closed: 'checkout.session.async_payment_failed',
+  };
+
+  function settledEvent(type, object) {
+    return { ok: true, body: { id: 'teleport-settle:' + String(object.id || ''), object: 'event', type: type, data: { object: object } } };
+  }
+
+  // Stripe could not be asked (a network failure, an outage, a rate limit):
+  // worth asking again. Any other refusal stands.
+  function unreachable(err) {
+    var status = Number(err && err.statusCode);
+    return !(status >= 400) || status >= 500 || status === 429;
+  }
+
+  // A subscription session answers its completion too, which activates the
+  // subscription (and pays the order when its first invoice is paid).
+  async function settleSession(stripe, session) {
+    var status = String(session.status || '');
+    if (status === 'expired') {
+      return settledEvent('checkout.session.expired', session);
+    }
+    if (status !== 'complete') {
+      return { ok: false, reason: 'Stripe checkout ' + session.id + ' is still open.' };
+    }
+    if (String(session.payment_status || '') !== 'unpaid') {
+      return settledEvent('checkout.session.completed', session);
+    }
+    // Completed unpaid, it stays that way: its PaymentIntent says what the
+    // money did since, and one still on its way is the completion itself.
+    var settled = await unpaidSessionState(stripe, session);
+    return settledEvent(ASYNC_SESSION_EVENTS[settled] || 'checkout.session.completed', session);
+  }
+
+  // A subscription session's first invoice, once paid: the \`invoice.paid\`
+  // that pays the order (the completion only replays it).
+  async function settleSessionInvoice(stripe, session) {
+    var invoiceId = session.mode === 'subscription' ? idOf(session.invoice) : '';
+    if (!invoiceId) {
+      return { ok: false, reason: 'Stripe checkout ' + session.id + ' has no subscription invoice to settle.' };
+    }
+    var invoice = await stripe.invoices.retrieve(invoiceId);
+    if (String((invoice && invoice.status) || '') !== 'paid') {
+      return { ok: false, reason: 'Stripe invoice ' + invoiceId + ' is not paid yet.' };
+    }
+    return settledEvent('invoice.paid', invoice);
+  }
+
+  async function reconcile(request) {
+    var kind = String((request && request.kind) || '');
+    var id = String((request && request.id) || '').trim();
+    if ((kind !== 'checkout' && kind !== 'checkout-invoice') || !SESSION_ID_PATTERN.test(id)) {
+      return { ok: false, reason: 'The request names no Stripe checkout to settle.' };
+    }
+    var key = secretKey();
+    if (!key) {
+      return { ok: false, retry: true, reason: MISSING_KEY };
+    }
+    try {
+      var stripe = client(key);
+      var session = await stripe.checkout.sessions.retrieve(id);
+      return kind === 'checkout' ? await settleSession(stripe, session) : await settleSessionInvoice(stripe, session);
+    } catch (err) {
+      if (isMissing(err)) {
+        return { ok: false, reason: 'Stripe does not know ' + id + '.' };
+      }
+      return { ok: false, retry: unreachable(err), reason: core.describeError(err) };
+    }
+  }
+
+  // What \`reconcile\` settles a checkout the store recorded by, in order: the
+  // session, then the first invoice a subscription session opened.
+  function reconcileKinds(reference) {
+    return SESSION_ID_PATTERN.test(String(reference || '').trim()) ? ['checkout', 'checkout-invoice'] : [];
+  }
+
+  function signatureMatches(rawBody, signatureHeader, secret) {
+    try {
+      var parts = String(signatureHeader || '').split(',');
+      var timestamp = '';
+      var signatures = [];
+      for (var i = 0; i < parts.length; i++) {
+        var pair = parts[i].trim().split('=');
+        if (pair[0] === 't') {
+          timestamp = pair[1];
+        }
+        if (pair[0] === 'v1') {
+          signatures.push(pair[1]);
+        }
+      }
+      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');
+      for (var j = 0; j < signatures.length; j++) {
+        if (core.safeEqual(expected, signatures[j])) {
+          return true;
+        }
+      }
+      return false;
+    } catch (_e) {
+      return false;
+    }
+  }
+
+  // With a signing secret the Stripe-Signature header decides. Without one the
+  // event is read back from Stripe with the store's own key, and THAT copy is
+  // what the store acts on — a forged body names no event Stripe has.
+  async function verifyWebhook(input) {
+    var secret = input.secret || core.credential('stripe', 'webhookSecret');
+    if (secret) {
+      var signature = core.header(input.headers, 'stripe-signature');
+      if (!signature) {
+        return { ok: false, reason: 'The Stripe-Signature header is missing.' };
+      }
+      return signatureMatches(input.rawBody, signature, secret)
+        ? { ok: true, body: input.body }
+        : { ok: false, reason: 'The Stripe signature does not match the webhook signing secret.' };
+    }
+    var eventId = input.body && typeof input.body.id === 'string' ? input.body.id : '';
+    if (eventId.indexOf('evt_') !== 0) {
+      return { ok: false, reason: 'The request names no Stripe event.' };
+    }
+    var key = secretKey();
+    if (!key) {
+      return { ok: false, reason: MISSING_KEY };
+    }
+    try {
+      var answer = await core.request('https://api.stripe.com/v1/events/' + encodeURIComponent(eventId), {
+        headers: { Authorization: 'Bearer ' + key },
+      });
+      if (!answer.ok || !answer.data || answer.data.id !== eventId) {
+        return { ok: false, reason: 'Stripe does not know the event ' + eventId + '.' };
+      }
+      return { ok: true, body: answer.data };
+    } catch (err) {
+      return { ok: false, reason: core.describeError(err) };
+    }
+  }
+
+  return {
+    id: 'stripe',
+    createCheckout: createCheckout,
+    createSubscriptionCheckout: createSubscriptionCheckout,
+    inspectCheckout: inspectCheckout,
+    closeCheckout: closeCheckout,
+    findCheckouts: findCheckouts,
+    ensurePlan: ensurePlan,
+    refund: refund,
+    manageSubscription: manageSubscription,
+    billingPortal: billingPortal,
+    reconcile: reconcile,
+    reconcileKinds: reconcileKinds,
+    verifyWebhook: verifyWebhook,
+  };
+};
+`;
+exports.generateStripeDriverCode = generateStripeDriverCode;
+//# sourceMappingURL=stripe-driver-code.js.map