@magnet-cms/plugin-stripe 0.1.0

package/dist/chunk-IPPZL6QM.js

@@ -0,0 +1,2257 @@
+import { Field, Prop, Schema, InjectModel } from '@magnet-cms/common';
+import { Plugin, InjectPluginOptions, DatabaseModule, RestrictedRoute, EmailService } from '@magnet-cms/core';
+import { Logger, HttpException, HttpStatus, Injectable, Module, Post, Body, Get, Param, Controller, HttpCode, Req, Headers, Optional } from '@nestjs/common';
+import Stripe from 'stripe';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+function _ts_decorate(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var StripeCustomer;
+var init_customer_schema = __esm({
+  "src/schemas/customer.schema.ts"() {
+    __name(_ts_decorate, "_ts_decorate");
+    __name(_ts_metadata, "_ts_metadata");
+    StripeCustomer = class {
+      static {
+        __name(this, "StripeCustomer");
+      }
+      /** Stripe Customer ID (cus_...) */
+      stripeCustomerId;
+      /** Customer email address */
+      email;
+      /** Customer display name */
+      name;
+      /** Reference to the Magnet user ID */
+      userId;
+      /** Arbitrary metadata from Stripe */
+      metadata;
+      /** When the customer was created in Stripe */
+      createdAt;
+    };
+    _ts_decorate([
+      Field.Text({
+        required: true,
+        unique: true
+      }),
+      _ts_metadata("design:type", String)
+    ], StripeCustomer.prototype, "stripeCustomerId", void 0);
+    _ts_decorate([
+      Field.Email({
+        required: true
+      }),
+      _ts_metadata("design:type", String)
+    ], StripeCustomer.prototype, "email", void 0);
+    _ts_decorate([
+      Field.Text(),
+      _ts_metadata("design:type", String)
+    ], StripeCustomer.prototype, "name", void 0);
+    _ts_decorate([
+      Field.Text(),
+      _ts_metadata("design:type", String)
+    ], StripeCustomer.prototype, "userId", void 0);
+    _ts_decorate([
+      Prop({
+        type: Object
+      }),
+      _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+    ], StripeCustomer.prototype, "metadata", void 0);
+    _ts_decorate([
+      Field.Date({
+        required: true,
+        default: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "default")
+      }),
+      _ts_metadata("design:type", typeof Date === "undefined" ? Object : Date)
+    ], StripeCustomer.prototype, "createdAt", void 0);
+    StripeCustomer = _ts_decorate([
+      Schema({
+        versioning: false,
+        i18n: false,
+        visible: false
+      })
+    ], StripeCustomer);
+  }
+});
+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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var StripePayment;
+var init_payment_schema = __esm({
+  "src/schemas/payment.schema.ts"() {
+    __name(_ts_decorate2, "_ts_decorate");
+    __name(_ts_metadata2, "_ts_metadata");
+    StripePayment = class {
+      static {
+        __name(this, "StripePayment");
+      }
+      /** Stripe PaymentIntent ID (pi_...) or Invoice ID (in_...) */
+      stripePaymentIntentId;
+      /** Reference to StripeCustomer.stripeCustomerId */
+      customerId;
+      /** Payment amount in the smallest currency unit (e.g., cents) */
+      amount;
+      /** Three-letter ISO currency code */
+      currency;
+      /** Payment status */
+      status;
+      /** URL for the payment receipt */
+      receiptUrl;
+      /** Stripe Invoice ID if payment is from an invoice */
+      invoiceId;
+      /** When the payment was created */
+      createdAt;
+    };
+    _ts_decorate2([
+      Field.Text({
+        required: true,
+        unique: true
+      }),
+      _ts_metadata2("design:type", String)
+    ], StripePayment.prototype, "stripePaymentIntentId", void 0);
+    _ts_decorate2([
+      Field.Text({
+        required: true
+      }),
+      _ts_metadata2("design:type", String)
+    ], StripePayment.prototype, "customerId", void 0);
+    _ts_decorate2([
+      Field.Number({
+        required: true
+      }),
+      _ts_metadata2("design:type", Number)
+    ], StripePayment.prototype, "amount", void 0);
+    _ts_decorate2([
+      Field.Text({
+        required: true
+      }),
+      _ts_metadata2("design:type", String)
+    ], StripePayment.prototype, "currency", void 0);
+    _ts_decorate2([
+      Field.Select({
+        required: true,
+        options: [
+          {
+            label: "Succeeded",
+            value: "succeeded"
+          },
+          {
+            label: "Failed",
+            value: "failed"
+          },
+          {
+            label: "Refunded",
+            value: "refunded"
+          },
+          {
+            label: "Pending",
+            value: "pending"
+          }
+        ]
+      }),
+      _ts_metadata2("design:type", String)
+    ], StripePayment.prototype, "status", void 0);
+    _ts_decorate2([
+      Field.Text(),
+      _ts_metadata2("design:type", String)
+    ], StripePayment.prototype, "receiptUrl", void 0);
+    _ts_decorate2([
+      Field.Text(),
+      _ts_metadata2("design:type", String)
+    ], StripePayment.prototype, "invoiceId", void 0);
+    _ts_decorate2([
+      Field.Date({
+        required: true,
+        default: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "default")
+      }),
+      _ts_metadata2("design:type", typeof Date === "undefined" ? Object : Date)
+    ], StripePayment.prototype, "createdAt", void 0);
+    StripePayment = _ts_decorate2([
+      Schema({
+        versioning: false,
+        i18n: false,
+        visible: false
+      })
+    ], StripePayment);
+  }
+});
+function _ts_decorate3(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var StripePrice;
+var init_price_schema = __esm({
+  "src/schemas/price.schema.ts"() {
+    __name(_ts_decorate3, "_ts_decorate");
+    __name(_ts_metadata3, "_ts_metadata");
+    StripePrice = class {
+      static {
+        __name(this, "StripePrice");
+      }
+      /** Stripe Price ID (price_...) */
+      stripePriceId;
+      /** Reference to the StripeProduct.stripeProductId */
+      productId;
+      /** Price amount in the smallest currency unit (e.g., cents) */
+      unitAmount;
+      /** Three-letter ISO currency code (e.g., 'usd') */
+      currency;
+      /** Pricing type */
+      type;
+      /** Billing interval for recurring prices */
+      interval;
+      /** Number of intervals between billings */
+      intervalCount;
+      /** Whether this price is currently active */
+      active = true;
+    };
+    _ts_decorate3([
+      Field.Text({
+        required: true,
+        unique: true
+      }),
+      _ts_metadata3("design:type", String)
+    ], StripePrice.prototype, "stripePriceId", void 0);
+    _ts_decorate3([
+      Field.Text({
+        required: true
+      }),
+      _ts_metadata3("design:type", String)
+    ], StripePrice.prototype, "productId", void 0);
+    _ts_decorate3([
+      Field.Number({
+        required: true
+      }),
+      _ts_metadata3("design:type", Number)
+    ], StripePrice.prototype, "unitAmount", void 0);
+    _ts_decorate3([
+      Field.Text({
+        required: true
+      }),
+      _ts_metadata3("design:type", String)
+    ], StripePrice.prototype, "currency", void 0);
+    _ts_decorate3([
+      Field.Select({
+        required: true,
+        options: [
+          {
+            label: "One-time",
+            value: "one_time"
+          },
+          {
+            label: "Recurring",
+            value: "recurring"
+          }
+        ]
+      }),
+      _ts_metadata3("design:type", String)
+    ], StripePrice.prototype, "type", void 0);
+    _ts_decorate3([
+      Field.Select({
+        options: [
+          {
+            label: "Day",
+            value: "day"
+          },
+          {
+            label: "Week",
+            value: "week"
+          },
+          {
+            label: "Month",
+            value: "month"
+          },
+          {
+            label: "Year",
+            value: "year"
+          }
+        ]
+      }),
+      _ts_metadata3("design:type", String)
+    ], StripePrice.prototype, "interval", void 0);
+    _ts_decorate3([
+      Field.Number(),
+      _ts_metadata3("design:type", Number)
+    ], StripePrice.prototype, "intervalCount", void 0);
+    _ts_decorate3([
+      Field.Boolean({
+        default: true
+      })
+    ], StripePrice.prototype, "active", void 0);
+    StripePrice = _ts_decorate3([
+      Schema({
+        versioning: false,
+        i18n: false,
+        visible: false
+      })
+    ], StripePrice);
+  }
+});
+function _ts_decorate4(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var StripeProcessedEvent;
+var init_processed_event_schema = __esm({
+  "src/schemas/processed-event.schema.ts"() {
+    __name(_ts_decorate4, "_ts_decorate");
+    __name(_ts_metadata4, "_ts_metadata");
+    StripeProcessedEvent = class {
+      static {
+        __name(this, "StripeProcessedEvent");
+      }
+      /** Stripe Event ID (evt_...) — unique to prevent reprocessing */
+      stripeEventId;
+      /** Event type (e.g., 'invoice.paid', 'customer.subscription.updated') */
+      eventType;
+      /** When this event was processed */
+      processedAt;
+    };
+    _ts_decorate4([
+      Field.Text({
+        required: true,
+        unique: true
+      }),
+      _ts_metadata4("design:type", String)
+    ], StripeProcessedEvent.prototype, "stripeEventId", void 0);
+    _ts_decorate4([
+      Field.Text({
+        required: true
+      }),
+      _ts_metadata4("design:type", String)
+    ], StripeProcessedEvent.prototype, "eventType", void 0);
+    _ts_decorate4([
+      Field.Date({
+        required: true,
+        default: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "default")
+      }),
+      _ts_metadata4("design:type", typeof Date === "undefined" ? Object : Date)
+    ], StripeProcessedEvent.prototype, "processedAt", void 0);
+    StripeProcessedEvent = _ts_decorate4([
+      Schema({
+        versioning: false,
+        i18n: false,
+        visible: false
+      })
+    ], StripeProcessedEvent);
+  }
+});
+function _ts_decorate5(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var StripeProduct;
+var init_product_schema = __esm({
+  "src/schemas/product.schema.ts"() {
+    __name(_ts_decorate5, "_ts_decorate");
+    __name(_ts_metadata5, "_ts_metadata");
+    StripeProduct = class {
+      static {
+        __name(this, "StripeProduct");
+      }
+      /** Stripe Product ID (prod_...) */
+      stripeProductId;
+      /** Product name */
+      name;
+      /** Product description */
+      description;
+      /** Whether the product is currently active in Stripe */
+      active = true;
+      /** Arbitrary metadata from Stripe */
+      metadata;
+      /** Product image URLs */
+      images;
+      /** When the product was last synced */
+      updatedAt;
+    };
+    _ts_decorate5([
+      Field.Text({
+        required: true,
+        unique: true
+      }),
+      _ts_metadata5("design:type", String)
+    ], StripeProduct.prototype, "stripeProductId", void 0);
+    _ts_decorate5([
+      Field.Text({
+        required: true
+      }),
+      _ts_metadata5("design:type", String)
+    ], StripeProduct.prototype, "name", void 0);
+    _ts_decorate5([
+      Field.Text(),
+      _ts_metadata5("design:type", String)
+    ], StripeProduct.prototype, "description", void 0);
+    _ts_decorate5([
+      Field.Boolean({
+        default: true
+      })
+    ], StripeProduct.prototype, "active", void 0);
+    _ts_decorate5([
+      Prop({
+        type: Object
+      }),
+      _ts_metadata5("design:type", typeof Record === "undefined" ? Object : Record)
+    ], StripeProduct.prototype, "metadata", void 0);
+    _ts_decorate5([
+      Prop({
+        type: [
+          String
+        ]
+      }),
+      _ts_metadata5("design:type", Array)
+    ], StripeProduct.prototype, "images", void 0);
+    _ts_decorate5([
+      Field.Date({
+        required: true,
+        default: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "default")
+      }),
+      _ts_metadata5("design:type", typeof Date === "undefined" ? Object : Date)
+    ], StripeProduct.prototype, "updatedAt", void 0);
+    StripeProduct = _ts_decorate5([
+      Schema({
+        versioning: false,
+        i18n: false,
+        visible: false
+      })
+    ], StripeProduct);
+  }
+});
+function _ts_decorate6(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var StripeSubscription;
+var init_subscription_schema = __esm({
+  "src/schemas/subscription.schema.ts"() {
+    __name(_ts_decorate6, "_ts_decorate");
+    __name(_ts_metadata6, "_ts_metadata");
+    StripeSubscription = class {
+      static {
+        __name(this, "StripeSubscription");
+      }
+      /** Stripe Subscription ID (sub_...) */
+      stripeSubscriptionId;
+      /** Reference to StripeCustomer.stripeCustomerId */
+      customerId;
+      /** Reference to StripePrice.stripePriceId */
+      priceId;
+      /** Subscription status from Stripe */
+      status;
+      /** Start of the current billing period */
+      currentPeriodStart;
+      /** End of the current billing period */
+      currentPeriodEnd;
+      /** Whether the subscription will be canceled at the end of the period */
+      cancelAtPeriodEnd = false;
+      /** When the trial ends (null if no trial) */
+      trialEnd;
+      /** When the subscription was last synced */
+      updatedAt;
+    };
+    _ts_decorate6([
+      Field.Text({
+        required: true,
+        unique: true
+      }),
+      _ts_metadata6("design:type", String)
+    ], StripeSubscription.prototype, "stripeSubscriptionId", void 0);
+    _ts_decorate6([
+      Field.Text({
+        required: true
+      }),
+      _ts_metadata6("design:type", String)
+    ], StripeSubscription.prototype, "customerId", void 0);
+    _ts_decorate6([
+      Field.Text({
+        required: true
+      }),
+      _ts_metadata6("design:type", String)
+    ], StripeSubscription.prototype, "priceId", void 0);
+    _ts_decorate6([
+      Field.Select({
+        required: true,
+        options: [
+          {
+            label: "Active",
+            value: "active"
+          },
+          {
+            label: "Past Due",
+            value: "past_due"
+          },
+          {
+            label: "Canceled",
+            value: "canceled"
+          },
+          {
+            label: "Incomplete",
+            value: "incomplete"
+          },
+          {
+            label: "Incomplete Expired",
+            value: "incomplete_expired"
+          },
+          {
+            label: "Trialing",
+            value: "trialing"
+          },
+          {
+            label: "Unpaid",
+            value: "unpaid"
+          },
+          {
+            label: "Paused",
+            value: "paused"
+          }
+        ]
+      }),
+      _ts_metadata6("design:type", String)
+    ], StripeSubscription.prototype, "status", void 0);
+    _ts_decorate6([
+      Field.Date({
+        required: true
+      }),
+      _ts_metadata6("design:type", typeof Date === "undefined" ? Object : Date)
+    ], StripeSubscription.prototype, "currentPeriodStart", void 0);
+    _ts_decorate6([
+      Field.Date({
+        required: true
+      }),
+      _ts_metadata6("design:type", typeof Date === "undefined" ? Object : Date)
+    ], StripeSubscription.prototype, "currentPeriodEnd", void 0);
+    _ts_decorate6([
+      Field.Boolean({
+        default: false
+      })
+    ], StripeSubscription.prototype, "cancelAtPeriodEnd", void 0);
+    _ts_decorate6([
+      Field.Date(),
+      _ts_metadata6("design:type", typeof Date === "undefined" ? Object : Date)
+    ], StripeSubscription.prototype, "trialEnd", void 0);
+    _ts_decorate6([
+      Field.Date({
+        required: true,
+        default: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Date(), "default")
+      }),
+      _ts_metadata6("design:type", typeof Date === "undefined" ? Object : Date)
+    ], StripeSubscription.prototype, "updatedAt", void 0);
+    StripeSubscription = _ts_decorate6([
+      Schema({
+        versioning: false,
+        i18n: false,
+        visible: false
+      })
+    ], StripeSubscription);
+  }
+});
+function _ts_decorate7(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeService;
+var init_stripe_service = __esm({
+  "src/stripe.service.ts"() {
+    __name(_ts_decorate7, "_ts_decorate");
+    __name(_ts_metadata7, "_ts_metadata");
+    __name(_ts_param, "_ts_param");
+    StripeService = class _StripeService {
+      static {
+        __name(this, "StripeService");
+      }
+      config;
+      logger;
+      stripe;
+      constructor(config) {
+        this.config = config;
+        this.logger = new Logger(_StripeService.name);
+        this.stripe = null;
+      }
+      onModuleInit() {
+        if (!this.config.secretKey) {
+          throw new Error("[StripePlugin] Missing secretKey in plugin options. Configure it via: { plugin: StripePlugin, options: { secretKey: process.env.STRIPE_SECRET_KEY } }");
+        }
+        this.stripe = new Stripe(this.config.secretKey, {
+          apiVersion: "2025-02-24.acacia"
+        });
+        if (this.config.webhookSecret) {
+          this.logger.debug("Webhook secret configured. Ensure rawBody is enabled in NestFactory.create() for signature verification.");
+        }
+      }
+      /** Get the initialized Stripe client */
+      get client() {
+        if (!this.stripe) {
+          throw new Error("[StripePlugin] Stripe client not initialized. Ensure the module has been initialized.");
+        }
+        return this.stripe;
+      }
+      /** Get the plugin configuration */
+      get pluginConfig() {
+        return this.config;
+      }
+      /**
+      * Verify that raw body is available on the request.
+      * Must be called before webhook signature verification.
+      * Consumers must enable `rawBody: true` in NestFactory.create().
+      */
+      verifyRawBodyAvailable(req) {
+        if (!req.rawBody) {
+          throw new HttpException("[StripePlugin] Raw request body not available. Enable rawBody in your NestJS bootstrap: NestFactory.create(AppModule, { rawBody: true }). This is required for Stripe webhook signature verification.", HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+      }
+    };
+    StripeService = _ts_decorate7([
+      Injectable(),
+      _ts_param(0, InjectPluginOptions("stripe")),
+      _ts_metadata7("design:type", Function),
+      _ts_metadata7("design:paramtypes", [
+        typeof StripePluginConfig === "undefined" ? Object : StripePluginConfig
+      ])
+    ], StripeService);
+  }
+});
+function _ts_decorate8(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeCustomerService;
+var init_customer_service = __esm({
+  "src/services/customer.service.ts"() {
+    init_customer_schema();
+    __name(_ts_decorate8, "_ts_decorate");
+    __name(_ts_metadata8, "_ts_metadata");
+    __name(_ts_param2, "_ts_param");
+    StripeCustomerService = class {
+      static {
+        __name(this, "StripeCustomerService");
+      }
+      customerModel;
+      constructor(customerModel) {
+        this.customerModel = customerModel;
+      }
+      /**
+      * Upsert a Stripe customer record from a Stripe Customer object.
+      */
+      async upsertFromStripe(stripeCustomer) {
+        const data = {
+          stripeCustomerId: stripeCustomer.id,
+          email: stripeCustomer.email ?? "",
+          name: stripeCustomer.name ?? void 0,
+          metadata: stripeCustomer.metadata
+        };
+        const existing = await this.customerModel.findOne({
+          stripeCustomerId: stripeCustomer.id
+        });
+        if (existing) {
+          return this.customerModel.update({
+            stripeCustomerId: stripeCustomer.id
+          }, data);
+        }
+        return this.customerModel.create(data);
+      }
+      /**
+      * Delete a customer record by Stripe Customer ID.
+      */
+      async deleteByStripeId(stripeCustomerId) {
+        await this.customerModel.delete({
+          stripeCustomerId
+        });
+      }
+      /**
+      * Find a customer by Magnet user ID.
+      */
+      async findByUserId(userId) {
+        return this.customerModel.findOne({
+          userId
+        });
+      }
+      /**
+      * Find a customer by Stripe Customer ID.
+      */
+      async findByStripeId(stripeCustomerId) {
+        return this.customerModel.findOne({
+          stripeCustomerId
+        });
+      }
+      /**
+      * List all customers.
+      */
+      async findAll() {
+        return this.customerModel.find();
+      }
+      /**
+      * Link a Stripe customer to a Magnet user.
+      */
+      async linkToUser(stripeCustomerId, userId) {
+        return this.customerModel.update({
+          stripeCustomerId
+        }, {
+          userId
+        });
+      }
+    };
+    StripeCustomerService = _ts_decorate8([
+      Injectable(),
+      _ts_param2(0, InjectModel(StripeCustomer)),
+      _ts_metadata8("design:type", Function),
+      _ts_metadata8("design:paramtypes", [
+        typeof Model === "undefined" ? Object : Model
+      ])
+    ], StripeCustomerService);
+  }
+});
+function _ts_decorate9(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeSubscriptionService;
+var init_subscription_service = __esm({
+  "src/services/subscription.service.ts"() {
+    init_subscription_schema();
+    init_stripe_service();
+    __name(_ts_decorate9, "_ts_decorate");
+    __name(_ts_metadata9, "_ts_metadata");
+    __name(_ts_param3, "_ts_param");
+    StripeSubscriptionService = class {
+      static {
+        __name(this, "StripeSubscriptionService");
+      }
+      subscriptionModel;
+      stripeService;
+      constructor(subscriptionModel, stripeService) {
+        this.subscriptionModel = subscriptionModel;
+        this.stripeService = stripeService;
+      }
+      /**
+      * Upsert a subscription from a Stripe Subscription object.
+      */
+      async syncSubscription(stripeSub) {
+        const customerId = typeof stripeSub.customer === "string" ? stripeSub.customer : stripeSub.customer.id;
+        const priceId = stripeSub.items.data[0]?.price?.id ?? "";
+        const data = {
+          stripeSubscriptionId: stripeSub.id,
+          customerId,
+          priceId,
+          status: stripeSub.status,
+          currentPeriodStart: new Date(stripeSub.current_period_start * 1e3),
+          currentPeriodEnd: new Date(stripeSub.current_period_end * 1e3),
+          cancelAtPeriodEnd: stripeSub.cancel_at_period_end,
+          trialEnd: stripeSub.trial_end ? new Date(stripeSub.trial_end * 1e3) : void 0,
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        const existing = await this.subscriptionModel.findOne({
+          stripeSubscriptionId: stripeSub.id
+        });
+        if (existing) {
+          return this.subscriptionModel.update({
+            stripeSubscriptionId: stripeSub.id
+          }, data);
+        }
+        return this.subscriptionModel.create(data);
+      }
+      /**
+      * Delete a subscription record by Stripe Subscription ID.
+      */
+      async deleteByStripeId(stripeSubscriptionId) {
+        await this.subscriptionModel.delete({
+          stripeSubscriptionId
+        });
+      }
+      /**
+      * Find active subscription for a customer.
+      */
+      async findActiveByCustomerId(customerId) {
+        return this.subscriptionModel.findOne({
+          customerId,
+          status: "active"
+        });
+      }
+      /**
+      * List all subscriptions.
+      */
+      async findAll() {
+        return this.subscriptionModel.find();
+      }
+      /**
+      * Cancel a subscription via the Stripe API.
+      */
+      async cancel(stripeSubscriptionId) {
+        await this.stripeService.client.subscriptions.cancel(stripeSubscriptionId);
+      }
+    };
+    StripeSubscriptionService = _ts_decorate9([
+      Injectable(),
+      _ts_param3(0, InjectModel(StripeSubscription)),
+      _ts_metadata9("design:type", Function),
+      _ts_metadata9("design:paramtypes", [
+        typeof Model === "undefined" ? Object : Model,
+        typeof StripeService === "undefined" ? Object : StripeService
+      ])
+    ], StripeSubscriptionService);
+  }
+});
+function _ts_decorate10(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeAccessService;
+var init_access_service = __esm({
+  "src/services/access.service.ts"() {
+    init_price_schema();
+    init_product_schema();
+    init_stripe_service();
+    init_customer_service();
+    init_subscription_service();
+    __name(_ts_decorate10, "_ts_decorate");
+    __name(_ts_metadata10, "_ts_metadata");
+    __name(_ts_param4, "_ts_param");
+    StripeAccessService = class {
+      static {
+        __name(this, "StripeAccessService");
+      }
+      stripeService;
+      customerService;
+      subscriptionService;
+      priceModel;
+      productModel;
+      constructor(stripeService, customerService, subscriptionService, priceModel, productModel) {
+        this.stripeService = stripeService;
+        this.customerService = customerService;
+        this.subscriptionService = subscriptionService;
+        this.priceModel = priceModel;
+        this.productModel = productModel;
+      }
+      /**
+      * Get subscription access info for a user.
+      * Returns subscription status, plan name, and feature flags.
+      */
+      async getAccess(userId) {
+        const noAccess = {
+          hasActiveSubscription: false,
+          plan: null,
+          expiresAt: null,
+          features: []
+        };
+        const customer = await this.customerService.findByUserId(userId);
+        if (!customer) {
+          return noAccess;
+        }
+        const subscription = await this.subscriptionService.findActiveByCustomerId(customer.stripeCustomerId);
+        if (!subscription) {
+          return noAccess;
+        }
+        const price = await this.priceModel.findOne({
+          stripePriceId: subscription.priceId
+        });
+        let planName = null;
+        if (price) {
+          const product = await this.productModel.findOne({
+            stripeProductId: price.productId
+          });
+          planName = product?.name ?? null;
+        }
+        const features = this.resolveFeaturesForPlan(planName);
+        return {
+          hasActiveSubscription: true,
+          plan: planName,
+          expiresAt: subscription.currentPeriodEnd,
+          features
+        };
+      }
+      /**
+      * Resolve feature flags for a plan name from plugin config.
+      */
+      resolveFeaturesForPlan(planName) {
+        if (!planName) return [];
+        const featuresConfig = this.stripeService.pluginConfig.features;
+        if (!featuresConfig) return [];
+        const normalizedPlan = planName.toLowerCase();
+        for (const [key, features] of Object.entries(featuresConfig)) {
+          if (key.toLowerCase() === normalizedPlan) {
+            return features;
+          }
+        }
+        return [];
+      }
+    };
+    StripeAccessService = _ts_decorate10([
+      Injectable(),
+      _ts_param4(3, InjectModel(StripePrice)),
+      _ts_param4(4, InjectModel(StripeProduct)),
+      _ts_metadata10("design:type", Function),
+      _ts_metadata10("design:paramtypes", [
+        typeof StripeService === "undefined" ? Object : StripeService,
+        typeof StripeCustomerService === "undefined" ? Object : StripeCustomerService,
+        typeof StripeSubscriptionService === "undefined" ? Object : StripeSubscriptionService,
+        typeof Model === "undefined" ? Object : Model,
+        typeof Model === "undefined" ? Object : Model
+      ])
+    ], StripeAccessService);
+  }
+});
+function _ts_decorate11(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var StripeCheckoutService;
+var init_checkout_service = __esm({
+  "src/services/checkout.service.ts"() {
+    init_stripe_service();
+    __name(_ts_decorate11, "_ts_decorate");
+    __name(_ts_metadata11, "_ts_metadata");
+    StripeCheckoutService = class {
+      static {
+        __name(this, "StripeCheckoutService");
+      }
+      stripeService;
+      constructor(stripeService) {
+        this.stripeService = stripeService;
+      }
+      /**
+      * Create a Stripe Checkout session.
+      */
+      async createCheckoutSession(dto) {
+        const config = this.stripeService.pluginConfig;
+        const session = await this.stripeService.client.checkout.sessions.create({
+          mode: "subscription",
+          payment_method_types: [
+            "card"
+          ],
+          line_items: [
+            {
+              price: dto.priceId,
+              quantity: 1
+            }
+          ],
+          success_url: dto.successUrl,
+          cancel_url: dto.cancelUrl,
+          currency: config.currency ?? "usd",
+          metadata: dto.metadata,
+          client_reference_id: dto.userId
+        });
+        return {
+          sessionId: session.id,
+          url: session.url ?? ""
+        };
+      }
+    };
+    StripeCheckoutService = _ts_decorate11([
+      Injectable(),
+      _ts_metadata11("design:type", Function),
+      _ts_metadata11("design:paramtypes", [
+        typeof StripeService === "undefined" ? Object : StripeService
+      ])
+    ], StripeCheckoutService);
+  }
+});
+function _ts_decorate12(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeMetricsService;
+var init_metrics_service = __esm({
+  "src/services/metrics.service.ts"() {
+    init_payment_schema();
+    init_subscription_schema();
+    init_stripe_service();
+    __name(_ts_decorate12, "_ts_decorate");
+    __name(_ts_metadata12, "_ts_metadata");
+    __name(_ts_param5, "_ts_param");
+    StripeMetricsService = class {
+      static {
+        __name(this, "StripeMetricsService");
+      }
+      paymentModel;
+      subscriptionModel;
+      stripeService;
+      constructor(paymentModel, subscriptionModel, stripeService) {
+        this.paymentModel = paymentModel;
+        this.subscriptionModel = subscriptionModel;
+        this.stripeService = stripeService;
+      }
+      /**
+      * Get dashboard metrics — hybrid of live Stripe API and local DB data.
+      */
+      async getMetrics() {
+        const [mrr, activeSubscriptions, revenueThisMonth, recentPayments] = await Promise.all([
+          this.calculateMRR(),
+          this.countActiveSubscriptions(),
+          this.calculateRevenueThisMonth(),
+          this.getRecentPayments()
+        ]);
+        const revenueByMonth = await this.getRevenueByMonth();
+        const churnRate = await this.calculateChurnRate();
+        return {
+          mrr,
+          revenueThisMonth,
+          activeSubscriptions,
+          churnRate,
+          revenueByMonth,
+          recentPayments
+        };
+      }
+      /**
+      * Calculate MRR from active subscriptions via live Stripe API.
+      */
+      async calculateMRR() {
+        try {
+          const subscriptions = await this.stripeService.client.subscriptions.list({
+            status: "active",
+            limit: 100
+          });
+          let mrr = 0;
+          for (const sub of subscriptions.data) {
+            for (const item of sub.items.data) {
+              const amount = item.price?.unit_amount ?? 0;
+              const interval = item.price?.recurring?.interval;
+              switch (interval) {
+                case "year":
+                  mrr += Math.round(amount / 12);
+                  break;
+                case "month":
+                  mrr += amount;
+                  break;
+                case "week":
+                  mrr += Math.round(amount * 4.33);
+                  break;
+                case "day":
+                  mrr += Math.round(amount * 30);
+                  break;
+              }
+            }
+          }
+          return mrr;
+        } catch {
+          return 0;
+        }
+      }
+      async countActiveSubscriptions() {
+        const subs = await this.subscriptionModel.findMany({
+          status: "active"
+        });
+        return subs.length;
+      }
+      async calculateRevenueThisMonth() {
+        const payments = await this.paymentModel.findMany({
+          status: "succeeded"
+        });
+        const now = /* @__PURE__ */ new Date();
+        const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+        return payments.filter((p) => new Date(p.createdAt) >= startOfMonth).reduce((sum, p) => sum + p.amount, 0);
+      }
+      async calculateChurnRate() {
+        const allSubs = await this.subscriptionModel.find();
+        if (allSubs.length === 0) return 0;
+        const canceled = allSubs.filter((s) => s.status === "canceled");
+        return Math.round(canceled.length / allSubs.length * 100);
+      }
+      async getRevenueByMonth() {
+        const payments = await this.paymentModel.findMany({
+          status: "succeeded"
+        });
+        const monthMap = /* @__PURE__ */ new Map();
+        const now = /* @__PURE__ */ new Date();
+        for (let i = 11; i >= 0; i--) {
+          const d = new Date(now.getFullYear(), now.getMonth() - i, 1);
+          const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+          monthMap.set(key, 0);
+        }
+        for (const payment of payments) {
+          const d = new Date(payment.createdAt);
+          const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+          if (monthMap.has(key)) {
+            monthMap.set(key, (monthMap.get(key) ?? 0) + payment.amount);
+          }
+        }
+        return Array.from(monthMap.entries()).map(([month, revenue]) => ({
+          month,
+          revenue
+        }));
+      }
+      async getRecentPayments() {
+        const payments = await this.paymentModel.find();
+        return payments.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, 10).map((p) => ({
+          id: p.id,
+          amount: p.amount,
+          currency: p.currency,
+          status: p.status,
+          customerEmail: p.customerId,
+          createdAt: p.createdAt.toISOString()
+        }));
+      }
+    };
+    StripeMetricsService = _ts_decorate12([
+      Injectable(),
+      _ts_param5(0, InjectModel(StripePayment)),
+      _ts_param5(1, InjectModel(StripeSubscription)),
+      _ts_metadata12("design:type", Function),
+      _ts_metadata12("design:paramtypes", [
+        typeof Model === "undefined" ? Object : Model,
+        typeof Model === "undefined" ? Object : Model,
+        typeof StripeService === "undefined" ? Object : StripeService
+      ])
+    ], StripeMetricsService);
+  }
+});
+function _ts_decorate13(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata13(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+var StripePortalService;
+var init_portal_service = __esm({
+  "src/services/portal.service.ts"() {
+    init_stripe_service();
+    init_customer_service();
+    __name(_ts_decorate13, "_ts_decorate");
+    __name(_ts_metadata13, "_ts_metadata");
+    StripePortalService = class {
+      static {
+        __name(this, "StripePortalService");
+      }
+      stripeService;
+      customerService;
+      constructor(stripeService, customerService) {
+        this.stripeService = stripeService;
+        this.customerService = customerService;
+      }
+      /**
+      * Create a Stripe Customer Portal session.
+      */
+      async createPortalSession(dto) {
+        let customerId = dto.customerId;
+        if (!customerId && dto.userId) {
+          const customer = await this.customerService.findByUserId(dto.userId);
+          if (!customer) {
+            throw new HttpException("No Stripe customer found for this user", HttpStatus.NOT_FOUND);
+          }
+          customerId = customer.stripeCustomerId;
+        }
+        if (!customerId) {
+          throw new HttpException("Either customerId or userId must be provided", HttpStatus.BAD_REQUEST);
+        }
+        const session = await this.stripeService.client.billingPortal.sessions.create({
+          customer: customerId,
+          return_url: dto.returnUrl
+        });
+        return {
+          sessionId: session.id,
+          url: session.url
+        };
+      }
+    };
+    StripePortalService = _ts_decorate13([
+      Injectable(),
+      _ts_metadata13("design:type", Function),
+      _ts_metadata13("design:paramtypes", [
+        typeof StripeService === "undefined" ? Object : StripeService,
+        typeof StripeCustomerService === "undefined" ? Object : StripeCustomerService
+      ])
+    ], StripePortalService);
+  }
+});
+function _ts_decorate14(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata14(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeProductService;
+var init_product_service = __esm({
+  "src/services/product.service.ts"() {
+    init_price_schema();
+    init_product_schema();
+    __name(_ts_decorate14, "_ts_decorate");
+    __name(_ts_metadata14, "_ts_metadata");
+    __name(_ts_param6, "_ts_param");
+    StripeProductService = class {
+      static {
+        __name(this, "StripeProductService");
+      }
+      productModel;
+      priceModel;
+      constructor(productModel, priceModel) {
+        this.productModel = productModel;
+        this.priceModel = priceModel;
+      }
+      /**
+      * Upsert a product from a Stripe Product object.
+      */
+      async syncProduct(stripeProduct) {
+        const data = {
+          stripeProductId: stripeProduct.id,
+          name: stripeProduct.name,
+          description: stripeProduct.description ?? void 0,
+          active: stripeProduct.active,
+          metadata: stripeProduct.metadata,
+          images: stripeProduct.images,
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        const existing = await this.productModel.findOne({
+          stripeProductId: stripeProduct.id
+        });
+        if (existing) {
+          return this.productModel.update({
+            stripeProductId: stripeProduct.id
+          }, data);
+        }
+        return this.productModel.create(data);
+      }
+      /**
+      * Upsert a price from a Stripe Price object.
+      */
+      async syncPrice(stripePrice) {
+        const productId = typeof stripePrice.product === "string" ? stripePrice.product : stripePrice.product.id;
+        const data = {
+          stripePriceId: stripePrice.id,
+          productId,
+          unitAmount: stripePrice.unit_amount ?? 0,
+          currency: stripePrice.currency,
+          type: stripePrice.type,
+          interval: stripePrice.recurring?.interval,
+          intervalCount: stripePrice.recurring?.interval_count,
+          active: stripePrice.active
+        };
+        const existing = await this.priceModel.findOne({
+          stripePriceId: stripePrice.id
+        });
+        if (existing) {
+          return this.priceModel.update({
+            stripePriceId: stripePrice.id
+          }, data);
+        }
+        return this.priceModel.create(data);
+      }
+      /**
+      * Delete a product by Stripe Product ID.
+      */
+      async deleteProduct(stripeProductId) {
+        await this.productModel.delete({
+          stripeProductId
+        });
+      }
+      /**
+      * Delete a price by Stripe Price ID.
+      */
+      async deletePrice(stripePriceId) {
+        await this.priceModel.delete({
+          stripePriceId
+        });
+      }
+      /**
+      * List all active products with their prices.
+      */
+      async findActiveProductsWithPrices() {
+        const products = await this.productModel.findMany({
+          active: true
+        });
+        const result = [];
+        for (const product of products) {
+          const prices = await this.priceModel.findMany({
+            productId: product.stripeProductId,
+            active: true
+          });
+          result.push({
+            product,
+            prices
+          });
+        }
+        return result;
+      }
+      /**
+      * List all products.
+      */
+      async findAllProducts() {
+        return this.productModel.find();
+      }
+      /**
+      * List all prices.
+      */
+      async findAllPrices() {
+        return this.priceModel.find();
+      }
+    };
+    StripeProductService = _ts_decorate14([
+      Injectable(),
+      _ts_param6(0, InjectModel(StripeProduct)),
+      _ts_param6(1, InjectModel(StripePrice)),
+      _ts_metadata14("design:type", Function),
+      _ts_metadata14("design:paramtypes", [
+        typeof Model === "undefined" ? Object : Model,
+        typeof Model === "undefined" ? Object : Model
+      ])
+    ], StripeProductService);
+  }
+});
+function _ts_decorate15(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata15(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeApiController;
+var init_stripe_api_controller = __esm({
+  "src/stripe-api.controller.ts"() {
+    init_payment_schema();
+    init_access_service();
+    init_checkout_service();
+    init_customer_service();
+    init_metrics_service();
+    init_portal_service();
+    init_product_service();
+    init_subscription_service();
+    init_stripe_service();
+    __name(_ts_decorate15, "_ts_decorate");
+    __name(_ts_metadata15, "_ts_metadata");
+    __name(_ts_param7, "_ts_param");
+    StripeApiController = class {
+      static {
+        __name(this, "StripeApiController");
+      }
+      accessService;
+      checkoutService;
+      customerService;
+      metricsService;
+      paymentModel;
+      portalService;
+      productService;
+      stripeService;
+      subscriptionService;
+      constructor(accessService, checkoutService, customerService, metricsService, paymentModel, portalService, productService, stripeService, subscriptionService) {
+        this.accessService = accessService;
+        this.checkoutService = checkoutService;
+        this.customerService = customerService;
+        this.metricsService = metricsService;
+        this.paymentModel = paymentModel;
+        this.portalService = portalService;
+        this.productService = productService;
+        this.stripeService = stripeService;
+        this.subscriptionService = subscriptionService;
+      }
+      /**
+      * Create a Stripe Checkout session.
+      * POST /stripe/checkout
+      */
+      async createCheckout(dto) {
+        try {
+          return await this.checkoutService.createCheckoutSession(dto);
+        } catch (error) {
+          if (error instanceof HttpException) throw error;
+          throw new HttpException(error instanceof Error ? error.message : "Failed to create checkout session", HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+      }
+      /**
+      * Create a Stripe Customer Portal session.
+      * POST /stripe/portal
+      */
+      async createPortal(dto) {
+        try {
+          return await this.portalService.createPortalSession(dto);
+        } catch (error) {
+          if (error instanceof HttpException) throw error;
+          throw new HttpException(error instanceof Error ? error.message : "Failed to create portal session", HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+      }
+      /**
+      * List active products with their prices.
+      * GET /stripe/products
+      */
+      async listProducts() {
+        return this.productService.findActiveProductsWithPrices();
+      }
+      /**
+      * Get a user's active subscription.
+      * GET /stripe/subscription/:userId
+      */
+      async getUserSubscription(userId) {
+        const customer = await this.customerService.findByUserId(userId);
+        if (!customer) {
+          return {
+            subscription: null
+          };
+        }
+        const subscription = await this.subscriptionService.findActiveByCustomerId(customer.stripeCustomerId);
+        return {
+          subscription
+        };
+      }
+      /**
+      * Get subscription access info and feature flags for a user.
+      * GET /stripe/access/:userId
+      */
+      async getAccess(userId) {
+        return this.accessService.getAccess(userId);
+      }
+      // =========================================================================
+      // Admin Endpoints
+      // =========================================================================
+      /**
+      * Get dashboard metrics (MRR, revenue, subscriptions).
+      * GET /stripe/admin/metrics
+      */
+      async getMetrics() {
+        return this.metricsService.getMetrics();
+      }
+      /**
+      * List all customers (admin).
+      * GET /stripe/admin/customers
+      */
+      async listCustomers() {
+        return this.customerService.findAll();
+      }
+      /**
+      * List all subscriptions (admin).
+      * GET /stripe/admin/subscriptions
+      */
+      async listSubscriptions() {
+        return this.subscriptionService.findAll();
+      }
+      /**
+      * Cancel a subscription (admin).
+      * POST /stripe/admin/subscriptions/:id/cancel
+      */
+      async cancelSubscription(stripeSubscriptionId) {
+        await this.subscriptionService.cancel(stripeSubscriptionId);
+        return {
+          canceled: true
+        };
+      }
+      /**
+      * List all products (admin).
+      * GET /stripe/admin/products
+      */
+      async listAllProducts() {
+        return this.productService.findAllProducts();
+      }
+      /**
+      * Sync products and prices from Stripe (admin).
+      * POST /stripe/admin/sync-products
+      */
+      async syncProducts() {
+        let productCount = 0;
+        for await (const product of this.stripeService.client.products.list({
+          active: true
+        })) {
+          await this.productService.syncProduct(product);
+          productCount++;
+        }
+        let priceCount = 0;
+        for await (const price of this.stripeService.client.prices.list({
+          active: true
+        })) {
+          await this.productService.syncPrice(price);
+          priceCount++;
+        }
+        return {
+          synced: true,
+          products: productCount,
+          prices: priceCount
+        };
+      }
+      /**
+      * List all payments (admin).
+      * GET /stripe/admin/payments
+      */
+      async listPayments() {
+        return this.paymentModel.find();
+      }
+      /**
+      * Refund a payment (admin).
+      * POST /stripe/admin/payments/:id/refund
+      */
+      async refundPayment(paymentIntentId) {
+        try {
+          await this.stripeService.client.refunds.create({
+            payment_intent: paymentIntentId
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Refund failed";
+          throw new HttpException(message, HttpStatus.BAD_REQUEST);
+        }
+        await this.paymentModel.update({
+          stripePaymentIntentId: paymentIntentId
+        }, {
+          status: "refunded"
+        });
+        return {
+          refunded: true
+        };
+      }
+    };
+    _ts_decorate15([
+      Post("checkout"),
+      _ts_param7(0, Body()),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", [
+        typeof CreateCheckoutDto === "undefined" ? Object : CreateCheckoutDto
+      ]),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "createCheckout", null);
+    _ts_decorate15([
+      Post("portal"),
+      _ts_param7(0, Body()),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", [
+        typeof CreatePortalDto === "undefined" ? Object : CreatePortalDto
+      ]),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "createPortal", null);
+    _ts_decorate15([
+      Get("products"),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", []),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "listProducts", null);
+    _ts_decorate15([
+      Get("subscription/:userId"),
+      _ts_param7(0, Param("userId")),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", [
+        String
+      ]),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "getUserSubscription", null);
+    _ts_decorate15([
+      Get("access/:userId"),
+      RestrictedRoute(),
+      _ts_param7(0, Param("userId")),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", [
+        String
+      ]),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "getAccess", null);
+    _ts_decorate15([
+      Get("admin/metrics"),
+      RestrictedRoute(),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", []),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "getMetrics", null);
+    _ts_decorate15([
+      Get("admin/customers"),
+      RestrictedRoute(),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", []),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "listCustomers", null);
+    _ts_decorate15([
+      Get("admin/subscriptions"),
+      RestrictedRoute(),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", []),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "listSubscriptions", null);
+    _ts_decorate15([
+      Post("admin/subscriptions/:id/cancel"),
+      RestrictedRoute(),
+      _ts_param7(0, Param("id")),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", [
+        String
+      ]),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "cancelSubscription", null);
+    _ts_decorate15([
+      Get("admin/products"),
+      RestrictedRoute(),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", []),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "listAllProducts", null);
+    _ts_decorate15([
+      Post("admin/sync-products"),
+      RestrictedRoute(),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", []),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "syncProducts", null);
+    _ts_decorate15([
+      Get("admin/payments"),
+      RestrictedRoute(),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", []),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "listPayments", null);
+    _ts_decorate15([
+      Post("admin/payments/:id/refund"),
+      RestrictedRoute(),
+      _ts_param7(0, Param("id")),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", [
+        String
+      ]),
+      _ts_metadata15("design:returntype", Promise)
+    ], StripeApiController.prototype, "refundPayment", null);
+    StripeApiController = _ts_decorate15([
+      Controller("stripe"),
+      _ts_param7(4, InjectModel(StripePayment)),
+      _ts_metadata15("design:type", Function),
+      _ts_metadata15("design:paramtypes", [
+        typeof StripeAccessService === "undefined" ? Object : StripeAccessService,
+        typeof StripeCheckoutService === "undefined" ? Object : StripeCheckoutService,
+        typeof StripeCustomerService === "undefined" ? Object : StripeCustomerService,
+        typeof StripeMetricsService === "undefined" ? Object : StripeMetricsService,
+        typeof Model === "undefined" ? Object : Model,
+        typeof StripePortalService === "undefined" ? Object : StripePortalService,
+        typeof StripeProductService === "undefined" ? Object : StripeProductService,
+        typeof StripeService === "undefined" ? Object : StripeService,
+        typeof StripeSubscriptionService === "undefined" ? Object : StripeSubscriptionService
+      ])
+    ], StripeApiController);
+  }
+});
+function _ts_decorate16(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata16(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeWebhookService;
+var init_stripe_webhook_service = __esm({
+  "src/stripe-webhook.service.ts"() {
+    init_payment_schema();
+    init_processed_event_schema();
+    init_customer_service();
+    init_product_service();
+    init_subscription_service();
+    __name(_ts_decorate16, "_ts_decorate");
+    __name(_ts_metadata16, "_ts_metadata");
+    __name(_ts_param8, "_ts_param");
+    StripeWebhookService = class _StripeWebhookService {
+      static {
+        __name(this, "StripeWebhookService");
+      }
+      processedEventModel;
+      paymentModel;
+      customerService;
+      productService;
+      subscriptionService;
+      emailService;
+      logger;
+      constructor(processedEventModel, paymentModel, customerService, productService, subscriptionService, emailService) {
+        this.processedEventModel = processedEventModel;
+        this.paymentModel = paymentModel;
+        this.customerService = customerService;
+        this.productService = productService;
+        this.subscriptionService = subscriptionService;
+        this.emailService = emailService;
+        this.logger = new Logger(_StripeWebhookService.name);
+      }
+      /**
+      * Process a verified Stripe event with idempotency.
+      * Returns silently if the event was already processed.
+      */
+      async processEvent(event) {
+        const existing = await this.findProcessedEvent(event.id);
+        if (existing) {
+          this.logger.log(`Event ${event.id} already processed, skipping`);
+          return;
+        }
+        try {
+          await this.dispatchEvent(event);
+          await this.recordProcessedEvent(event.id, event.type);
+        } catch (error) {
+          this.logger.error(`Failed to process event ${event.id} (${event.type}): ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      /**
+      * Dispatch event to the appropriate handler.
+      */
+      async dispatchEvent(event) {
+        switch (event.type) {
+          case "checkout.session.completed":
+            await this.handleCheckoutCompleted(event.data.object);
+            break;
+          case "customer.created":
+          case "customer.updated":
+            await this.customerService.upsertFromStripe(event.data.object);
+            break;
+          case "customer.deleted":
+            await this.customerService.deleteByStripeId(event.data.object.id);
+            break;
+          case "customer.subscription.created":
+          case "customer.subscription.updated":
+            await this.subscriptionService.syncSubscription(event.data.object);
+            break;
+          case "customer.subscription.deleted":
+            await this.subscriptionService.deleteByStripeId(event.data.object.id);
+            break;
+          case "invoice.paid":
+            await this.handleInvoicePaid(event.data.object);
+            break;
+          case "invoice.payment_failed":
+            await this.handleInvoicePaymentFailed(event.data.object);
+            break;
+          case "product.created":
+          case "product.updated":
+            await this.productService.syncProduct(event.data.object);
+            break;
+          case "product.deleted":
+            await this.productService.deleteProduct(event.data.object.id);
+            break;
+          case "price.created":
+          case "price.updated":
+            await this.productService.syncPrice(event.data.object);
+            break;
+          case "price.deleted":
+            await this.productService.deletePrice(event.data.object.id);
+            break;
+          default:
+            this.logger.log(`Unhandled event type: ${event.type}`);
+        }
+      }
+      // =========================================================================
+      // Event Handlers — complex events that touch multiple services
+      // =========================================================================
+      async handleCheckoutCompleted(session) {
+        this.logger.log(`checkout.session.completed: ${session.id}`);
+        if (session.customer) {
+          const customerId = typeof session.customer === "string" ? session.customer : session.customer.id;
+          this.logger.log(`Checkout customer: ${customerId}`);
+        }
+        if (session.payment_intent && session.amount_total !== null) {
+          const paymentIntentId = typeof session.payment_intent === "string" ? session.payment_intent : session.payment_intent.id;
+          const customerId = typeof session.customer === "string" ? session.customer : session.customer?.id ?? "";
+          await this.paymentModel.create({
+            stripePaymentIntentId: paymentIntentId,
+            customerId,
+            amount: session.amount_total,
+            currency: session.currency ?? "usd",
+            status: "succeeded",
+            createdAt: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      async handleInvoicePaid(invoice) {
+        this.logger.log(`invoice.paid: ${invoice.id}`);
+        const customerId = typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id ?? "";
+        if (invoice.payment_intent) {
+          const paymentIntentId = typeof invoice.payment_intent === "string" ? invoice.payment_intent : invoice.payment_intent.id;
+          const existing = await this.paymentModel.findOne({
+            stripePaymentIntentId: paymentIntentId
+          });
+          if (!existing) {
+            await this.paymentModel.create({
+              stripePaymentIntentId: paymentIntentId,
+              customerId,
+              amount: invoice.amount_paid,
+              currency: invoice.currency,
+              status: "succeeded",
+              receiptUrl: invoice.hosted_invoice_url ?? void 0,
+              invoiceId: invoice.id ?? void 0,
+              createdAt: /* @__PURE__ */ new Date()
+            });
+          }
+        }
+        await this.sendReceiptEmail(invoice);
+      }
+      async handleInvoicePaymentFailed(invoice) {
+        this.logger.log(`invoice.payment_failed: ${invoice.id}`);
+        const customerId = typeof invoice.customer === "string" ? invoice.customer : invoice.customer?.id ?? "";
+        if (invoice.payment_intent) {
+          const paymentIntentId = typeof invoice.payment_intent === "string" ? invoice.payment_intent : invoice.payment_intent.id;
+          const existing = await this.paymentModel.findOne({
+            stripePaymentIntentId: paymentIntentId
+          });
+          if (!existing) {
+            await this.paymentModel.create({
+              stripePaymentIntentId: paymentIntentId,
+              customerId,
+              amount: invoice.amount_due,
+              currency: invoice.currency,
+              status: "failed",
+              invoiceId: invoice.id ?? void 0,
+              createdAt: /* @__PURE__ */ new Date()
+            });
+          }
+        }
+        await this.sendPaymentFailedEmail(invoice);
+      }
+      // =========================================================================
+      // Email Helpers
+      // =========================================================================
+      async sendReceiptEmail(invoice) {
+        if (!this.emailService) return;
+        const email = typeof invoice.customer_email === "string" ? invoice.customer_email : null;
+        if (!email) return;
+        try {
+          await this.emailService.send(email, "Payment Receipt", "stripe-receipt", {
+            amount: (invoice.amount_paid / 100).toFixed(2),
+            currency: invoice.currency.toUpperCase(),
+            invoiceUrl: invoice.hosted_invoice_url ?? "",
+            date: (/* @__PURE__ */ new Date()).toLocaleDateString()
+          });
+        } catch (error) {
+          this.logger.warn(`Failed to send receipt email: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      async sendPaymentFailedEmail(invoice) {
+        if (!this.emailService) return;
+        const email = typeof invoice.customer_email === "string" ? invoice.customer_email : null;
+        if (!email) return;
+        try {
+          await this.emailService.send(email, "Payment Failed", "stripe-payment-failed", {
+            amount: (invoice.amount_due / 100).toFixed(2),
+            currency: invoice.currency.toUpperCase(),
+            invoiceUrl: invoice.hosted_invoice_url ?? "",
+            date: (/* @__PURE__ */ new Date()).toLocaleDateString()
+          });
+        } catch (error) {
+          this.logger.warn(`Failed to send payment failed email: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      // =========================================================================
+      // Idempotency Helpers
+      // =========================================================================
+      async findProcessedEvent(eventId) {
+        const result = await this.processedEventModel.findOne({
+          stripeEventId: eventId
+        });
+        return result !== null;
+      }
+      async recordProcessedEvent(eventId, eventType) {
+        try {
+          await this.processedEventModel.create({
+            stripeEventId: eventId,
+            eventType,
+            processedAt: /* @__PURE__ */ new Date()
+          });
+        } catch (error) {
+          this.logger.warn(`Failed to record processed event ${eventId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    };
+    StripeWebhookService = _ts_decorate16([
+      Injectable(),
+      _ts_param8(0, InjectModel(StripeProcessedEvent)),
+      _ts_param8(1, InjectModel(StripePayment)),
+      _ts_param8(5, Optional()),
+      _ts_metadata16("design:type", Function),
+      _ts_metadata16("design:paramtypes", [
+        typeof Model === "undefined" ? Object : Model,
+        typeof Model === "undefined" ? Object : Model,
+        typeof StripeCustomerService === "undefined" ? Object : StripeCustomerService,
+        typeof StripeProductService === "undefined" ? Object : StripeProductService,
+        typeof StripeSubscriptionService === "undefined" ? Object : StripeSubscriptionService,
+        typeof EmailService === "undefined" ? Object : EmailService
+      ])
+    ], StripeWebhookService);
+  }
+});
+function _ts_decorate17(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata17(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+function _ts_param9(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+var StripeWebhookController;
+var init_stripe_webhook_controller = __esm({
+  "src/stripe-webhook.controller.ts"() {
+    init_stripe_webhook_service();
+    init_stripe_service();
+    __name(_ts_decorate17, "_ts_decorate");
+    __name(_ts_metadata17, "_ts_metadata");
+    __name(_ts_param9, "_ts_param");
+    StripeWebhookController = class {
+      static {
+        __name(this, "StripeWebhookController");
+      }
+      stripeService;
+      webhookService;
+      constructor(stripeService, webhookService) {
+        this.stripeService = stripeService;
+        this.webhookService = webhookService;
+      }
+      async handleWebhook(req, signature) {
+        this.stripeService.verifyRawBodyAvailable(req);
+        const { webhookSecret } = this.stripeService.pluginConfig;
+        if (!webhookSecret) {
+          throw new Error("[StripePlugin] webhookSecret is required for webhook verification");
+        }
+        const event = this.stripeService.client.webhooks.constructEvent(req.rawBody, signature, webhookSecret);
+        await this.webhookService.processEvent(event);
+        return {
+          received: true
+        };
+      }
+    };
+    _ts_decorate17([
+      Post(),
+      HttpCode(200),
+      _ts_param9(0, Req()),
+      _ts_param9(1, Headers("stripe-signature")),
+      _ts_metadata17("design:type", Function),
+      _ts_metadata17("design:paramtypes", [
+        Object,
+        String
+      ]),
+      _ts_metadata17("design:returntype", Promise)
+    ], StripeWebhookController.prototype, "handleWebhook", null);
+    StripeWebhookController = _ts_decorate17([
+      Controller("stripe/webhooks"),
+      _ts_metadata17("design:type", Function),
+      _ts_metadata17("design:paramtypes", [
+        typeof StripeService === "undefined" ? Object : StripeService,
+        typeof StripeWebhookService === "undefined" ? Object : StripeWebhookService
+      ])
+    ], StripeWebhookController);
+  }
+});
+
+// src/stripe.module.ts
+var stripe_module_exports = {};
+__export(stripe_module_exports, {
+  StripeModule: () => StripeModule
+});
+function _ts_decorate18(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var StripeModule;
+var init_stripe_module = __esm({
+  "src/stripe.module.ts"() {
+    init_customer_schema();
+    init_payment_schema();
+    init_price_schema();
+    init_processed_event_schema();
+    init_product_schema();
+    init_subscription_schema();
+    init_access_service();
+    init_checkout_service();
+    init_customer_service();
+    init_metrics_service();
+    init_portal_service();
+    init_product_service();
+    init_subscription_service();
+    init_stripe_api_controller();
+    init_stripe_webhook_controller();
+    init_stripe_webhook_service();
+    init_stripe_service();
+    __name(_ts_decorate18, "_ts_decorate");
+    StripeModule = class {
+      static {
+        __name(this, "StripeModule");
+      }
+    };
+    StripeModule = _ts_decorate18([
+      Module({
+        imports: [
+          DatabaseModule.forFeature(StripeCustomer),
+          DatabaseModule.forFeature(StripeProduct),
+          DatabaseModule.forFeature(StripePrice),
+          DatabaseModule.forFeature(StripeSubscription),
+          DatabaseModule.forFeature(StripePayment),
+          DatabaseModule.forFeature(StripeProcessedEvent)
+        ],
+        controllers: [
+          StripeApiController,
+          StripeWebhookController
+        ],
+        providers: [
+          StripeService,
+          StripeWebhookService,
+          StripeCustomerService,
+          StripeProductService,
+          StripeSubscriptionService,
+          StripeCheckoutService,
+          StripePortalService,
+          StripeAccessService,
+          StripeMetricsService
+        ],
+        exports: [
+          StripeService,
+          StripeCustomerService,
+          StripeProductService,
+          StripeSubscriptionService,
+          StripeCheckoutService,
+          StripePortalService,
+          StripeAccessService
+        ]
+      })
+    ], StripeModule);
+  }
+});
+function _ts_decorate19(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") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate19, "_ts_decorate");
+var StripePlugin = class _StripePlugin {
+  static {
+    __name(this, "StripePlugin");
+  }
+  /** Environment variables used by this plugin */
+  static envVars = [
+    {
+      name: "STRIPE_SECRET_KEY",
+      required: true,
+      description: "Stripe API secret key"
+    },
+    {
+      name: "STRIPE_WEBHOOK_SECRET",
+      required: true,
+      description: "Stripe webhook signing secret"
+    },
+    {
+      name: "STRIPE_PUBLISHABLE_KEY",
+      required: false,
+      description: "Stripe publishable key"
+    }
+  ];
+  /**
+  * Create a configured plugin provider for MagnetModule.forRoot().
+  * Auto-resolves secret values from environment variables if not provided.
+  *
+  * @example
+  * ```typescript
+  * MagnetModule.forRoot([
+  *   StripePlugin.forRoot({ currency: 'usd' }),
+  * ])
+  * ```
+  */
+  static forRoot(config) {
+    const resolvedConfig = {
+      secretKey: config?.secretKey ?? process.env.STRIPE_SECRET_KEY,
+      webhookSecret: config?.webhookSecret ?? process.env.STRIPE_WEBHOOK_SECRET,
+      publishableKey: config?.publishableKey ?? process.env.STRIPE_PUBLISHABLE_KEY,
+      syncProducts: config?.syncProducts,
+      portalEnabled: config?.portalEnabled,
+      currency: config?.currency,
+      features: config?.features
+    };
+    return {
+      type: "plugin",
+      plugin: _StripePlugin,
+      options: resolvedConfig,
+      envVars: _StripePlugin.envVars
+    };
+  }
+};
+StripePlugin = _ts_decorate19([
+  Plugin({
+    name: "stripe",
+    description: "Stripe payments plugin for Magnet CMS",
+    version: "0.1.0",
+    module: /* @__PURE__ */ __name(() => (init_stripe_module(), __toCommonJS(stripe_module_exports)).StripeModule, "module"),
+    frontend: {
+      routes: [
+        {
+          path: "stripe",
+          componentId: "StripeDashboard",
+          requiresAuth: true,
+          children: [
+            {
+              path: "",
+              componentId: "StripeDashboard"
+            },
+            {
+              path: "customers",
+              componentId: "StripeCustomers"
+            },
+            {
+              path: "products",
+              componentId: "StripeProducts"
+            },
+            {
+              path: "subscriptions",
+              componentId: "StripeSubscriptions"
+            },
+            {
+              path: "payments",
+              componentId: "StripePayments"
+            }
+          ]
+        }
+      ],
+      sidebar: [
+        {
+          id: "stripe",
+          title: "Stripe Payments",
+          url: "/stripe",
+          icon: "CreditCard",
+          order: 30,
+          items: [
+            {
+              id: "stripe-dashboard",
+              title: "Dashboard",
+              url: "/stripe",
+              icon: "BarChart3"
+            },
+            {
+              id: "stripe-customers",
+              title: "Customers",
+              url: "/stripe/customers",
+              icon: "Users"
+            },
+            {
+              id: "stripe-products",
+              title: "Products",
+              url: "/stripe/products",
+              icon: "Package"
+            },
+            {
+              id: "stripe-subscriptions",
+              title: "Subscriptions",
+              url: "/stripe/subscriptions",
+              icon: "RefreshCw"
+            },
+            {
+              id: "stripe-payments",
+              title: "Payments",
+              url: "/stripe/payments",
+              icon: "Receipt"
+            }
+          ]
+        }
+      ]
+    }
+  })
+], StripePlugin);
+
+export { StripeAccessService, StripeCheckoutService, StripeCustomer, StripeCustomerService, StripeMetricsService, StripeModule, StripePayment, StripePlugin, StripePortalService, StripePrice, StripeProcessedEvent, StripeProduct, StripeProductService, StripeService, StripeSubscription, StripeSubscriptionService, init_access_service, init_checkout_service, init_customer_schema, init_customer_service, init_metrics_service, init_payment_schema, init_portal_service, init_price_schema, init_processed_event_schema, init_product_schema, init_product_service, init_stripe_module, init_stripe_service, init_subscription_schema, init_subscription_service };