@zucker-framework/payment 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -86,7 +86,49 @@ PaymentService = _ts_decorate([
 ], PaymentService);
 
 // src/order.service.ts
-import { Injectable as Injectable2, Logger as Logger2 } from "@nestjs/common";
+import { Injectable as Injectable2, Inject } from "@nestjs/common";
+
+// src/order-persistence.ts
+var ORDER_PERSISTENCE = "PAYMENT_ORDER_PERSISTENCE";
+var DatabaseOrderPersistence = class {
+  static {
+    __name(this, "DatabaseOrderPersistence");
+  }
+  model;
+  constructor(model) {
+    this.model = model;
+  }
+  create(args) {
+    return this.model.create(args);
+  }
+  findUnique(args) {
+    return this.model.findUnique(args);
+  }
+  findMany(args) {
+    return this.model.findMany(args);
+  }
+  update(args) {
+    return this.model.update(args);
+  }
+  updateMany(args) {
+    return this.model.updateMany(args);
+  }
+  count(args) {
+    return this.model.count(args);
+  }
+  async compareAndSet(id, expected, data) {
+    const result = await this.model.updateMany({
+      where: {
+        ...expected,
+        id
+      },
+      data
+    });
+    return result.count === 1;
+  }
+};
+
+// src/order.service.ts
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -107,137 +149,166 @@ function _ts_metadata(metadataKey, metadataValue) {
   }
 }
 __name(_ts_metadata, "_ts_metadata");
-var OrderService = class _OrderService {
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var OrderNotFoundError = class extends Error {
+  static {
+    __name(this, "OrderNotFoundError");
+  }
+  orderId;
+  constructor(orderId) {
+    super(`\u8BA2\u5355 "${orderId}" \u4E0D\u5B58\u5728`), this.orderId = orderId;
+    this.name = "OrderNotFoundError";
+  }
+};
+var OrderService = class {
   static {
     __name(this, "OrderService");
   }
   paymentService;
-  logger = new Logger2(_OrderService.name);
-  orders = /* @__PURE__ */ new Map();
-  constructor(paymentService) {
+  orders;
+  constructor(paymentService, orders) {
     this.paymentService = paymentService;
+    this.orders = orders;
+    if (!orders) throw new Error("Order persistence must be configured");
   }
-  /** 创建订单并发起支付 */
   async createOrder(params) {
-    const { orderId, providerId, payment } = params;
-    if (this.orders.has(orderId)) {
-      throw new Error(`\u8BA2\u5355 "${orderId}" \u5DF2\u5B58\u5728`);
+    if (await this.orders.findUnique({
+      where: {
+        id: params.orderId
+      }
+    })) {
+      throw new Error(`\u8BA2\u5355 "${params.orderId}" \u5DF2\u5B58\u5728`);
     }
     const now = /* @__PURE__ */ new Date();
-    const order = {
-      id: orderId,
-      providerId,
-      amount: payment.amount,
-      currency: payment.currency,
-      status: "created",
-      metadata: payment.metadata,
-      createdAt: now,
-      updatedAt: now
-    };
-    this.orders.set(orderId, order);
-    this.logger.log(`\u8BA2\u5355 "${orderId}" \u5DF2\u521B\u5EFA`);
-    try {
-      const intent = await this.paymentService.createPaymentIntent(providerId, payment);
-      order.paymentIntentId = intent.id;
-      order.status = "paying";
-      order.updatedAt = /* @__PURE__ */ new Date();
-      this.logger.log(`\u8BA2\u5355 "${orderId}" \u652F\u4ED8\u5DF2\u53D1\u8D77, intentId=${intent.id}`);
-    } catch (error) {
-      order.status = "failed";
-      order.updatedAt = /* @__PURE__ */ new Date();
-      this.logger.error(`\u8BA2\u5355 "${orderId}" \u652F\u4ED8\u53D1\u8D77\u5931\u8D25`, error);
-      throw error;
-    }
-    return {
-      ...order
-    };
+    const order = await this.orders.create({
+      data: {
+        id: params.orderId,
+        providerId: params.providerId,
+        amount: params.payment.amount,
+        currency: params.payment.currency,
+        metadata: params.payment.metadata,
+        status: "created",
+        createdAt: now,
+        updatedAt: now
+      }
+    });
+    return this.initiatePayment(order, params.payment);
+  }
+  async initiatePayment(order, payment) {
+    const intent = await this.paymentService.createPaymentIntent(order.providerId, payment);
+    await this.transition(order.id, [
+      "created"
+    ], "paying", {
+      paymentIntentId: intent.id
+    });
+    return this.getOrder(order.id);
   }
-  /** 确认订单支付 */
   async confirmOrder(orderId) {
-    const order = this.getOrder(orderId);
-    if (order.status !== "paying") {
-      throw new Error(`\u8BA2\u5355 "${orderId}" \u72B6\u6001\u4E3A "${order.status}"\uFF0C\u65E0\u6CD5\u786E\u8BA4\u652F\u4ED8`);
-    }
-    if (!order.paymentIntentId) {
-      throw new Error(`\u8BA2\u5355 "${orderId}" \u7F3A\u5C11 paymentIntentId`);
-    }
+    const order = await this.getOrder(orderId);
+    if (!order.paymentIntentId) throw new Error(`\u8BA2\u5355 "${orderId}" \u7F3A\u5C11 paymentIntentId`);
+    await this.transition(orderId, [
+      "paying"
+    ], "confirming");
     const result = await this.paymentService.confirmPayment(order.providerId, order.paymentIntentId);
     if (result.status === "succeeded") {
-      order.status = "paid";
-      order.paymentId = result.id;
-      order.paidAt = result.paidAt ?? /* @__PURE__ */ new Date();
-    } else {
-      order.status = "failed";
+      await this.transition(orderId, [
+        "confirming"
+      ], "paid", {
+        paymentId: result.id,
+        paidAt: result.paidAt ?? /* @__PURE__ */ new Date()
+      });
+    } else if (result.status === "failed" || result.status === "cancelled") {
+      await this.transition(orderId, [
+        "confirming"
+      ], "failed");
+    } else if (result.status === "refunded") {
+      await this.transition(orderId, [
+        "confirming"
+      ], "refunded");
     }
-    order.updatedAt = /* @__PURE__ */ new Date();
-    this.logger.log(`\u8BA2\u5355 "${orderId}" \u652F\u4ED8\u7ED3\u679C: ${result.status}`);
     return result;
   }
-  /** 订单退款 */
   async refundOrder(orderId, amount, reason) {
-    const order = this.getOrder(orderId);
-    if (order.status !== "paid" && order.status !== "refunding") {
-      throw new Error(`\u8BA2\u5355 "${orderId}" \u72B6\u6001\u4E3A "${order.status}"\uFF0C\u65E0\u6CD5\u9000\u6B3E`);
-    }
-    if (!order.paymentId) {
-      throw new Error(`\u8BA2\u5355 "${orderId}" \u7F3A\u5C11 paymentId`);
-    }
-    order.status = "refunding";
-    order.updatedAt = /* @__PURE__ */ new Date();
+    const order = await this.getOrder(orderId);
+    if (!order.paymentId) throw new Error(`\u8BA2\u5355 "${orderId}" \u7F3A\u5C11 paymentId`);
+    await this.transition(orderId, [
+      "paid"
+    ], "refunding");
     const result = await this.paymentService.refund(order.providerId, order.paymentId, amount, reason);
     if (result.status === "succeeded") {
-      order.status = "refunded";
-      order.refundedAt = /* @__PURE__ */ new Date();
+      await this.transition(orderId, [
+        "refunding"
+      ], "refunded", {
+        refundedAt: /* @__PURE__ */ new Date()
+      });
     } else if (result.status === "failed") {
-      order.status = "paid";
+      await this.transition(orderId, [
+        "refunding"
+      ], "paid");
     }
-    order.updatedAt = /* @__PURE__ */ new Date();
-    this.logger.log(`\u8BA2\u5355 "${orderId}" \u9000\u6B3E\u7ED3\u679C: ${result.status}`);
     return result;
   }
-  /** 取消订单 */
-  cancelOrder(orderId) {
-    const order = this.getOrder(orderId);
-    const cancellableStates = [
+  async retryOrder(orderId) {
+    const order = await this.getOrder(orderId);
+    await this.transition(orderId, [
+      "failed"
+    ], "created");
+    return this.initiatePayment(order, {
+      amount: order.amount,
+      currency: order.currency,
+      metadata: order.metadata
+    });
+  }
+  async cancelOrder(orderId) {
+    await this.transition(orderId, [
       "created",
       "paying",
       "failed"
-    ];
-    if (!cancellableStates.includes(order.status)) {
-      throw new Error(`\u8BA2\u5355 "${orderId}" \u72B6\u6001\u4E3A "${order.status}"\uFF0C\u65E0\u6CD5\u53D6\u6D88`);
-    }
-    order.status = "cancelled";
-    order.updatedAt = /* @__PURE__ */ new Date();
-    this.logger.log(`\u8BA2\u5355 "${orderId}" \u5DF2\u53D6\u6D88`);
-    return {
-      ...order
-    };
+    ], "cancelled");
+    return this.getOrder(orderId);
   }
-  /** 查询订单 */
-  getOrder(orderId) {
-    const order = this.orders.get(orderId);
-    if (!order) {
-      throw new Error(`\u8BA2\u5355 "${orderId}" \u4E0D\u5B58\u5728`);
-    }
+  async getOrder(orderId) {
+    const order = await this.orders.findUnique({
+      where: {
+        id: orderId
+      }
+    });
+    if (!order) throw new OrderNotFoundError(orderId);
     return order;
   }
-  /** 列出所有订单 */
   listOrders() {
-    return Array.from(this.orders.values()).map((o) => ({
-      ...o
-    }));
+    return this.orders.findMany();
+  }
+  async transition(id, from, to, data = {}) {
+    const changed = await this.orders.compareAndSet(id, {
+      status: {
+        in: from
+      }
+    }, {
+      ...data,
+      status: to,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    if (!changed) throw new Error(`\u8BA2\u5355 "${id}" \u4E0D\u5B58\u5728\u6216\u72B6\u6001\u5DF2\u53D8\u5316\uFF0C\u65E0\u6CD5\u8F6C\u6362\u4E3A ${to}`);
   }
 };
 OrderService = _ts_decorate2([
   Injectable2(),
+  _ts_param(1, Inject(ORDER_PERSISTENCE)),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof PaymentService === "undefined" ? Object : PaymentService
+    typeof PaymentService === "undefined" ? Object : PaymentService,
+    typeof OrderPersistence === "undefined" ? Object : OrderPersistence
   ])
 ], OrderService);
 
 // src/recovery.service.ts
-import { Injectable as Injectable3, Logger as Logger3, Optional, Inject } from "@nestjs/common";
+import { Injectable as Injectable3, Logger as Logger2, Optional, Inject as Inject2 } from "@nestjs/common";
 import { EventEmitter2 } from "@nestjs/event-emitter";
 
 // src/payment.events.ts
@@ -271,15 +342,16 @@ function _ts_metadata2(metadataKey, metadataValue) {
   }
 }
 __name(_ts_metadata2, "_ts_metadata");
-function _ts_param(paramIndex, decorator) {
+function _ts_param2(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param, "_ts_param");
+__name(_ts_param2, "_ts_param");
 var RECOVERY_MAIL_SENDER = "RECOVERY_MAIL_SENDER";
 var RECOVERY_USER_LOOKUP = "RECOVERY_USER_LOOKUP";
 var RECOVERY_URL_GENERATOR = "RECOVERY_URL_GENERATOR";
+var RECOVERY_ATTEMPT_STORE = "RECOVERY_ATTEMPT_STORE";
 var DEFAULT_OPTIONS = {
   maxAttempts: 3,
   retryLinkExpireHours: 48,
@@ -290,18 +362,16 @@ var PaymentRecoveryService = class _PaymentRecoveryService {
     __name(this, "PaymentRecoveryService");
   }
   orderService;
-  paymentService;
+  attempts;
   mailSender;
   userLookup;
   urlGenerator;
   eventEmitter;
-  logger = new Logger3(_PaymentRecoveryService.name);
+  logger = new Logger2(_PaymentRecoveryService.name);
   options;
-  /** 内存挽回计数（生产环境建议由业务项目持久化） */
-  recoveryAttempts = /* @__PURE__ */ new Map();
-  constructor(orderService, paymentService, mailSender, userLookup, urlGenerator, eventEmitter) {
+  constructor(orderService, attempts, mailSender, userLookup, urlGenerator, eventEmitter) {
     this.orderService = orderService;
-    this.paymentService = paymentService;
+    this.attempts = attempts;
     this.mailSender = mailSender;
     this.userLookup = userLookup;
     this.urlGenerator = urlGenerator;
@@ -320,8 +390,9 @@ var PaymentRecoveryService = class _PaymentRecoveryService {
   async handleFailedPayment(orderId, errorCode, errorMessage) {
     let order;
     try {
-      order = this.orderService.getOrder(orderId);
-    } catch {
+      order = await this.orderService.getOrder(orderId);
+    } catch (error) {
+      if (!(error instanceof OrderNotFoundError)) throw error;
       this.logger.warn(`\u8BA2\u5355 ${orderId} \u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u633D\u56DE`);
       return;
     }
@@ -329,11 +400,11 @@ var PaymentRecoveryService = class _PaymentRecoveryService {
       this.logger.warn(`\u8BA2\u5355 ${orderId} \u72B6\u6001\u4E3A ${order.status}\uFF0C\u8DF3\u8FC7\u633D\u56DE`);
       return;
     }
-    const attempts = this.recoveryAttempts.get(orderId);
-    if (attempts && attempts.count >= this.options.maxAttempts) {
-      this.logger.log(`\u8BA2\u5355 ${orderId} \u5DF2\u633D\u56DE ${attempts.count} \u6B21\uFF0C\u4E0D\u518D\u53D1\u9001`);
+    if (!this.mailSender) {
+      this.logger.warn("Recovery mail sender is not configured; no attempt was reserved");
       return;
     }
+    if (!this.attempts) throw new Error("Recovery attempt persistence must be configured");
     const userId = order.metadata?.userId;
     let email;
     let userName = "";
@@ -354,32 +425,20 @@ var PaymentRecoveryService = class _PaymentRecoveryService {
       this.logger.warn(`\u8BA2\u5355 ${orderId} \u65E0\u6CD5\u751F\u6210\u91CD\u8BD5\u94FE\u63A5`);
       return;
     }
-    const errorReason = friendlyErrorReason(errorCode, errorMessage);
-    const attemptNumber = (attempts?.count ?? 0) + 1;
-    if (this.mailSender) {
-      try {
-        await this.mailSender.sendRecoveryEmail({
-          to: email,
-          userName: userName || email.split("@")[0],
-          orderId: order.id,
-          orderNumber: order.metadata?.orderNumber,
-          amount: order.amount,
-          currency: order.currency,
-          errorReason,
-          retryUrl,
-          expireHours: this.options.retryLinkExpireHours
-        });
-        this.logger.log(`\u633D\u56DE\u90AE\u4EF6\u5DF2\u53D1\u9001: ${email}, \u8BA2\u5355 ${orderId} (\u7B2C ${attemptNumber} \u6B21)`);
-      } catch (err) {
-        this.logger.error(`\u633D\u56DE\u90AE\u4EF6\u53D1\u9001\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
-        return;
-      }
-    } else {
-      this.logger.log(`[Recovery:NoMailSender] \u8BA2\u5355 ${orderId} \u9700\u8981\u633D\u56DE, email=${email}, retryUrl=${retryUrl}, reason=${errorReason}`);
-    }
-    this.recoveryAttempts.set(orderId, {
-      count: attemptNumber,
-      lastAt: /* @__PURE__ */ new Date()
+    const reservation = await this.attempts.claim(orderId, this.options.maxAttempts, /* @__PURE__ */ new Date());
+    if (!reservation) return;
+    const attemptNumber = reservation.attemptNumber;
+    await this.mailSender.sendRecoveryEmail({
+      to: email,
+      userName: userName || email.split("@")[0],
+      orderId: order.id,
+      orderNumber: order.metadata?.orderNumber,
+      amount: order.amount,
+      currency: order.currency,
+      errorReason: friendlyErrorReason(errorCode, errorMessage),
+      retryUrl,
+      expireHours: this.options.retryLinkExpireHours,
+      idempotencyKey: `payment-recovery:${orderId}:${attemptNumber}`
     });
     if (this.eventEmitter) {
       const event = {
@@ -395,28 +454,12 @@ var PaymentRecoveryService = class _PaymentRecoveryService {
   /**
   * 重试失败订单 — 将 failed → created 并重新发起支付
   */
-  async retryOrder(orderId) {
-    const order = this.orderService.getOrder(orderId);
-    if (order.status !== "failed") {
-      throw new Error(`\u8BA2\u5355 ${orderId} \u72B6\u6001\u4E3A ${order.status}\uFF0C\u4EC5 failed \u8BA2\u5355\u53EF\u91CD\u8BD5`);
-    }
-    const intent = await this.paymentService.createPaymentIntent(order.providerId, {
-      amount: order.amount,
-      currency: order.currency,
-      metadata: order.metadata
-    });
-    const internalOrder = this.orderService.getOrder(orderId);
-    internalOrder.paymentIntentId = intent.id;
-    internalOrder.status = "paying";
-    internalOrder.updatedAt = /* @__PURE__ */ new Date();
-    this.logger.log(`\u8BA2\u5355 ${orderId} \u91CD\u8BD5\u652F\u4ED8, \u65B0 intentId=${intent.id}`);
-    return {
-      ...internalOrder
-    };
+  retryOrder(orderId) {
+    return this.orderService.retryOrder(orderId);
   }
-  /** 获取订单挽回记录 */
   getRecoveryAttempts(orderId) {
-    return this.recoveryAttempts.get(orderId);
+    if (!this.attempts) throw new Error("Recovery attempt persistence must be configured");
+    return this.attempts.get(orderId);
   }
   async generateRetryUrl(order) {
     if (this.urlGenerator) {
@@ -427,17 +470,18 @@ var PaymentRecoveryService = class _PaymentRecoveryService {
 };
 PaymentRecoveryService = _ts_decorate3([
   Injectable3(),
-  _ts_param(2, Optional()),
-  _ts_param(2, Inject(RECOVERY_MAIL_SENDER)),
-  _ts_param(3, Optional()),
-  _ts_param(3, Inject(RECOVERY_USER_LOOKUP)),
-  _ts_param(4, Optional()),
-  _ts_param(4, Inject(RECOVERY_URL_GENERATOR)),
-  _ts_param(5, Optional()),
+  _ts_param2(1, Inject2(RECOVERY_ATTEMPT_STORE)),
+  _ts_param2(2, Optional()),
+  _ts_param2(2, Inject2(RECOVERY_MAIL_SENDER)),
+  _ts_param2(3, Optional()),
+  _ts_param2(3, Inject2(RECOVERY_USER_LOOKUP)),
+  _ts_param2(4, Optional()),
+  _ts_param2(4, Inject2(RECOVERY_URL_GENERATOR)),
+  _ts_param2(5, Optional()),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof OrderService === "undefined" ? Object : OrderService,
-    typeof PaymentService === "undefined" ? Object : PaymentService,
+    Object,
     typeof RecoveryMailSender === "undefined" ? Object : RecoveryMailSender,
     typeof RecoveryUserLookup === "undefined" ? Object : RecoveryUserLookup,
     typeof RecoveryUrlGenerator === "undefined" ? Object : RecoveryUrlGenerator,
@@ -477,30 +521,63 @@ function _ts_decorate4(decorators, target, key, desc) {
 }
 __name(_ts_decorate4, "_ts_decorate");
 var PAYMENT_PROVIDERS = "PAYMENT_PROVIDERS";
+var PAYMENT_OPTIONS = /* @__PURE__ */ Symbol("PAYMENT_OPTIONS");
+function configuredProviders() {
+  return [
+    {
+      provide: ORDER_PERSISTENCE,
+      inject: [
+        PAYMENT_OPTIONS
+      ],
+      useFactory: /* @__PURE__ */ __name((options) => {
+        if (!options.orderPersistence) throw new Error("Order persistence must be configured");
+        return options.orderPersistence;
+      }, "useFactory")
+    },
+    {
+      provide: RECOVERY_ATTEMPT_STORE,
+      inject: [
+        PAYMENT_OPTIONS
+      ],
+      useFactory: /* @__PURE__ */ __name((options) => options.recoveryAttempts ?? null, "useFactory")
+    },
+    {
+      provide: PaymentService,
+      inject: [
+        PAYMENT_OPTIONS
+      ],
+      useFactory: /* @__PURE__ */ __name((options) => {
+        const service = new PaymentService();
+        for (const provider of options.providers ?? []) service.register(provider);
+        return service;
+      }, "useFactory")
+    },
+    OrderService,
+    PaymentRecoveryService,
+    {
+      provide: PAYMENT_PROVIDERS,
+      inject: [
+        PaymentService
+      ],
+      useFactory: /* @__PURE__ */ __name((service) => service.listProviders(), "useFactory")
+    }
+  ];
+}
+__name(configuredProviders, "configuredProviders");
 var ZuckerPaymentModule = class _ZuckerPaymentModule {
   static {
     __name(this, "ZuckerPaymentModule");
   }
-  static forRoot(options = {}) {
+  static forRoot(options) {
     return {
       module: _ZuckerPaymentModule,
       global: true,
       providers: [
-        PaymentService,
-        OrderService,
-        PaymentRecoveryService,
         {
-          provide: PAYMENT_PROVIDERS,
-          useFactory: /* @__PURE__ */ __name((paymentService) => {
-            for (const provider of options.providers ?? []) {
-              paymentService.register(provider);
-            }
-            return paymentService.listProviders();
-          }, "useFactory"),
-          inject: [
-            PaymentService
-          ]
-        }
+          provide: PAYMENT_OPTIONS,
+          useValue: options
+        },
+        ...configuredProviders()
       ],
       exports: [
         PaymentService,
@@ -515,24 +592,12 @@ var ZuckerPaymentModule = class _ZuckerPaymentModule {
       global: true,
       imports: options.imports ?? [],
       providers: [
-        PaymentService,
-        OrderService,
-        PaymentRecoveryService,
         {
-          provide: PAYMENT_PROVIDERS,
-          useFactory: /* @__PURE__ */ __name(async (paymentService, ...args) => {
-            const factoryFn = options.useFactory;
-            const moduleOptions = await factoryFn(...args);
-            for (const provider of moduleOptions.providers ?? []) {
-              paymentService.register(provider);
-            }
-            return paymentService.listProviders();
-          }, "useFactory"),
-          inject: [
-            PaymentService,
-            ...options.inject ?? []
-          ]
-        }
+          provide: PAYMENT_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject ?? []
+        },
+        ...configuredProviders()
       ],
       exports: [
         PaymentService,
@@ -546,15 +611,240 @@ ZuckerPaymentModule = _ts_decorate4([
   Global(),
   Module({})
 ], ZuckerPaymentModule);
+
+// src/providers/stripe.ts
+import { createRequire } from "module";
+var requireSdk = createRequire(typeof __filename === "string" ? __filename : import.meta.url);
+function createStripeClient(secretKey, options) {
+  const StripeSdk = requireSdk("stripe");
+  return new StripeSdk(secretKey, options);
+}
+__name(createStripeClient, "createStripeClient");
+function verifyStripeWebhookEvent(client, payload, signature, webhookSecret) {
+  return client.webhooks.constructEvent(payload, signature, webhookSecret);
+}
+__name(verifyStripeWebhookEvent, "verifyStripeWebhookEvent");
+function stripeResourceId(value) {
+  return typeof value === "string" ? value : value?.id;
+}
+__name(stripeResourceId, "stripeResourceId");
+function observeStripeCheckoutSession(raw) {
+  return {
+    raw,
+    id: raw.id,
+    url: raw.url || void 0,
+    clientReferenceId: raw.client_reference_id || void 0,
+    paymentIntentId: stripeResourceId(raw.payment_intent),
+    subscriptionId: stripeResourceId(raw.subscription),
+    settlement: raw.payment_status === "paid" ? "paid" : raw.status === "expired" ? "unpaid" : "unknown"
+  };
+}
+__name(observeStripeCheckoutSession, "observeStripeCheckoutSession");
+async function createStripeCheckoutSession(client, params) {
+  return observeStripeCheckoutSession(await client.checkout.sessions.create(params));
+}
+__name(createStripeCheckoutSession, "createStripeCheckoutSession");
+async function retrieveStripeCheckoutSession(client, id) {
+  return observeStripeCheckoutSession(await client.checkout.sessions.retrieve(id));
+}
+__name(retrieveStripeCheckoutSession, "retrieveStripeCheckoutSession");
+function observeStripePaymentIntent(raw) {
+  const charge = typeof raw.latest_charge === "object" ? raw.latest_charge : null;
+  return {
+    raw,
+    id: raw.id,
+    chargeId: stripeResourceId(raw.latest_charge) ?? null,
+    paymentMethodType: charge?.payment_method_details?.type,
+    failureCode: raw.last_payment_error?.code,
+    failureMessage: raw.last_payment_error?.message,
+    settlement: raw.status === "succeeded" ? "paid" : raw.status === "canceled" ? "unpaid" : "unknown"
+  };
+}
+__name(observeStripePaymentIntent, "observeStripePaymentIntent");
+async function retrieveStripePaymentIntent(client, id, params) {
+  const raw = params ? await client.paymentIntents.retrieve(id, params) : await client.paymentIntents.retrieve(id);
+  return observeStripePaymentIntent(raw);
+}
+__name(retrieveStripePaymentIntent, "retrieveStripePaymentIntent");
+
+// src/providers/paypal.ts
+import { createRequire as createRequire2 } from "module";
+var requireSdk2 = createRequire2(typeof __filename === "string" ? __filename : import.meta.url);
+function observePayPalOrder(raw) {
+  return {
+    raw,
+    id: raw.id,
+    approveUrl: raw.links?.find((link) => link.rel === "approve")?.href,
+    captureId: raw.purchaseUnits?.[0]?.payments?.captures?.[0]?.id,
+    settlement: raw.status === "COMPLETED" ? "paid" : raw.status === "VOIDED" ? "unpaid" : "unknown"
+  };
+}
+__name(observePayPalOrder, "observePayPalOrder");
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+__name(asRecord, "asRecord");
+function decodePayPalWebhookEvent(payload) {
+  const raw = asRecord(JSON.parse(payload));
+  if (!raw || typeof raw.event_type !== "string") throw new Error("Invalid PayPal webhook event");
+  const type = raw.event_type;
+  const kind = type === "PAYMENT.CAPTURE.COMPLETED" ? "capture-succeeded" : type === "PAYMENT.CAPTURE.DENIED" || type === "PAYMENT.CAPTURE.DECLINED" ? "capture-failed" : "unknown";
+  if (kind === "unknown") return {
+    raw,
+    type,
+    kind
+  };
+  const resource = asRecord(raw.resource);
+  if (!resource || typeof resource.id !== "string" || !resource.id) {
+    throw new Error("PayPal capture event is missing its resource ID");
+  }
+  const reason = asRecord(resource.status_details)?.reason;
+  return {
+    raw,
+    type,
+    kind,
+    capture: {
+      raw: resource,
+      id: resource.id,
+      failureReason: typeof reason === "string" ? reason : void 0
+    }
+  };
+}
+__name(decodePayPalWebhookEvent, "decodePayPalWebhookEvent");
+var PayPalPaymentTransport = class {
+  static {
+    __name(this, "PayPalPaymentTransport");
+  }
+  options;
+  orders;
+  baseUrl;
+  fetcher;
+  constructor(options) {
+    this.options = options;
+    const { Client, Environment, LogLevel, OrdersController } = requireSdk2("@paypal/paypal-server-sdk");
+    const client = new Client({
+      clientCredentialsAuthCredentials: {
+        oAuthClientId: options.clientId,
+        oAuthClientSecret: options.clientSecret
+      },
+      timeout: 0,
+      environment: options.mode === "live" ? Environment.Production : Environment.Sandbox,
+      logging: {
+        logLevel: LogLevel.Info,
+        logRequest: {
+          logBody: false
+        },
+        logResponse: {
+          logHeaders: false
+        }
+      }
+    });
+    this.orders = new OrdersController(client);
+    this.baseUrl = options.mode === "live" ? "https://api.paypal.com" : "https://api.sandbox.paypal.com";
+    this.fetcher = options.fetcher ?? fetch;
+  }
+  async createOrder(input) {
+    const { result } = await this.orders.createOrder(input);
+    return observePayPalOrder(result);
+  }
+  /** An explicit capture command; never invoked by getOrder or status observation. */
+  async captureOrder(input) {
+    const { result } = await this.orders.captureOrder(input);
+    return observePayPalOrder(result);
+  }
+  async getOrder(input) {
+    const { result } = await this.orders.getOrder(input);
+    return observePayPalOrder(result);
+  }
+  async getAccessToken() {
+    const response = await this.fetcher(`${this.baseUrl}/v1/oauth2/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Authorization: `Basic ${Buffer.from(`${this.options.clientId}:${this.options.clientSecret}`).toString("base64")}`
+      },
+      body: "grant_type=client_credentials"
+    });
+    const data = await response.json();
+    if (!response.ok || typeof data.access_token !== "string" || !data.access_token) {
+      throw new Error("Unable to obtain PayPal access token");
+    }
+    return data.access_token;
+  }
+  async verifyWebhookSignature(payload, headers, webhookId) {
+    const transmissionId = headers["paypal-transmission-id"];
+    const transmissionTime = headers["paypal-transmission-time"];
+    const certUrl = headers["paypal-cert-url"];
+    const authAlgo = headers["paypal-auth-algo"];
+    const transmissionSig = headers["paypal-transmission-sig"];
+    if (!transmissionId || !transmissionTime || !certUrl || !authAlgo || !transmissionSig) {
+      this.options.logger?.warn("PayPal webhook is missing required signature headers");
+      return false;
+    }
+    try {
+      const accessToken = await this.getAccessToken();
+      const response = await this.fetcher(`${this.baseUrl}/v1/notifications/verify-webhook-signature`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${accessToken}`
+        },
+        body: JSON.stringify({
+          auth_algo: authAlgo,
+          cert_url: certUrl,
+          transmission_id: transmissionId,
+          transmission_sig: transmissionSig,
+          transmission_time: transmissionTime,
+          webhook_id: webhookId,
+          webhook_event: JSON.parse(payload)
+        })
+      });
+      const result = await response.json();
+      return response.ok && result.verification_status === "SUCCESS";
+    } catch (error) {
+      this.options.logger?.error(`PayPal webhook verification failed: ${error instanceof Error ? error.message : String(error)}`);
+      return false;
+    }
+  }
+  async refundCapture(captureId, request) {
+    const accessToken = await this.getAccessToken();
+    const response = await this.fetcher(`${this.baseUrl}/v2/payments/captures/${encodeURIComponent(captureId)}/refund`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`
+      },
+      body: JSON.stringify(request)
+    });
+    const result = await response.json();
+    if (!response.ok && result.status === "COMPLETED") throw new Error(`PayPal refund request failed (${response.status})`);
+    return result;
+  }
+};
 export {
+  DatabaseOrderPersistence,
+  ORDER_PERSISTENCE,
+  OrderNotFoundError,
   OrderService,
   PAYMENT_PROVIDERS,
+  PayPalPaymentTransport,
   PaymentEvents,
   PaymentRecoveryService,
   PaymentService,
+  RECOVERY_ATTEMPT_STORE,
   RECOVERY_MAIL_SENDER,
   RECOVERY_URL_GENERATOR,
   RECOVERY_USER_LOOKUP,
   ZuckerPaymentModule,
-  friendlyErrorReason
+  createStripeCheckoutSession,
+  createStripeClient,
+  decodePayPalWebhookEvent,
+  friendlyErrorReason,
+  observePayPalOrder,
+  observeStripeCheckoutSession,
+  observeStripePaymentIntent,
+  retrieveStripeCheckoutSession,
+  retrieveStripePaymentIntent,
+  stripeResourceId,
+  verifyStripeWebhookEvent
 };