vona-module-pay-stripe 5.0.4 → 5.0.6

package/dist/bean/payProvider.stripe.d.ts

@@ -1,23 +1,36 @@
 import type { IDecoratorPayProviderOptions, IPayProviderClientOptions, IPayProviderClientRecord, IPayProviderExecute, IPayProviderPaymentInput, IPayProviderPaymentSnapshot, IPayProviderRefundInput, IPayProviderRefundSnapshot, IPayProviderVerifiedWebhook, IPayProviderWebhookInput } from 'vona-module-a-pay';
 import { BeanBase } from 'vona';
+import type { IStripeGateway } from '../lib/stripeGateway.ts';
 export interface IPayProviderStripeClientRecord extends IPayProviderClientRecord {
 }
 export interface IPayProviderStripeClientOptions extends IPayProviderClientOptions {
     secretCredential: string | undefined;
     secretWebhook: string | undefined;
+    gateway?: IStripeGateway;
 }
 export interface IPayProviderOptionsStripe extends IDecoratorPayProviderOptions<IPayProviderStripeClientRecord, IPayProviderStripeClientOptions> {
 }
 export declare class PayProviderStripe extends BeanBase implements IPayProviderExecute<IPayProviderStripeClientOptions> {
-    startPayment(_input: IPayProviderPaymentInput, _clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderPaymentSnapshot>;
-    confirmPayment(_input: IPayProviderPaymentInput, _clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderPaymentSnapshot>;
-    queryPayment(_input: IPayProviderPaymentInput, _clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderPaymentSnapshot>;
-    createRefund(_input: IPayProviderRefundInput, _clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderRefundSnapshot>;
-    verifyWebhook(_input: IPayProviderWebhookInput, _clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderVerifiedWebhook>;
-}
-declare module 'vona-module-a-pay' {
-    interface IPayProviderRecord {
-        'pay-stripe:stripe': IPayProviderOptionsStripe;
-    }
+    startPayment(input: IPayProviderPaymentInput, clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderPaymentSnapshot>;
+    confirmPayment(input: IPayProviderPaymentInput, clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderPaymentSnapshot>;
+    queryPayment(input: IPayProviderPaymentInput, clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderPaymentSnapshot>;
+    createRefund(input: IPayProviderRefundInput, clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderRefundSnapshot>;
+    queryRefund(input: IPayProviderRefundInput, clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderRefundSnapshot>;
+    verifyWebhook(input: IPayProviderWebhookInput, clientOptions: IPayProviderStripeClientOptions): Promise<IPayProviderVerifiedWebhook>;
+    private _mapCheckoutWebhook;
+    private _mapPaymentIntentWebhook;
+    private _mapRefundWebhook;
+    private _inputFromCheckoutSession;
+    private _mapCheckoutSession;
+    private _mapPaymentIntent;
+    private _mapRefund;
+    private _paymentMetadata;
+    private _refundMetadata;
+    private _gateway;
+    private _gatewayOptions;
+    private _matchesEnvironment;
+    private _isDefinitiveRefundRejection;
+    private _throwTerminalPaymentFailure;
+    private _throwGatewayError;
 }
 //# sourceMappingURL=payProvider.stripe.d.ts.map

package/dist/bean/payProvider.stripe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"payProvider.stripe.d.ts","sourceRoot":"","sources":["../../src/bean/payProvider.stripe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,wBAAwB,EACxB,mBAAmB,EACnB,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,QAAQ,EAAU,MAAM,MAAM,CAAC;AAGxC,MAAM,WAAW,8BAA+B,SAAQ,wBAAwB;CAAG;AAEnF,MAAM,WAAW,+BAAgC,SAAQ,yBAAyB;IAChF,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAID,MAAM,WAAW,yBAA0B,SAAQ,4BAA4B,CAC7E,8BAA8B,EAC9B,+BAA+B,CAChC;CAAG;AAEJ,qBAoBa,iBACX,SAAQ,QACR,YAAW,mBAAmB,CAAC,+BAA+B,CAAC;IAEzD,YAAY,CAChB,MAAM,EAAE,wBAAwB,EAChC,cAAc,EAAE,+BAA+B,GAC9C,OAAO,CAAC,2BAA2B,CAAC;IAIjC,cAAc,CAClB,MAAM,EAAE,wBAAwB,EAChC,cAAc,EAAE,+BAA+B,GAC9C,OAAO,CAAC,2BAA2B,CAAC;IAIjC,YAAY,CAChB,MAAM,EAAE,wBAAwB,EAChC,cAAc,EAAE,+BAA+B,GAC9C,OAAO,CAAC,2BAA2B,CAAC;IAIjC,YAAY,CAChB,MAAM,EAAE,uBAAuB,EAC/B,cAAc,EAAE,+BAA+B,GAC9C,OAAO,CAAC,0BAA0B,CAAC;IAIhC,aAAa,CACjB,MAAM,EAAE,wBAAwB,EAChC,cAAc,EAAE,+BAA+B,GAC9C,OAAO,CAAC,2BAA2B,CAAC;CAGxC;AAED,OAAO,QAAQ,mBAAmB,CAAC;IACjC,UAAiB,kBAAkB;QACjC,mBAAmB,EAAE,yBAAyB,CAAC;KAChD;CACF"}
+{"version":3,"file":"payProvider.stripe.d.ts","sourceRoot":"","sources":["../../src/bean/payProvider.stripe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,yBAAyB,EACzB,wBAAwB,EACxB,mBAAmB,EACnB,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,0BAA0B,EAC1B,2BAA2B,EAC3B,wBAAwB,EACzB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,QAAQ,EAAU,MAAM,MAAM,CAAC;AAGxC,OAAO,KAAK,EAAE,cAAc,EAAyB,MAAM,yBAAyB,CAAC;AAIrF,MAAM,WAAW,8BAA+B,SAAQ,wBAAwB;CAAG;AAEnF,MAAM,WAAW,+BAAgC,SAAQ,yBAAyB;IAChF,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,OAAO,CAAC,EAAE,cAAc,CAAC;CAC1B;AAID,MAAM,WAAW,yBAA0B,SAAQ,4BAA4B,CAC7E,8BAA8B,EAC9B,+BAA+B,CAChC;CAAG;AAEJ,qBAqBa,iBACX,SAAQ,QACR,YAAW,mBAAmB,CAAC,+BAA+B,CAAC;IAEzD,YAAY,CAChB,KAAK,EAAE,wBAAwB,EAC/B,aAAa,EAAE,+BAA+B,GAC7C,OAAO,CAAC,2BAA2B,CAAC;IAsCjC,cAAc,CAClB,KAAK,EAAE,wBAAwB,EAC/B,aAAa,EAAE,+BAA+B,GAC7C,OAAO,CAAC,2BAA2B,CAAC;IAIjC,YAAY,CAChB,KAAK,EAAE,wBAAwB,EAC/B,aAAa,EAAE,+BAA+B,GAC7C,OAAO,CAAC,2BAA2B,CAAC;IAUjC,YAAY,CAChB,KAAK,EAAE,uBAAuB,EAC9B,aAAa,EAAE,+BAA+B,GAC7C,OAAO,CAAC,0BAA0B,CAAC;IAmBhC,WAAW,CACf,KAAK,EAAE,uBAAuB,EAC9B,aAAa,EAAE,+BAA+B,GAC7C,OAAO,CAAC,0BAA0B,CAAC;IAUhC,aAAa,CACjB,KAAK,EAAE,wBAAwB,EAC/B,aAAa,EAAE,+BAA+B,GAC7C,OAAO,CAAC,2BAA2B,CAAC;YA4BzB,mBAAmB;YAkCnB,wBAAwB;YAgDxB,iBAAiB;YAsCjB,yBAAyB;IA4BvC,OAAO,CAAC,mBAAmB;IAmD3B,OAAO,CAAC,iBAAiB;IAmCzB,OAAO,CAAC,UAAU;IAyBlB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,4BAA4B;IAIpC,OAAO,CAAC,4BAA4B;IAUpC,OAAO,CAAC,kBAAkB;CAI3B"}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export type { IPayProviderStripeClientOptions } from './bean/payProvider.stripe.ts';
 export * from './types/index.ts';
 export * from './.metadata/index.ts';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,+BAA+B,EAAE,MAAM,8BAA8B,CAAC;AACpF,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -1,31 +1,498 @@
 import { useApp, BeanInfo, BeanBase, BeanScopeBase } from 'vona';
 import { __decorate } from 'tslib';
-import { PayProvider } from 'vona-module-a-pay';
+import { PayProvider, ProviderOperationFailure } from 'vona-module-a-pay';
+import Stripe from 'stripe';
 import { Scope } from 'vona-module-a-bean';
 
+const StripeRequestTimeoutMilliseconds = 15_000;
+class StripeGatewayError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = void 0;
+    this.status = status;
+  }
+}
+function createStripeGateway() {
+  return {
+    async createCheckoutSession(options, input) {
+      const request = input;
+      return await createClient(options).checkout.sessions.create(request.body, {
+        idempotencyKey: request.idempotencyKey
+      });
+    },
+    async retrieveCheckoutSession(options, input) {
+      const request = input;
+      return await createClient(options).checkout.sessions.retrieve(request.id, {
+        expand: ['payment_intent']
+      });
+    },
+    async createRefund(options, input) {
+      const request = input;
+      return await createClient(options).refunds.create(request.body, {
+        idempotencyKey: request.idempotencyKey
+      });
+    },
+    async retrieveRefund(options, input) {
+      const request = input;
+      return await createClient(options).refunds.retrieve(request.id);
+    },
+    async constructWebhookEvent(options, input) {
+      const signature = getHeader(input.headers, 'stripe-signature');
+      if (!input.rawBody || !signature) {
+        throw new StripeGatewayError(401, 'Stripe webhook signature is invalid');
+      }
+      try {
+        return createClient(options).webhooks.constructEvent(input.rawBody, signature, options.webhookSecret);
+      } catch {
+        throw new StripeGatewayError(401, 'Stripe webhook signature is invalid');
+      }
+    }
+  };
+}
+function createClient(options) {
+  return new Stripe(options.secretKey, {
+    maxNetworkRetries: 0,
+    timeout: StripeRequestTimeoutMilliseconds
+  });
+}
+function getHeader(headers, key) {
+  const value = headers[key];
+  return Array.isArray(value) ? value[0] : value;
+}
+
 const app = useApp();
 let PayProviderStripe = class PayProviderStripe extends BeanBase {
-  async startPayment(_input, _clientOptions) {
-    this.app.throw(501, 'Stripe provider is not implemented');
+  async startPayment(input, clientOptions) {
+    if (input.providerOrderId) return await this.queryPayment(input, clientOptions);
+    if (!input.returnUrl || !input.cancelUrl) {
+      this.app.throw(500, 'Stripe payment requires return and cancel URLs');
+    }
+    const gatewayOptions = this._gatewayOptions(clientOptions);
+    assertStripeMoney(input.amountMinor, input.currency);
+    const body = {
+      mode: 'payment',
+      success_url: input.returnUrl,
+      cancel_url: input.cancelUrl,
+      client_reference_id: input.providerCorrelationReference,
+      metadata: this._paymentMetadata(input),
+      payment_intent_data: {
+        metadata: this._paymentMetadata(input)
+      },
+      managed_payments: {
+        enabled: false
+      },
+      line_items: [{
+        quantity: 1,
+        price_data: {
+          currency: input.currency.toLowerCase(),
+          unit_amount: input.amountMinor,
+          product_data: {
+            name: `Payment ${input.providerInvoiceReference}`
+          }
+        }
+      }]
+    };
+    let checkoutSession;
+    try {
+      checkoutSession = await this._gateway(clientOptions).createCheckoutSession(gatewayOptions, {
+        idempotencyKey: input.idempotencyKey,
+        body
+      });
+    } catch (error) {
+      this._throwTerminalPaymentFailure(error);
+    }
+    return this._mapCheckoutSession(checkoutSession, input, clientOptions, true);
+  }
+  async confirmPayment(input, clientOptions) {
+    return await this.queryPayment(input, clientOptions);
+  }
+  async queryPayment(input, clientOptions) {
+    const gatewayOptions = this._gatewayOptions(clientOptions);
+    if (!input.providerOrderId) this.app.throw(409, 'Stripe payment has no Checkout Session');
+    const checkoutSession = await this._gateway(clientOptions).retrieveCheckoutSession(gatewayOptions, {
+      id: input.providerOrderId
+    });
+    return this._mapCheckoutSession(checkoutSession, input, clientOptions);
+  }
+  async createRefund(input, clientOptions) {
+    const gatewayOptions = this._gatewayOptions(clientOptions);
+    assertStripeMoney(input.amountMinor, input.currency);
+    try {
+      const refund = await this._gateway(clientOptions).createRefund(gatewayOptions, {
+        idempotencyKey: input.idempotencyKey,
+        body: {
+          payment_intent: input.providerCaptureId,
+          amount: input.amountMinor,
+          metadata: this._refundMetadata(input)
+        }
+      });
+      return this._mapRefund(refund, input);
+    } catch (error) {
+      if (this._isDefinitiveRefundRejection(error)) return {
+        state: 'failed'
+      };
+      throw error;
+    }
+  }
+  async queryRefund(input, clientOptions) {
+    const gatewayOptions = this._gatewayOptions(clientOptions);
+    if (!input.providerRefundId) this.app.throw(409, 'Stripe refund has no provider refund identifier');
+    const refund = await this._gateway(clientOptions).retrieveRefund(gatewayOptions, {
+      id: input.providerRefundId
+    });
+    return this._mapRefund(refund, input);
+  }
+  async verifyWebhook(input, clientOptions) {
+    const gatewayOptions = this._gatewayOptions(clientOptions);
+    let event;
+    try {
+      event = asRecord(await this._gateway(clientOptions).constructWebhookEvent(gatewayOptions, input));
+    } catch (error) {
+      this._throwGatewayError(error);
+    }
+    const eventId = readString(event.id);
+    const eventType = readString(event.type);
+    const resource = asRecord(asRecord(event.data).object);
+    if (!eventId || !eventType || !Object.keys(resource).length) {
+      this.app.throw(400, 'Stripe webhook is invalid');
+    }
+    if (eventType.startsWith('checkout.session.')) {
+      return await this._mapCheckoutWebhook(eventId, eventType, resource, clientOptions);
+    }
+    if (eventType.startsWith('payment_intent.')) {
+      return await this._mapPaymentIntentWebhook(eventId, eventType, resource);
+    }
+    if (eventType.startsWith('refund.')) {
+      return await this._mapRefundWebhook(eventId, eventType, resource);
+    }
+    return {
+      eventId,
+      eventType,
+      ignored: true,
+      summary: {
+        amountMinor: 0,
+        currency: 'USD'
+      }
+    };
+  }
+  async _mapCheckoutWebhook(eventId, eventType, checkoutSession, clientOptions) {
+    const input = await this._inputFromCheckoutSession(checkoutSession);
+    const payment = await this._mapCheckoutSession(checkoutSession, input, clientOptions);
+    if (eventType === 'checkout.session.async_payment_failed') {
+      return {
+        eventId,
+        eventType,
+        paymentSessionId: input.paymentSessionId,
+        payment: {
+          ...payment,
+          state: 'failed'
+        },
+        summary: {
+          amountMinor: input.amountMinor,
+          currency: input.currency
+        }
+      };
+    }
+    if (!['succeeded', 'failed', 'cancelled'].includes(payment.state)) {
+      return {
+        eventId,
+        eventType,
+        ignored: true,
+        summary: {
+          amountMinor: input.amountMinor,
+          currency: input.currency
+        }
+      };
+    }
+    return {
+      eventId,
+      eventType,
+      paymentSessionId: input.paymentSessionId,
+      payment,
+      summary: {
+        amountMinor: input.amountMinor,
+        currency: input.currency
+      }
+    };
+  }
+  async _mapPaymentIntentWebhook(eventId, eventType, paymentIntent) {
+    const metadata = asRecord(paymentIntent.metadata);
+    const providerCorrelationReference = readString(metadata.providerCorrelationReference);
+    const providerInvoiceReference = readString(metadata.providerInvoiceReference);
+    if (!providerCorrelationReference || !providerInvoiceReference) {
+      this.app.throw(400, 'Stripe PaymentIntent webhook is not correlated');
+    }
+    const session = await this.$scope.pay.model.paymentSession.get({
+      providerCorrelationReference
+    });
+    if (!session || session.providerInvoiceReference !== providerInvoiceReference) {
+      this.app.throw(400, 'Stripe PaymentIntent webhook is not correlated');
+    }
+    const payment = this._mapPaymentIntent(paymentIntent, {
+      paymentSessionId: session.id,
+      businessReference: session.businessReference,
+      providerInvoiceReference: session.providerInvoiceReference,
+      providerCorrelationReference: session.providerCorrelationReference,
+      idempotencyKey: '',
+      amountMinor: session.amountMinor,
+      currency: session.currency,
+      providerOrderId: session.providerOrderId
+    });
+    const terminalPayment = eventType === 'payment_intent.payment_failed' ? {
+      ...payment,
+      state: 'failed'
+    } : payment;
+    if (!['succeeded', 'failed', 'cancelled'].includes(terminalPayment.state)) {
+      return {
+        eventId,
+        eventType,
+        ignored: true,
+        summary: {
+          amountMinor: session.amountMinor,
+          currency: session.currency
+        }
+      };
+    }
+    return {
+      eventId,
+      eventType,
+      paymentSessionId: session.id,
+      payment: terminalPayment,
+      summary: {
+        amountMinor: session.amountMinor,
+        currency: session.currency
+      }
+    };
+  }
+  async _mapRefundWebhook(eventId, eventType, refundResource) {
+    const refundId = readString(refundResource.id);
+    const metadata = asRecord(refundResource.metadata);
+    const providerCorrelationReference = readString(metadata.providerCorrelationReference);
+    if (!refundId || !providerCorrelationReference) {
+      this.app.throw(400, 'Stripe refund webhook is not correlated');
+    }
+    const refund = await this.$scope.pay.model.refundOperation.get({
+      providerCorrelationReference
+    });
+    if (!refund) this.app.throw(400, 'Stripe refund webhook is not correlated');
+    const session = await this.$scope.pay.model.paymentSession.getById(refund.paymentSessionId);
+    if (!session?.providerCaptureId) this.app.throw(409, 'Stripe refund webhook payment conflicts');
+    const snapshot = this._mapRefund(refundResource, {
+      paymentSessionId: session.id,
+      refundOperationId: refund.id,
+      businessReference: refund.businessReference,
+      providerInvoiceReference: refund.providerInvoiceReference,
+      providerCorrelationReference: refund.providerCorrelationReference,
+      idempotencyKey: '',
+      amountMinor: refund.amountMinor,
+      currency: refund.currency,
+      providerCaptureId: session.providerCaptureId,
+      providerRefundId: refundId
+    });
+    return {
+      eventId,
+      eventType,
+      refundOperationId: refund.id,
+      refund: snapshot,
+      summary: {
+        amountMinor: refund.amountMinor,
+        currency: refund.currency
+      }
+    };
+  }
+  async _inputFromCheckoutSession(checkoutSession) {
+    const metadata = asRecord(checkoutSession.metadata);
+    const providerCorrelationReference = readString(metadata.providerCorrelationReference);
+    const providerInvoiceReference = readString(metadata.providerInvoiceReference);
+    const providerOrderId = readString(checkoutSession.id);
+    if (!providerCorrelationReference || !providerInvoiceReference || !providerOrderId) {
+      this.app.throw(400, 'Stripe Checkout Session is not correlated');
+    }
+    const session = await this.$scope.pay.model.paymentSession.get({
+      providerCorrelationReference
+    });
+    if (!session || session.providerInvoiceReference !== providerInvoiceReference) {
+      this.app.throw(400, 'Stripe Checkout Session is not correlated');
+    }
+    return {
+      paymentSessionId: session.id,
+      businessReference: session.businessReference,
+      providerInvoiceReference: session.providerInvoiceReference,
+      providerCorrelationReference: session.providerCorrelationReference,
+      idempotencyKey: '',
+      amountMinor: session.amountMinor,
+      currency: session.currency,
+      providerOrderId
+    };
+  }
+  _mapCheckoutSession(checkoutSession, input, clientOptions, requireRedirect = false) {
+    const record = asRecord(checkoutSession);
+    const providerOrderId = readString(record.id);
+    const amountMinor = readInteger(record.amount_total);
+    const currency = readString(record.currency)?.toUpperCase();
+    const metadata = asRecord(record.metadata);
+    if (!providerOrderId || input.providerOrderId && input.providerOrderId !== providerOrderId || amountMinor !== input.amountMinor || currency !== input.currency || readString(record.client_reference_id) !== input.providerCorrelationReference || readString(metadata.providerCorrelationReference) !== input.providerCorrelationReference || readString(metadata.providerInvoiceReference) !== input.providerInvoiceReference || !this._matchesEnvironment(record, clientOptions)) {
+      this.app.throw(409, 'Stripe Checkout Session facts conflict with the payment session');
+    }
+    const paymentIntent = asRecord(record.payment_intent);
+    const paymentIntentId = readString(record.payment_intent) ?? readString(paymentIntent.id) ?? undefined;
+    if (paymentIntentId && Object.keys(paymentIntent).length) {
+      return this._mapPaymentIntent(paymentIntent, {
+        ...input,
+        providerOrderId
+      }, providerOrderId);
+    }
+    if (record.status === 'expired') {
+      return {
+        state: 'cancelled',
+        providerPaymentId: providerOrderId,
+        providerOrderId
+      };
+    }
+    if (record.payment_status === 'paid' && paymentIntentId) {
+      return {
+        state: 'succeeded',
+        providerPaymentId: paymentIntentId,
+        providerOrderId,
+        providerCaptureId: paymentIntentId,
+        nextAction: {
+          kind: 'completed'
+        }
+      };
+    }
+    const url = readString(record.url);
+    if (requireRedirect && !url) this.app.throw(502, 'Stripe did not return a Checkout URL');
+    return {
+      state: 'requires_action',
+      providerPaymentId: providerOrderId,
+      providerOrderId,
+      ...(url && {
+        nextAction: {
+          kind: 'redirect',
+          url
+        }
+      })
+    };
   }
-  async confirmPayment(_input, _clientOptions) {
-    this.app.throw(501, 'Stripe provider is not implemented');
+  _mapPaymentIntent(paymentIntent, input, providerOrderId = input.providerOrderId) {
+    const providerPaymentId = readString(paymentIntent.id);
+    const amountMinor = readInteger(paymentIntent.amount);
+    const currency = readString(paymentIntent.currency)?.toUpperCase();
+    const metadata = asRecord(paymentIntent.metadata);
+    if (!providerPaymentId || amountMinor !== input.amountMinor || currency !== input.currency || readString(metadata.providerCorrelationReference) !== input.providerCorrelationReference || readString(metadata.providerInvoiceReference) !== input.providerInvoiceReference) {
+      this.app.throw(409, 'Stripe PaymentIntent facts conflict with the payment session');
+    }
+    const status = readString(paymentIntent.status);
+    if (status === 'succeeded') {
+      return {
+        state: 'succeeded',
+        providerPaymentId,
+        providerOrderId,
+        providerCaptureId: providerPaymentId,
+        nextAction: {
+          kind: 'completed'
+        }
+      };
+    }
+    if (status === 'processing') return {
+      state: 'processing',
+      providerPaymentId,
+      providerOrderId
+    };
+    if (status === 'canceled') return {
+      state: 'cancelled',
+      providerPaymentId,
+      providerOrderId
+    };
+    if (status === 'requires_payment_method') return {
+      state: 'failed',
+      providerPaymentId,
+      providerOrderId
+    };
+    return {
+      state: 'requires_action',
+      providerPaymentId,
+      providerOrderId
+    };
+  }
+  _mapRefund(refund, input) {
+    const record = asRecord(refund);
+    const providerRefundId = readString(record.id);
+    const amountMinor = readInteger(record.amount);
+    const currency = readString(record.currency)?.toUpperCase();
+    const metadata = asRecord(record.metadata);
+    const paymentIntent = readString(record.payment_intent);
+    if (!providerRefundId || input.providerRefundId && input.providerRefundId !== providerRefundId || amountMinor !== input.amountMinor || currency !== input.currency || paymentIntent !== input.providerCaptureId || readString(metadata.providerCorrelationReference) !== input.providerCorrelationReference || readString(metadata.providerInvoiceReference) !== input.providerInvoiceReference) {
+      this.app.throw(409, 'Stripe refund facts conflict with the refund operation');
+    }
+    const status = readString(record.status);
+    if (status === 'succeeded') return {
+      state: 'succeeded',
+      providerRefundId
+    };
+    if (status === 'failed') return {
+      state: 'failed',
+      providerRefundId
+    };
+    if (status === 'canceled') return {
+      state: 'cancelled',
+      providerRefundId
+    };
+    return {
+      state: 'pending',
+      providerRefundId
+    };
+  }
+  _paymentMetadata(input) {
+    return {
+      paymentSessionId: String(input.paymentSessionId),
+      providerCorrelationReference: input.providerCorrelationReference,
+      providerInvoiceReference: input.providerInvoiceReference
+    };
+  }
+  _refundMetadata(input) {
+    return {
+      paymentSessionId: String(input.paymentSessionId),
+      refundOperationId: String(input.refundOperationId),
+      providerCorrelationReference: input.providerCorrelationReference,
+      providerInvoiceReference: input.providerInvoiceReference
+    };
   }
-  async queryPayment(_input, _clientOptions) {
-    this.app.throw(501, 'Stripe provider is not implemented');
+  _gateway(clientOptions) {
+    return clientOptions.gateway ?? createStripeGateway();
   }
-  async createRefund(_input, _clientOptions) {
-    this.app.throw(501, 'Stripe provider is not implemented');
+  _gatewayOptions(clientOptions) {
+    const secretKey = clientOptions.secretCredential;
+    const webhookSecret = clientOptions.secretWebhook;
+    if (!secretKey || !webhookSecret) this.app.throw(503, 'Stripe is not fully configured');
+    return {
+      secretKey,
+      webhookSecret
+    };
   }
-  async verifyWebhook(_input, _clientOptions) {
-    this.app.throw(501, 'Stripe provider is not implemented');
+  _matchesEnvironment(value, clientOptions) {
+    const livemode = value.livemode;
+    return typeof livemode !== 'boolean' || livemode === (clientOptions.environment === 'live');
+  }
+  _isDefinitiveRefundRejection(error) {
+    return isStripeDefinitiveRejection(error);
+  }
+  _throwTerminalPaymentFailure(error) {
+    if (isStripeDefinitiveRejection(error)) {
+      throw new ProviderOperationFailure('stripe_request_rejected', 'Stripe rejected the payment request');
+    }
+    throw error;
+  }
+  _throwGatewayError(error) {
+    if (error instanceof StripeGatewayError) this.app.throw(error.status, error.message);
+    throw error;
   }
 };
 PayProviderStripe = __decorate([PayProvider({
   base: {
     capabilities: {
-      redirectCheckout: false,
-      embeddedCheckout: true,
+      redirectCheckout: true,
+      embeddedCheckout: false,
       automaticCapture: true,
       manualCapture: false,
       refunds: true,
@@ -35,14 +502,34 @@ PayProviderStripe = __decorate([PayProvider({
   },
   clients: {
     default: {
-      environment: 'sandbox',
+      environment: app.meta.env.STRIPE_ENVIRONMENT,
       secretCredential: app.meta.env.STRIPE_SECRET_KEY,
-      secretWebhook: app.meta.env.STRIPE_WEBHOOK_SECRET
+      secretWebhook: app.meta.env.STRIPE_WEBHOOK_SECRET,
+      merchantReference: app.meta.env.STRIPE_MERCHANT_REFERENCE
     }
   }
 }), BeanInfo({
   module: "pay-stripe"
 })], PayProviderStripe);
+function isStripeDefinitiveRejection(error) {
+  if (error instanceof StripeGatewayError) return error.status >= 400 && error.status < 500;
+  const type = error?.type;
+  return ['StripeInvalidRequestError', 'StripeIdempotencyError', 'StripeAuthenticationError', 'StripePermissionError'].includes(type);
+}
+function assertStripeMoney(amountMinor, currency) {
+  if (!Number.isSafeInteger(amountMinor) || amountMinor <= 0 || currency !== 'USD') {
+    throw new Error('Stripe supports only positive USD minor-unit amounts');
+  }
+}
+function asRecord(value) {
+  return value && typeof value === 'object' ? value : {};
+}
+function readString(value) {
+  return typeof value === 'string' && value ? value : undefined;
+}
+function readInteger(value) {
+  return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
+}
 
 let ScopeModulePayStripe = class ScopeModulePayStripe extends BeanScopeBase {};
 ScopeModulePayStripe = __decorate([Scope(), BeanInfo({