@happyvertical/payments 0.74.8

package/dist/adapters/stripe.js

@@ -0,0 +1,696 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { P as PaymentConfigurationError, b as PaymentProviderError, d as PaymentVerificationError } from "../chunks/errors-BgFC46qQ.js";
+import { g as getFetch, a as normalizeMaxStoredPaymentOptions, b as normalizeUrlString, n as normalizeNonEmptyString, o as normalizePositivePaymentAmount, h as normalizeDate, t as formEncode, r as rememberPaymentOption, p as pollPaymentStatus, i as normalizeMinorUnitAmount, j as readJsonResponse, s as applyExpiryToPendingStatus } from "../chunks/shared-DGHSqDQT.js";
+const STRIPE_BACKEND_ID = "stripe";
+const STRIPE_CHECKOUT_MIN_EXPIRY_MS = 30 * 60 * 1e3;
+const STRIPE_CHECKOUT_MAX_EXPIRY_MS = 24 * 60 * 60 * 1e3;
+const DEFAULT_STRIPE_API_VERSION = "2024-06-20";
+const DEFAULT_MAX_STORED_WEBHOOK_EVENT_IDS = 5e4;
+class StripeAdapter {
+  constructor(options) {
+    this.options = options;
+    if (typeof options.secretKey !== "string" || !options.secretKey.trim()) {
+      throw new PaymentConfigurationError("StripeAdapter requires secretKey.");
+    }
+    if (options.webhookSecret !== void 0) {
+      if (typeof options.webhookSecret !== "string") {
+        throw new PaymentConfigurationError(
+          "StripeAdapter webhookSecret must be a string when configured."
+        );
+      }
+      if (!options.webhookSecret.trim()) {
+        throw new PaymentConfigurationError(
+          "StripeAdapter webhookSecret must not be empty when configured."
+        );
+      }
+    }
+    if (options.apiBaseUrl !== void 0) {
+      if (typeof options.apiBaseUrl !== "string") {
+        throw new PaymentConfigurationError(
+          "StripeAdapter apiBaseUrl must be a string when configured."
+        );
+      }
+      if (!options.apiBaseUrl.trim()) {
+        throw new PaymentConfigurationError(
+          "StripeAdapter apiBaseUrl must not be empty when configured."
+        );
+      }
+    }
+    this.fetch = getFetch(options.fetch);
+    this.maxStoredPaymentOptions = normalizeMaxStoredPaymentOptions(
+      options.maxStoredPaymentOptions,
+      "StripeAdapter maxStoredPaymentOptions"
+    );
+    this.maxStoredWebhookEventIds = normalizeMaxStoredPaymentOptions(
+      options.maxStoredWebhookEventIds ?? DEFAULT_MAX_STORED_WEBHOOK_EVENT_IDS,
+      "StripeAdapter maxStoredWebhookEventIds"
+    );
+    this.secretKey = options.secretKey.trim();
+    this.apiBaseUrl = normalizeUrlString(
+      options.apiBaseUrl ?? "https://api.stripe.com/v1",
+      "StripeAdapter apiBaseUrl"
+    ).replace(/\/$/, "");
+    this.apiVersion = normalizeNonEmptyString(
+      options.apiVersion ?? DEFAULT_STRIPE_API_VERSION,
+      "StripeAdapter apiVersion"
+    );
+    this.defaultCurrency = normalizeStripeCurrency(
+      options.defaultCurrency ?? "usd"
+    );
+    this.supportedCurrencies = normalizeSupportedStripeCurrencies(
+      options.supportedCurrencies,
+      this.defaultCurrency
+    );
+    this.checkoutMode = options.checkoutMode ?? "payment";
+    if (this.checkoutMode !== "payment") {
+      throw new PaymentConfigurationError(
+        "StripeAdapter only supports payment Checkout mode."
+      );
+    }
+    this.webhookSecret = options.webhookSecret?.trim();
+    this.capabilities = {
+      id: STRIPE_BACKEND_ID,
+      displayName: "Stripe Checkout",
+      settlementCurrency: this.defaultCurrency.toUpperCase(),
+      supportedSettlementCurrencies: [...this.supportedCurrencies].map(
+        (currency) => currency.toUpperCase()
+      ),
+      chain: "stripe",
+      settlementShape: "url",
+      x402Capable: false,
+      confirmationLatency: {
+        expectedSeconds: 5,
+        maxExpectedSeconds: 600,
+        description: "Card payments usually confirm in seconds; bank debits can remain processing while Stripe settles them."
+      },
+      supportsRefunds: true,
+      supportsPayouts: true,
+      supportsWebhooks: true,
+      metadata: {
+        provider: "stripe"
+      }
+    };
+  }
+  capabilities;
+  fetch;
+  secretKey;
+  apiBaseUrl;
+  apiVersion;
+  defaultCurrency;
+  supportedCurrencies;
+  checkoutMode;
+  webhookSecret;
+  maxStoredPaymentOptions;
+  maxStoredWebhookEventIds;
+  optionsByQuote = /* @__PURE__ */ new Map();
+  seenWebhookEventIds = /* @__PURE__ */ new Set();
+  async createPaymentOption(input) {
+    const quoteId = normalizeNonEmptyString(input.quoteId, "Stripe quoteId");
+    const rawSuccessUrl = input.successUrl ?? this.options.successUrl;
+    const rawCancelUrl = input.cancelUrl ?? this.options.cancelUrl;
+    if (rawSuccessUrl === void 0 || rawCancelUrl === void 0) {
+      throw new PaymentConfigurationError(
+        "StripeAdapter createPaymentOption requires successUrl and cancelUrl."
+      );
+    }
+    const successUrl = normalizeUrlString(rawSuccessUrl, "Stripe successUrl");
+    const cancelUrl = normalizeUrlString(rawCancelUrl, "Stripe cancelUrl");
+    const currency = normalizeStripeCurrency(input.currency);
+    this.assertSupportedCurrency(currency);
+    const amount = normalizePositivePaymentAmount(
+      input.amount,
+      currency,
+      "Stripe Checkout amount"
+    );
+    const expiresAt = normalizeDate(input.expiresAt);
+    const stripeExpiresAt = normalizeStripeCheckoutExpiresAt(expiresAt);
+    const params = {
+      mode: this.checkoutMode,
+      ...Object.fromEntries([
+        ["success_url", successUrl],
+        ["cancel_url", cancelUrl],
+        ["client_reference_id", quoteId],
+        ["customer_email", input.buyerEmail],
+        ["expires_at", Math.floor(stripeExpiresAt.getTime() / 1e3)]
+      ]),
+      "line_items[0][quantity]": 1,
+      "line_items[0][price_data][currency]": currency,
+      "line_items[0][price_data][unit_amount]": amount,
+      "line_items[0][price_data][product_data][name]": input.description ?? `Quote ${quoteId}`,
+      ...flattenStripeMetadata(input.metadata),
+      "metadata[quoteId]": quoteId
+    };
+    const session = await this.stripeRequest(
+      "/checkout/sessions",
+      {
+        method: "POST",
+        idempotencyKey: input.idempotencyKey,
+        body: formEncode(params)
+      }
+    );
+    const sessionId = normalizeOptionalProviderString(
+      readProviderString(session, "id")
+    );
+    const checkoutUrl = normalizeOptionalProviderString(
+      readProviderString(session, "url")
+    );
+    if (!sessionId || !checkoutUrl) {
+      throw new PaymentProviderError(
+        "Stripe Checkout Session response did not include id and url."
+      );
+    }
+    const option = {
+      backendId: this.capabilities.id,
+      quoteId,
+      payTo: checkoutUrl,
+      settlementShape: "url",
+      settlementCurrency: currency.toUpperCase(),
+      settlementAmount: amount,
+      amount,
+      currency: currency.toUpperCase(),
+      expiresAt: stripeExpiresAt,
+      providerPaymentId: sessionId,
+      paymentUri: checkoutUrl,
+      metadata: {
+        sessionId,
+        paymentIntent: normalizeOptionalProviderString(
+          readProviderString(session, "payment_intent")
+        )
+      }
+    };
+    rememberPaymentOption(
+      this.optionsByQuote,
+      quoteId,
+      option,
+      this.maxStoredPaymentOptions
+    );
+    return option;
+  }
+  watchPayment(input) {
+    return pollPaymentStatus(
+      {
+        ...input,
+        pollIntervalMs: input.pollIntervalMs ?? this.options.pollIntervalMs ?? 5e3
+      },
+      () => this.getStatus(input.quoteId, input.payTo, input.statusContext)
+    );
+  }
+  async getStatus(quoteId, payTo, context = {}) {
+    const normalizedQuoteId = normalizeNonEmptyString(
+      quoteId,
+      "Stripe quoteId"
+    );
+    const normalizedPayTo = normalizeNonEmptyString(payTo, "Stripe payTo");
+    const contextProviderPaymentId = context.providerPaymentId === void 0 ? void 0 : normalizeNonEmptyString(
+      context.providerPaymentId,
+      "Stripe providerPaymentId"
+    );
+    const sessionId = this.optionsByQuote.get(normalizedQuoteId)?.providerPaymentId ?? contextProviderPaymentId ?? extractStripeSessionId(normalizedPayTo);
+    if (!sessionId) {
+      throw new PaymentConfigurationError(
+        "Stripe getStatus requires a Checkout Session id or URL."
+      );
+    }
+    const session = await this.stripeRequest(
+      `/checkout/sessions/${encodeURIComponent(sessionId)}`
+    );
+    const sessionQuoteId = readStripeSessionQuoteId(session);
+    if (sessionQuoteId !== void 0 && sessionQuoteId !== normalizedQuoteId) {
+      throw new PaymentVerificationError(
+        `Stripe Checkout Session quoteId ${sessionQuoteId} did not match ${normalizedQuoteId}.`
+      );
+    }
+    const paymentStatus = readString(session, "payment_status");
+    const status = mapStripeStatus(
+      readString(session, "status"),
+      paymentStatus
+    );
+    const option = this.optionsByQuote.get(normalizedQuoteId);
+    const contextAmount = context.amount === void 0 ? void 0 : normalizeMinorUnitAmount(context.amount, "Stripe status");
+    const contextCurrency = context.currency === void 0 ? void 0 : normalizeStripeCurrency(context.currency).toUpperCase();
+    const sessionCurrency = readString(session, "currency") === void 0 ? void 0 : normalizeStripeCurrency(
+      readString(session, "currency") ?? ""
+    ).toUpperCase();
+    const sessionAmount = readSafeInteger(session, "amount_total");
+    const expiresAt = option?.expiresAt ?? (context.expiresAt === void 0 ? void 0 : normalizeDate(context.expiresAt));
+    const effectiveStatus = applyExpiryToPendingStatus(status, expiresAt);
+    return {
+      backendId: this.capabilities.id,
+      quoteId: normalizedQuoteId,
+      payTo: normalizedPayTo,
+      status: effectiveStatus,
+      settlementCurrency: sessionCurrency ?? option?.settlementCurrency ?? contextCurrency ?? this.defaultCurrency.toUpperCase(),
+      settlementAmount: sessionAmount ?? option?.settlementAmount ?? contextAmount,
+      receivedAmount: paymentStatus === "paid" || paymentStatus === "no_payment_required" ? sessionAmount ?? option?.settlementAmount ?? contextAmount : void 0,
+      amount: option?.amount ?? contextAmount,
+      currency: option?.currency ?? contextCurrency,
+      providerPaymentId: sessionId,
+      transactionId: normalizeOptionalProviderString(
+        readProviderString(session, "payment_intent")
+      ),
+      updatedAt: /* @__PURE__ */ new Date(),
+      raw: session
+    };
+  }
+  async sendPayout(input) {
+    const currency = normalizeStripeCurrency(
+      input.currency ?? this.defaultCurrency
+    );
+    this.assertSupportedCurrency(currency);
+    const destination = normalizeNonEmptyString(
+      input.destination,
+      "Stripe payout destination"
+    );
+    const quoteId = input.quoteId === void 0 ? void 0 : normalizeNonEmptyString(input.quoteId, "Stripe payout quoteId");
+    const amount = normalizePositivePaymentAmount(
+      input.amount,
+      currency,
+      "Stripe payout amount"
+    );
+    const transfer = await this.stripeRequest(
+      "/transfers",
+      {
+        method: "POST",
+        idempotencyKey: input.idempotencyKey,
+        body: formEncode({
+          amount,
+          currency,
+          destination,
+          description: input.memo,
+          ...flattenStripeMetadata(input.metadata),
+          ...quoteId === void 0 ? {} : { "metadata[quoteId]": quoteId }
+        })
+      }
+    );
+    return {
+      backendId: this.capabilities.id,
+      status: "submitted",
+      payoutId: normalizeOptionalProviderString(
+        readProviderString(transfer, "id")
+      ),
+      destination,
+      amount,
+      currency: currency.toUpperCase(),
+      raw: transfer
+    };
+  }
+  async refundPayment(input) {
+    const rawPaymentReference = input.paymentId ?? input.transactionId;
+    if (!rawPaymentReference) {
+      throw new PaymentConfigurationError(
+        "Stripe refunds require paymentId or transactionId."
+      );
+    }
+    const paymentReference = normalizeNonEmptyString(
+      rawPaymentReference,
+      "Stripe refund payment reference"
+    );
+    const currency = normalizeStripeCurrency(
+      input.currency ?? this.defaultCurrency
+    );
+    this.assertSupportedCurrency(currency);
+    const amount = input.amount === void 0 ? void 0 : normalizePositivePaymentAmount(
+      input.amount,
+      currency,
+      "Stripe refund amount"
+    );
+    const refundReferenceParam = await this.resolveStripeRefundReferenceParam(paymentReference);
+    const refundParams = {
+      ...refundReferenceParam,
+      amount: amount === void 0 ? void 0 : amount,
+      reason: input.reason,
+      ...flattenStripeMetadata(input.metadata)
+    };
+    const refund = await this.stripeRequest(
+      "/refunds",
+      {
+        method: "POST",
+        idempotencyKey: input.idempotencyKey,
+        body: formEncode(refundParams)
+      }
+    );
+    return {
+      backendId: this.capabilities.id,
+      status: mapStripeRefundStatus(readString(refund, "status")),
+      refundId: normalizeOptionalProviderString(
+        readProviderString(refund, "id")
+      ),
+      transactionId: paymentReference,
+      amount,
+      currency: currency.toUpperCase(),
+      raw: refund
+    };
+  }
+  parseWebhookEvent(payload, signature) {
+    if (!this.webhookSecret) {
+      throw new PaymentConfigurationError(
+        "StripeAdapter parseWebhookEvent requires webhookSecret."
+      );
+    }
+    if (!signature) {
+      throw new PaymentProviderError("Missing Stripe webhook signature.");
+    }
+    verifyStripeWebhookSignature(payload, signature, this.webhookSecret);
+    const event = parseStripeWebhookPayload(payload);
+    const id = readRequiredWebhookString(
+      event,
+      "id",
+      "Stripe webhook event id"
+    );
+    const type = readRequiredWebhookString(
+      event,
+      "type",
+      "Stripe webhook event type"
+    );
+    const duplicate = this.seenWebhookEventIds.has(id);
+    if (!duplicate) {
+      this.seenWebhookEventIds.add(id);
+      while (this.seenWebhookEventIds.size > this.maxStoredWebhookEventIds) {
+        const oldest = this.seenWebhookEventIds.values().next().value;
+        if (oldest === void 0) {
+          break;
+        }
+        this.seenWebhookEventIds.delete(oldest);
+      }
+    }
+    const data = event.data?.object;
+    return {
+      id,
+      type,
+      status: mapStripeWebhookStatus(type, data),
+      quoteId: normalizeOptionalWebhookString(
+        readString(data, "client_reference_id") ?? readString(
+          data?.metadata ?? {},
+          "quoteId"
+        )
+      ),
+      providerPaymentId: normalizeOptionalWebhookString(readString(data, "id")),
+      duplicate,
+      raw: event
+    };
+  }
+  async stripeRequest(path, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("Authorization", `Bearer ${this.secretKey}`);
+    headers.set("Content-Type", "application/x-www-form-urlencoded");
+    headers.set("Accept", "application/json");
+    headers.set("Stripe-Version", this.apiVersion);
+    if (init.idempotencyKey !== void 0) {
+      headers.set(
+        "Idempotency-Key",
+        normalizeNonEmptyString(init.idempotencyKey, "Stripe idempotencyKey")
+      );
+    }
+    const { idempotencyKey: _idempotencyKey, ...requestInit } = init;
+    const response = await this.fetch(`${this.apiBaseUrl}${path}`, {
+      ...requestInit,
+      method: init.method ?? "GET",
+      headers
+    });
+    return readJsonResponse(response, `Stripe ${path}`);
+  }
+  assertSupportedCurrency(currency) {
+    if (!this.supportedCurrencies.has(currency)) {
+      throw new PaymentConfigurationError(
+        `StripeAdapter currency ${currency.toUpperCase()} is not configured as supported.`
+      );
+    }
+  }
+  async resolveStripeRefundReferenceParam(paymentReference) {
+    if (paymentReference.startsWith("cs_")) {
+      const session = await this.stripeRequest(
+        `/checkout/sessions/${encodeURIComponent(paymentReference)}`
+      );
+      const paymentIntent = normalizeOptionalProviderString(
+        readProviderString(session, "payment_intent")
+      );
+      if (!paymentIntent) {
+        throw new PaymentProviderError(
+          "Stripe Checkout Session did not include payment_intent for refund."
+        );
+      }
+      return Object.fromEntries([["payment_intent", paymentIntent]]);
+    }
+    return stripeRefundReferenceParam(paymentReference);
+  }
+}
+function stripeRefundReferenceParam(paymentReference) {
+  if (paymentReference.startsWith("pi_")) {
+    return Object.fromEntries([["payment_intent", paymentReference]]);
+  }
+  if (paymentReference.startsWith("ch_")) {
+    return { charge: paymentReference };
+  }
+  throw new PaymentConfigurationError(
+    "Stripe refunds require a Checkout Session (cs_), payment_intent (pi_), or charge (ch_) reference."
+  );
+}
+function normalizeStripeCurrency(value) {
+  if (typeof value !== "string") {
+    throw new PaymentConfigurationError(
+      `StripeAdapter currency must be a three-letter ISO currency code, received ${String(value)}.`
+    );
+  }
+  const normalized = value.trim().toLowerCase();
+  if (!/^[a-z]{3}$/.test(normalized)) {
+    throw new PaymentConfigurationError(
+      `StripeAdapter currency must be a three-letter ISO currency code, received ${String(value)}.`
+    );
+  }
+  return normalized;
+}
+function normalizeSupportedStripeCurrencies(configuredCurrencies, defaultCurrency) {
+  const normalized = new Set(
+    (configuredCurrencies ?? ["usd", "eur", "gbp", "cad"]).map(
+      normalizeStripeCurrency
+    )
+  );
+  normalized.add(defaultCurrency);
+  return normalized;
+}
+function normalizeStripeCheckoutExpiresAt(expiresAt, now = Date.now()) {
+  if (expiresAt.getTime() <= now) {
+    throw new PaymentProviderError("Stripe Checkout expiry is in the past.");
+  }
+  const min = now + STRIPE_CHECKOUT_MIN_EXPIRY_MS;
+  const max = now + STRIPE_CHECKOUT_MAX_EXPIRY_MS;
+  if (expiresAt.getTime() < min || expiresAt.getTime() > max) {
+    throw new PaymentConfigurationError(
+      "Stripe Checkout expiry must be at least 30 minutes and no more than 24 hours from now."
+    );
+  }
+  return expiresAt;
+}
+function verifyStripeWebhookSignature(payload, signatureHeader, secret, toleranceSeconds = 300) {
+  if (typeof payload !== "string") {
+    throw new PaymentProviderError("Stripe webhook payload must be a string.");
+  }
+  const normalizedSignatureHeader = normalizeNonEmptyString(
+    signatureHeader,
+    "Stripe signature header"
+  );
+  const normalizedSecret = normalizeNonEmptyString(
+    secret,
+    "Stripe webhook secret"
+  );
+  if (!Number.isFinite(toleranceSeconds) || toleranceSeconds < 0) {
+    throw new PaymentConfigurationError(
+      `Stripe webhook toleranceSeconds must be a non-negative finite number, received ${String(toleranceSeconds)}.`
+    );
+  }
+  const timestampCandidates = [];
+  const signatures = [];
+  for (const part of normalizedSignatureHeader.split(",")) {
+    const [rawKey, ...rawValue] = part.split("=");
+    const key = rawKey?.trim();
+    const value = rawValue.join("=").trim();
+    if (!key || !value) {
+      continue;
+    }
+    if (key === "t") {
+      timestampCandidates.push(value);
+    }
+    if (key === "v1") {
+      signatures.push(value);
+    }
+  }
+  if (timestampCandidates.length !== 1 || signatures.length === 0) {
+    throw new PaymentProviderError("Invalid Stripe signature header.");
+  }
+  const timestamp = timestampCandidates[0] ?? "";
+  if (!/^\d+$/.test(timestamp)) {
+    throw new PaymentProviderError("Invalid Stripe signature header.");
+  }
+  const timestampSeconds = Number(timestamp);
+  if (!Number.isSafeInteger(timestampSeconds)) {
+    throw new PaymentProviderError("Invalid Stripe signature header.");
+  }
+  const nowSeconds = Date.now() / 1e3;
+  const ageSeconds = nowSeconds - timestampSeconds;
+  if (ageSeconds < -5) {
+    throw new PaymentProviderError(
+      "Stripe webhook signature timestamp is in the future."
+    );
+  }
+  if (ageSeconds > toleranceSeconds) {
+    throw new PaymentProviderError("Stripe webhook signature is too old.");
+  }
+  const expected = createHmac("sha256", normalizedSecret).update(`${timestamp}.${payload}`).digest("hex");
+  const expectedBuffer = Buffer.from(expected, "hex");
+  for (const signature of signatures) {
+    if (!/^[0-9a-f]+$/i.test(signature)) {
+      throw new PaymentProviderError("Invalid Stripe signature header.");
+    }
+    const actualBuffer = Buffer.from(signature, "hex");
+    if (expectedBuffer.length === actualBuffer.length && timingSafeEqual(expectedBuffer, actualBuffer)) {
+      return;
+    }
+  }
+  throw new PaymentProviderError("Invalid Stripe webhook signature.");
+}
+function parseStripeWebhookPayload(payload) {
+  try {
+    const event = JSON.parse(payload);
+    if (!event || typeof event !== "object" || Array.isArray(event)) {
+      throw new PaymentProviderError("Invalid Stripe webhook JSON payload.");
+    }
+    return event;
+  } catch (error) {
+    if (error instanceof PaymentProviderError) {
+      throw error;
+    }
+    throw new PaymentProviderError("Invalid Stripe webhook JSON payload.", {
+      cause: error
+    });
+  }
+}
+function normalizeOptionalWebhookString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function normalizeOptionalProviderString(value) {
+  const normalized = value?.trim();
+  return normalized ? normalized : void 0;
+}
+function readProviderString(value, key) {
+  if (!value) {
+    return void 0;
+  }
+  const item = value[key];
+  return typeof item === "string" ? item : void 0;
+}
+function readRequiredWebhookString(value, key, context) {
+  const item = value[key];
+  if (typeof item !== "string") {
+    throw new PaymentProviderError(`${context} must be a string.`);
+  }
+  return normalizeNonEmptyString(item, context);
+}
+function readStripeSessionQuoteId(session) {
+  return normalizeOptionalWebhookString(
+    readString(session, "client_reference_id") ?? readString(
+      session.metadata ?? {},
+      "quoteId"
+    )
+  );
+}
+function mapStripeStatus(checkoutStatus, paymentStatus) {
+  if (paymentStatus === "paid" || paymentStatus === "no_payment_required") {
+    return "confirmed";
+  }
+  if (checkoutStatus === "expired") {
+    return "expired";
+  }
+  if (paymentStatus === "unpaid" || checkoutStatus === "open") {
+    return "pending";
+  }
+  if (checkoutStatus === "complete") {
+    return "processing";
+  }
+  return "pending";
+}
+function mapStripeWebhookStatus(type, object) {
+  if (type === "checkout.session.completed") {
+    return mapStripeStatus(
+      readString(object, "status"),
+      readString(object, "payment_status")
+    );
+  }
+  if (type === "checkout.session.async_payment_succeeded") {
+    return "confirmed";
+  }
+  if (type === "checkout.session.async_payment_failed") {
+    return "failed";
+  }
+  if (type === "checkout.session.expired") {
+    return "expired";
+  }
+  if (type?.includes("failed")) {
+    return "failed";
+  }
+  if (type?.includes("refunded")) {
+    return "refunded";
+  }
+  return "processing";
+}
+function mapStripeRefundStatus(status) {
+  switch (status) {
+    case "succeeded":
+      return "succeeded";
+    case "failed":
+    case "canceled":
+      return "failed";
+    case "requires_action":
+      return "requires_action";
+    default:
+      return "submitted";
+  }
+}
+function extractStripeSessionId(payTo) {
+  if (/^cs_(test_|live_)?[A-Za-z0-9_]+$/.test(payTo)) {
+    return payTo;
+  }
+  try {
+    const url = new URL(payTo);
+    const match = url.pathname.match(/\/pay\/([^/?#]+)/);
+    const sessionId = match?.[1];
+    return sessionId && /^cs_(test_|live_)?[A-Za-z0-9_]+$/.test(sessionId) ? sessionId : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function flattenStripeMetadata(metadata) {
+  const result = {};
+  for (const [key, value] of Object.entries(metadata ?? {})) {
+    if (value !== void 0 && value !== null) {
+      result[`metadata[${key}]`] = value;
+    }
+  }
+  return result;
+}
+function readString(value, key) {
+  if (!value) {
+    return void 0;
+  }
+  const item = value[key];
+  if (typeof item === "string") {
+    return item;
+  }
+  if (typeof item === "number") {
+    return String(item);
+  }
+  return void 0;
+}
+function readSafeInteger(value, key) {
+  if (!value) {
+    return void 0;
+  }
+  const item = value[key];
+  return typeof item === "number" && Number.isSafeInteger(item) && item >= 0 ? item : void 0;
+}
+export {
+  STRIPE_BACKEND_ID,
+  StripeAdapter,
+  verifyStripeWebhookSignature
+};
+//# sourceMappingURL=stripe.js.map