@reeboot/strapi-payment-plugin 0.0.9 → 0.0.10

package/dist/server/index.js

@@ -13,7 +13,7 @@ const config = {
   validator() {
   }
 };
-const schema$2 = {
+const schema$3 = {
   kind: "collectionType",
   collectionName: "customers",
   info: {
@@ -76,11 +76,17 @@ const schema$2 = {
       relation: "oneToMany",
       target: "plugin::payment-plugin.payment",
       mappedBy: "customer"
+    },
+    subscriptions: {
+      type: "relation",
+      relation: "oneToMany",
+      target: "plugin::payment-plugin.subscription",
+      mappedBy: "customer"
     }
   }
 };
-const customer = { schema: schema$2 };
-const schema$1 = {
+const customer = { schema: schema$3 };
+const schema$2 = {
   kind: "collectionType",
   collectionName: "orders",
   info: {
@@ -165,8 +171,8 @@ const schema$1 = {
     }
   }
 };
-const order = { schema: schema$1 };
-const schema = {
+const order = { schema: schema$2 };
+const schema$1 = {
   kind: "collectionType",
   collectionName: "payments",
   info: {
@@ -238,17 +244,115 @@ const schema = {
     }
   }
 };
-const payment = { schema };
+const payment = { schema: schema$1 };
+const kind = "collectionType";
+const collectionName = "payment_plugin_subscriptions";
+const info = {
+  singularName: "subscription",
+  pluralName: "subscriptions",
+  displayName: "Subscription",
+  description: "Stripe subscription records for recurring billing"
+};
+const options = {
+  draftAndPublish: false
+};
+const attributes = {
+  stripe_subscription_id: {
+    type: "string",
+    unique: true,
+    required: true,
+    configurable: false
+  },
+  stripe_customer_id: {
+    type: "string",
+    required: true,
+    configurable: false
+  },
+  stripe_price_id: {
+    type: "string",
+    required: true,
+    configurable: false
+  },
+  stripe_product_id: {
+    type: "string",
+    configurable: false
+  },
+  status: {
+    type: "enumeration",
+    "enum": [
+      "active",
+      "canceled",
+      "incomplete",
+      "incomplete_expired",
+      "past_due",
+      "paused",
+      "trialing",
+      "unpaid"
+    ],
+    required: true,
+    "default": "incomplete",
+    configurable: false
+  },
+  current_period_start: {
+    type: "datetime",
+    configurable: false
+  },
+  current_period_end: {
+    type: "datetime",
+    configurable: false
+  },
+  cancel_at_period_end: {
+    type: "boolean",
+    "default": false,
+    configurable: false
+  },
+  canceled_at: {
+    type: "datetime",
+    configurable: false
+  },
+  trial_start: {
+    type: "datetime",
+    configurable: false
+  },
+  trial_end: {
+    type: "datetime",
+    configurable: false
+  },
+  latest_invoice_id: {
+    type: "string",
+    configurable: false
+  },
+  metadata: {
+    type: "json",
+    configurable: false
+  },
+  customer: {
+    type: "relation",
+    relation: "manyToOne",
+    target: "plugin::payment-plugin.customer",
+    inversedBy: "subscriptions"
+  }
+};
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  attributes
+};
+const subscription = { schema };
 const contentTypes = {
   customer,
   order,
-  payment
+  payment,
+  subscription
 };
 const controller = ({ strapi: strapi2 }) => ({
   index(ctx) {
     ctx.body = strapi2.plugin("payment-plugin").service("service").getWelcomeMessage();
   }
 });
+const getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
 const stripeController = {
   /**
    * Create a payment intent
@@ -419,12 +523,13 @@ const stripeController = {
       await stripeService2.handleWebhook(event);
       ctx.body = { received: true };
     } catch (error) {
-      if (error.message.includes("No signatures found matching") || error.message.includes("Webhook payload must be provided as a string or a Buffer")) {
+      const message = getErrorMessage(error);
+      if (message.includes("No signatures found matching") || message.includes("Webhook payload must be provided as a string or a Buffer")) {
         strapi.log.error('Stripe Webhook Error: Payload is not raw. Ensure "includeUnparsed: true" is set in config/middlewares.ts for "strapi::body".');
         return ctx.badRequest("Webhook verification failed: Payload must be raw. Check your Strapi configuration for strapi::body middleware.");
       }
-      strapi.log.error("Failed to handle webhook", { error: error.message, stack: error.stack });
-      ctx.badRequest(`Webhook Error: ${error.message}`);
+      strapi.log.error("Failed to handle webhook", { message, stack: error instanceof Error ? error.stack : void 0 });
+      ctx.badRequest(`Webhook Error: ${message}`);
     }
   },
   /**
@@ -782,24 +887,28 @@ const stripeController = {
       const { startDate, endDate, format = "json" } = ctx.query;
       const filters = {};
       if (startDate || endDate) {
-        filters.createdAt = {};
-        if (startDate) filters.createdAt.$gte = new Date(startDate).toISOString();
-        if (endDate) filters.createdAt.$lte = new Date(endDate).toISOString();
+        const dateFilter = {};
+        if (startDate) dateFilter.$gte = new Date(startDate).toISOString();
+        if (endDate) dateFilter.$lte = new Date(endDate).toISOString();
+        filters.createdAt = dateFilter;
       }
-      const payments = await strapi.documents("plugin::payment-plugin.payment").findMany({
+      const rawPayments = await strapi.documents("plugin::payment-plugin.payment").findMany({
         filters,
         populate: ["customer", "order"],
         sort: { createdAt: "desc" }
       });
+      const payments = rawPayments;
       const summary = {
         totalPayments: payments.length,
         totalAmount: payments.reduce((sum, p) => sum + p.amount, 0),
         byStatus: payments.reduce((acc, p) => {
-          acc[p.payment_status] = (acc[p.payment_status] || 0) + 1;
+          const s = p.payment_status || "unknown";
+          acc[s] = (acc[s] || 0) + 1;
           return acc;
         }, {}),
         byCurrency: payments.reduce((acc, p) => {
-          acc[p.currency] = (acc[p.currency] || 0) + 1;
+          const c = p.currency || "unknown";
+          acc[c] = (acc[c] || 0) + 1;
           return acc;
         }, {})
       };
@@ -890,8 +999,9 @@ const stripeController = {
         fields: ["amount", "createdAt", "currency"],
         sort: { createdAt: "asc" }
       });
-      const dailyStats = payments.reduce((acc, payment2) => {
-        const date = new Date(payment2.createdAt).toISOString().split("T")[0];
+      const typedPayments = payments;
+      const dailyStats = typedPayments.reduce((acc, payment2) => {
+        const date = new Date(payment2.createdAt || "").toISOString().split("T")[0];
         if (!acc[date]) {
           acc[date] = { count: 0, amount: 0, currency: payment2.currency };
         }
@@ -899,14 +1009,15 @@ const stripeController = {
         acc[date].amount += payment2.amount;
         return acc;
       }, {});
+      const totalVolume = typedPayments.reduce((sum, p) => sum + p.amount, 0);
       ctx.body = {
         success: true,
         data: {
           period,
           dailyStats,
-          totalVolume: payments.reduce((sum, p) => sum + p.amount, 0),
-          totalTransactions: payments.length,
-          averageTransaction: payments.length > 0 ? payments.reduce((sum, p) => sum + p.amount, 0) / payments.length : 0
+          totalVolume,
+          totalTransactions: typedPayments.length,
+          averageTransaction: typedPayments.length > 0 ? totalVolume / typedPayments.length : 0
         }
       };
     } catch (error) {
@@ -968,12 +1079,11 @@ const stripeController = {
       };
     } catch (error) {
       strapi.log.error("Failed to create admin refund:", {
-        message: error.message,
-        stack: error.stack,
-        ...error.raw && { stripeError: error.raw }
+        message: getErrorMessage(error),
+        stack: error instanceof Error ? error.stack : void 0,
+        ...error instanceof Error && "raw" in error && { stripeError: error.raw }
       });
-      const errorMessage = error.message || "Failed to create admin refund";
-      ctx.internalServerError(errorMessage);
+      ctx.internalServerError(getErrorMessage(error) || "Failed to create admin refund");
     }
   },
   /**
@@ -1225,9 +1335,207 @@ const stripeController = {
     }
   }
 };
+const subscriptionController = {
+  /**
+   * POST /subscriptions
+   * Body: { stripeCustomerId, priceId, trialPeriodDays?, metadata?, defaultPaymentMethod? }
+   */
+  async createSubscription(ctx) {
+    try {
+      const { stripeCustomerId, priceId, trialPeriodDays, metadata, defaultPaymentMethod } = ctx.request.body;
+      if (!stripeCustomerId || !priceId) {
+        return ctx.badRequest("stripeCustomerId and priceId are required");
+      }
+      const stripeService2 = strapi.plugin("payment-plugin").service("stripe");
+      const customers = await strapi.documents("plugin::payment-plugin.customer").findMany({
+        filters: { stripe_customer_id: { $eq: stripeCustomerId } }
+      });
+      const strapiCustomerId = customers.length > 0 ? customers[0].documentId : void 0;
+      const subscription2 = await stripeService2.createSubscription({
+        strapiCustomerId: strapiCustomerId || "",
+        stripeCustomerId,
+        priceId,
+        trialPeriodDays,
+        metadata,
+        defaultPaymentMethod
+      });
+      const invoice = typeof subscription2.latest_invoice === "object" ? subscription2.latest_invoice : null;
+      const invoiceExt = invoice;
+      const paymentIntent = typeof invoiceExt?.payment_intent === "object" ? invoiceExt.payment_intent : null;
+      const setupIntent = typeof subscription2.pending_setup_intent === "object" ? subscription2.pending_setup_intent : null;
+      ctx.body = {
+        subscriptionId: subscription2.id,
+        status: subscription2.status,
+        clientSecret: paymentIntent?.client_secret || setupIntent?.client_secret || null,
+        currentPeriodEnd: subscription2.current_period_end
+      };
+    } catch (error) {
+      strapi.log.error("Failed to create subscription", { error: getErrorMessage(error) });
+      ctx.internalServerError(getErrorMessage(error) || "Failed to create subscription");
+    }
+  },
+  /**
+   * POST /subscriptions/:id/cancel
+   * Body: { cancelAtPeriodEnd? }
+   */
+  async cancelSubscription(ctx) {
+    try {
+      const { id } = ctx.params;
+      const { cancelAtPeriodEnd = false } = ctx.request.body || {};
+      const stripeService2 = strapi.plugin("payment-plugin").service("stripe");
+      const subscription2 = await stripeService2.cancelSubscription(id, cancelAtPeriodEnd);
+      ctx.body = {
+        subscriptionId: subscription2.id,
+        status: subscription2.status,
+        cancelAtPeriodEnd: subscription2.cancel_at_period_end,
+        canceledAt: subscription2.canceled_at
+      };
+    } catch (error) {
+      strapi.log.error("Failed to cancel subscription", { error: getErrorMessage(error) });
+      ctx.internalServerError(getErrorMessage(error) || "Failed to cancel subscription");
+    }
+  },
+  /**
+   * PUT /subscriptions/:id
+   * Body: { priceId?, cancelAtPeriodEnd?, trialEnd?, metadata?, defaultPaymentMethod? }
+   */
+  async updateSubscription(ctx) {
+    try {
+      const { id } = ctx.params;
+      const params = ctx.request.body || {};
+      const stripeService2 = strapi.plugin("payment-plugin").service("stripe");
+      const subscription2 = await stripeService2.updateSubscription(id, params);
+      ctx.body = {
+        subscriptionId: subscription2.id,
+        status: subscription2.status,
+        cancelAtPeriodEnd: subscription2.cancel_at_period_end,
+        currentPeriodEnd: subscription2.current_period_end
+      };
+    } catch (error) {
+      strapi.log.error("Failed to update subscription", { error: getErrorMessage(error) });
+      ctx.internalServerError(getErrorMessage(error) || "Failed to update subscription");
+    }
+  },
+  /**
+   * GET /subscriptions/:id
+   */
+  async getSubscriptionDetails(ctx) {
+    try {
+      const { id } = ctx.params;
+      const records = await strapi.documents("plugin::payment-plugin.subscription").findMany({
+        filters: { stripe_subscription_id: { $eq: id } },
+        populate: ["customer"]
+      });
+      if (records.length === 0) {
+        return ctx.notFound("Subscription not found");
+      }
+      const stripeService2 = strapi.plugin("payment-plugin").service("stripe");
+      const stripeSubscription = await stripeService2.retrieveSubscription(id);
+      ctx.body = {
+        strapi: records[0],
+        stripe: stripeSubscription
+      };
+    } catch (error) {
+      strapi.log.error("Failed to get subscription", { error: getErrorMessage(error) });
+      ctx.internalServerError(getErrorMessage(error) || "Failed to get subscription");
+    }
+  },
+  /**
+   * GET /subscriptions
+   * Query: page, pageSize, status, stripeCustomerId
+   */
+  async listSubscriptions(ctx) {
+    try {
+      const { page = 1, pageSize = 25, status, stripeCustomerId } = ctx.query;
+      const filters = {};
+      if (status) filters.status = { $eq: status };
+      if (stripeCustomerId) filters.stripe_customer_id = { $eq: stripeCustomerId };
+      const subscriptions = await strapi.documents("plugin::payment-plugin.subscription").findMany({
+        filters,
+        populate: ["customer"],
+        sort: { createdAt: "desc" },
+        start: (Number(page) - 1) * Number(pageSize),
+        limit: Number(pageSize)
+      });
+      const total = await strapi.documents("plugin::payment-plugin.subscription").count({ filters });
+      ctx.body = {
+        data: subscriptions,
+        meta: {
+          pagination: {
+            page: Number(page),
+            pageSize: Number(pageSize),
+            total,
+            pageCount: Math.ceil(total / Number(pageSize))
+          }
+        }
+      };
+    } catch (error) {
+      strapi.log.error("Failed to list subscriptions", { error: getErrorMessage(error) });
+      ctx.internalServerError(getErrorMessage(error) || "Failed to list subscriptions");
+    }
+  },
+  /**
+   * GET /admin/subscriptions  (admin only)
+   */
+  async adminListSubscriptions(ctx) {
+    try {
+      const { page = 1, pageSize = 25, status } = ctx.query;
+      const filters = {};
+      if (status) filters.status = { $eq: status };
+      const subscriptions = await strapi.documents("plugin::payment-plugin.subscription").findMany({
+        filters,
+        populate: ["customer"],
+        sort: { createdAt: "desc" },
+        start: (Number(page) - 1) * Number(pageSize),
+        limit: Number(pageSize)
+      });
+      const total = await strapi.documents("plugin::payment-plugin.subscription").count({ filters });
+      const enriched = subscriptions.map((s) => ({
+        ...s,
+        customerEmail: s.customer?.email || "",
+        customerName: s.customer ? `${s.customer.first_name} ${s.customer.last_name}` : ""
+      }));
+      ctx.body = {
+        data: enriched,
+        meta: {
+          pagination: {
+            page: Number(page),
+            pageSize: Number(pageSize),
+            total,
+            pageCount: Math.ceil(total / Number(pageSize))
+          }
+        }
+      };
+    } catch (error) {
+      strapi.log.error("Failed to list subscriptions (admin)", { error: getErrorMessage(error) });
+      ctx.internalServerError(getErrorMessage(error) || "Failed to list subscriptions");
+    }
+  },
+  /**
+   * POST /admin/subscriptions/:id/cancel  (admin only)
+   */
+  async adminCancelSubscription(ctx) {
+    try {
+      const { id } = ctx.params;
+      const { cancelAtPeriodEnd = false } = ctx.request.body || {};
+      const stripeService2 = strapi.plugin("payment-plugin").service("stripe");
+      const subscription2 = await stripeService2.cancelSubscription(id, cancelAtPeriodEnd);
+      ctx.body = {
+        success: true,
+        subscriptionId: subscription2.id,
+        status: subscription2.status,
+        cancelAtPeriodEnd: subscription2.cancel_at_period_end
+      };
+    } catch (error) {
+      strapi.log.error("Failed to cancel subscription (admin)", { error: getErrorMessage(error) });
+      ctx.internalServerError(getErrorMessage(error) || "Failed to cancel subscription");
+    }
+  }
+};
+const stripeControllerFull = { ...stripeController, ...subscriptionController };
 const controllers = {
   controller,
-  stripe: stripeController
+  stripe: stripeControllerFull
 };
 const middlewares = {
   /**
@@ -1426,6 +1734,37 @@ const routes$2 = {
       config: {
         policies: []
       }
+    },
+    // Subscription Operations
+    {
+      method: "POST",
+      path: "/subscriptions",
+      handler: "stripe.createSubscription",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/subscriptions",
+      handler: "stripe.listSubscriptions",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/subscriptions/:id",
+      handler: "stripe.getSubscriptionDetails",
+      config: { policies: [] }
+    },
+    {
+      method: "PUT",
+      path: "/subscriptions/:id",
+      handler: "stripe.updateSubscription",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/subscriptions/:id/cancel",
+      handler: "stripe.cancelSubscription",
+      config: { policies: [] }
     }
   ]
 };
@@ -1549,6 +1888,25 @@ const routes$1 = {
         policies: ["admin::isAuthenticatedAdmin"],
         middlewares: []
       }
+    },
+    // Admin Subscription Management
+    {
+      method: "GET",
+      path: "/admin/subscriptions",
+      handler: "stripe.adminListSubscriptions",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"],
+        middlewares: []
+      }
+    },
+    {
+      method: "POST",
+      path: "/admin/subscriptions/:id/cancel",
+      handler: "stripe.adminCancelSubscription",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"],
+        middlewares: []
+      }
     }
   ]
 };
@@ -1752,14 +2110,14 @@ const stripeService = ({ strapi: strapi2 }) => {
       return refund;
     } catch (error) {
       const logger = getLogger();
-      const errorMessage = error instanceof Error ? error.message : "Unknown Stripe error";
+      const errorMessage = getErrorMessage(error);
       logger.error("Failed to create Stripe refund", {
         message: errorMessage,
         error: error instanceof Error ? {
           message: error.message,
           stack: error.stack,
-          ...error.raw && { raw: error.raw }
-        } : error,
+          ..."raw" in error && { raw: error.raw }
+        } : String(error),
         params
       });
       throw error;
@@ -1782,8 +2140,8 @@ const stripeService = ({ strapi: strapi2 }) => {
       return stripe2.webhooks.constructEvent(verifiedPayload, signature, webhookSecret);
     } catch (error) {
       logger.error("Failed to construct webhook event", {
-        message: error.message,
-        type: error.type
+        message: getErrorMessage(error),
+        ...error instanceof Error && "type" in error && { type: error.type }
       });
       throw error;
     }
@@ -1856,10 +2214,7 @@ const stripeService = ({ strapi: strapi2 }) => {
   };
   const createOrderRecord = async (data) => {
     return strapi2.documents("plugin::payment-plugin.order").create({
-      data: {
-        ...data,
-        order_status: data.order_status || "pending"
-      }
+      data: { ...data, order_status: data.order_status || "pending" }
     });
   };
   const createStrapiPaymentRecord = async (paymentIntent) => {
@@ -1976,10 +2331,18 @@ const stripeService = ({ strapi: strapi2 }) => {
       switch (event.type) {
         case "payment_intent.succeeded":
         case "charge.succeeded": {
-          const obj = event.data.object;
-          const paymentIntentId = event.type === "payment_intent.succeeded" ? obj.id : obj.payment_intent;
+          let paymentIntentId;
+          let metadata;
+          if (event.type === "payment_intent.succeeded") {
+            const piObj = event.data.object;
+            paymentIntentId = piObj.id;
+            metadata = piObj.metadata || {};
+          } else {
+            const chargeObj = event.data.object;
+            paymentIntentId = chargeObj.payment_intent;
+            metadata = chargeObj.metadata || {};
+          }
           if (!paymentIntentId) break;
-          const metadata = obj.metadata || {};
           await updateStrapiPayment(paymentIntentId, {
             payment_status: "succeeded",
             metadata
@@ -1987,12 +2350,14 @@ const stripeService = ({ strapi: strapi2 }) => {
           const existing = await strapi2.documents("plugin::payment-plugin.payment").findMany({
             filters: { stripe_payment_intent_id: paymentIntentId }
           });
-          if (existing.length === 0 && event.type === "payment_intent.succeeded") {
-            await createStrapiPaymentRecord(obj);
-          } else if (existing.length === 0 && event.type === "charge.succeeded" && obj.payment_intent) {
-            const stripe2 = await initializeStripe();
-            const pi = await stripe2.paymentIntents.retrieve(obj.payment_intent);
-            await createStrapiPaymentRecord(pi);
+          if (existing.length === 0) {
+            if (event.type === "payment_intent.succeeded") {
+              await createStrapiPaymentRecord(event.data.object);
+            } else {
+              const stripeClient = await initializeStripe();
+              const pi = await stripeClient.paymentIntents.retrieve(paymentIntentId);
+              await createStrapiPaymentRecord(pi);
+            }
           }
           const orderId = metadata.strapi_order_id;
           if (orderId) {
@@ -2099,6 +2464,73 @@ const stripeService = ({ strapi: strapi2 }) => {
           });
           break;
         }
+        case "customer.subscription.created": {
+          const subscription2 = event.data.object;
+          const strapiCustomerId = subscription2.metadata?.strapi_customer_id;
+          const existing = await strapi2.documents("plugin::payment-plugin.subscription").findMany({
+            filters: { stripe_subscription_id: subscription2.id }
+          });
+          if (existing.length === 0) {
+            await createStrapiSubscriptionRecord(subscription2, strapiCustomerId);
+          }
+          logger.info("Subscription created via webhook", { subscriptionId: subscription2.id });
+          break;
+        }
+        case "customer.subscription.updated": {
+          const subscription2 = event.data.object;
+          const sub = subscription2;
+          const firstItem = subscription2.items.data[0];
+          await updateStrapiSubscription(subscription2.id, {
+            status: mapStripeSubscriptionStatus(subscription2.status),
+            stripe_price_id: firstItem?.price?.id,
+            stripe_product_id: firstItem?.price?.product,
+            current_period_start: toISOOrNull(sub.current_period_start),
+            current_period_end: toISOOrNull(sub.current_period_end),
+            cancel_at_period_end: subscription2.cancel_at_period_end,
+            canceled_at: toISOOrNull(subscription2.canceled_at),
+            trial_start: toISOOrNull(subscription2.trial_start),
+            trial_end: toISOOrNull(subscription2.trial_end),
+            latest_invoice_id: typeof subscription2.latest_invoice === "string" ? subscription2.latest_invoice : subscription2.latest_invoice?.id,
+            metadata: subscription2.metadata
+          });
+          logger.info("Subscription updated via webhook", { subscriptionId: subscription2.id, status: subscription2.status });
+          break;
+        }
+        case "customer.subscription.deleted": {
+          const subscription2 = event.data.object;
+          await updateStrapiSubscription(subscription2.id, {
+            status: "canceled",
+            canceled_at: toISOOrNull(subscription2.canceled_at) || (/* @__PURE__ */ new Date()).toISOString()
+          });
+          logger.info("Subscription deleted via webhook", { subscriptionId: subscription2.id });
+          break;
+        }
+        case "invoice.payment_succeeded": {
+          const invoice = event.data.object;
+          const subDetails = invoice.parent?.subscription_details;
+          const subscriptionId = typeof subDetails?.subscription === "string" ? subDetails.subscription : subDetails?.subscription?.id ?? null;
+          if (subscriptionId) {
+            await updateStrapiSubscription(subscriptionId, {
+              status: "active",
+              latest_invoice_id: invoice.id
+            });
+          }
+          logger.info("Invoice payment succeeded", { invoiceId: invoice.id, subscriptionId });
+          break;
+        }
+        case "invoice.payment_failed": {
+          const invoice = event.data.object;
+          const subDetails = invoice.parent?.subscription_details;
+          const subscriptionId = typeof subDetails?.subscription === "string" ? subDetails.subscription : subDetails?.subscription?.id ?? null;
+          if (subscriptionId) {
+            await updateStrapiSubscription(subscriptionId, {
+              status: "past_due",
+              latest_invoice_id: invoice.id
+            });
+          }
+          logger.warn("Invoice payment failed", { invoiceId: invoice.id, subscriptionId });
+          break;
+        }
         default:
           logger.info("Unhandled webhook event type", { eventType: event.type });
       }
@@ -2111,6 +2543,140 @@ const stripeService = ({ strapi: strapi2 }) => {
       throw error;
     }
   };
+  const mapStripeSubscriptionStatus = (status) => {
+    const valid = ["active", "canceled", "incomplete", "incomplete_expired", "past_due", "paused", "trialing", "unpaid"];
+    return valid.includes(status) ? status : "incomplete";
+  };
+  const toISOOrNull = (ts) => {
+    if (!ts) return null;
+    return new Date(ts * 1e3).toISOString();
+  };
+  const createStrapiSubscriptionRecord = async (subscription2, strapiCustomerId) => {
+    const logger = getLogger();
+    try {
+      const firstItem = subscription2.items.data[0];
+      const price = firstItem?.price;
+      const data = {
+        stripe_subscription_id: subscription2.id,
+        stripe_customer_id: subscription2.customer,
+        stripe_price_id: price?.id || "",
+        stripe_product_id: price?.product,
+        status: mapStripeSubscriptionStatus(subscription2.status),
+        current_period_start: toISOOrNull(subscription2.current_period_start) || void 0,
+        current_period_end: toISOOrNull(subscription2.current_period_end) || void 0,
+        cancel_at_period_end: subscription2.cancel_at_period_end,
+        canceled_at: toISOOrNull(subscription2.canceled_at) || void 0,
+        trial_start: toISOOrNull(subscription2.trial_start) || void 0,
+        trial_end: toISOOrNull(subscription2.trial_end) || void 0,
+        latest_invoice_id: typeof subscription2.latest_invoice === "string" ? subscription2.latest_invoice : subscription2.latest_invoice?.id,
+        metadata: subscription2.metadata,
+        customer: strapiCustomerId
+      };
+      const record = await strapi2.documents("plugin::payment-plugin.subscription").create({ data });
+      logger.info("Created Strapi subscription record", {
+        stripeSubscriptionId: subscription2.id,
+        strapiCustomerId
+      });
+      return record;
+    } catch (error) {
+      logger.error("Failed to create Strapi subscription record", { error, subscriptionId: subscription2.id });
+      throw error;
+    }
+  };
+  const updateStrapiSubscription = async (stripeSubscriptionId, data) => {
+    const logger = getLogger();
+    try {
+      const existing = await strapi2.documents("plugin::payment-plugin.subscription").findMany({
+        filters: { stripe_subscription_id: stripeSubscriptionId }
+      });
+      if (existing.length > 0) {
+        await strapi2.documents("plugin::payment-plugin.subscription").update({
+          documentId: existing[0].documentId,
+          data
+        });
+      }
+    } catch (error) {
+      logger.error("Failed to update Strapi subscription record", { error, stripeSubscriptionId });
+    }
+  };
+  const createSubscription = async (params) => {
+    const stripe2 = await initializeStripe();
+    const { strapiCustomerId, stripeCustomerId, priceId, trialPeriodDays, metadata = {}, defaultPaymentMethod } = params;
+    const subscriptionParams = {
+      customer: stripeCustomerId,
+      items: [{ price: priceId }],
+      payment_behavior: "default_incomplete",
+      payment_settings: { save_default_payment_method: "on_subscription" },
+      expand: ["latest_invoice.payment_intent", "pending_setup_intent"],
+      metadata: { ...metadata, strapi_customer_id: strapiCustomerId }
+    };
+    if (trialPeriodDays) {
+      subscriptionParams.trial_period_days = trialPeriodDays;
+    }
+    if (defaultPaymentMethod) {
+      subscriptionParams.default_payment_method = defaultPaymentMethod;
+    }
+    const subscription2 = await stripe2.subscriptions.create(subscriptionParams);
+    await createStrapiSubscriptionRecord(subscription2, strapiCustomerId);
+    getLogger().info("Subscription created", { subscriptionId: subscription2.id, stripeCustomerId });
+    return subscription2;
+  };
+  const cancelSubscription = async (stripeSubscriptionId, cancelAtPeriodEnd = false) => {
+    const stripe2 = await initializeStripe();
+    let subscription2;
+    if (cancelAtPeriodEnd) {
+      subscription2 = await stripe2.subscriptions.update(stripeSubscriptionId, { cancel_at_period_end: true });
+      await updateStrapiSubscription(stripeSubscriptionId, { cancel_at_period_end: true });
+    } else {
+      subscription2 = await stripe2.subscriptions.cancel(stripeSubscriptionId);
+      await updateStrapiSubscription(stripeSubscriptionId, {
+        status: "canceled",
+        canceled_at: (/* @__PURE__ */ new Date()).toISOString(),
+        cancel_at_period_end: false
+      });
+    }
+    getLogger().info("Subscription canceled", { stripeSubscriptionId, cancelAtPeriodEnd });
+    return subscription2;
+  };
+  const updateSubscription = async (stripeSubscriptionId, params) => {
+    const stripe2 = await initializeStripe();
+    const updateParams = {};
+    if (params.priceId) {
+      const current = await stripe2.subscriptions.retrieve(stripeSubscriptionId);
+      const itemId = current.items.data[0]?.id;
+      updateParams.items = [{ id: itemId, price: params.priceId }];
+      updateParams.proration_behavior = "create_prorations";
+    }
+    if (params.cancelAtPeriodEnd !== void 0) {
+      updateParams.cancel_at_period_end = params.cancelAtPeriodEnd;
+    }
+    if (params.trialEnd !== void 0) {
+      updateParams.trial_end = params.trialEnd;
+    }
+    if (params.metadata) {
+      updateParams.metadata = params.metadata;
+    }
+    if (params.defaultPaymentMethod) {
+      updateParams.default_payment_method = params.defaultPaymentMethod;
+    }
+    const subscription2 = await stripe2.subscriptions.update(stripeSubscriptionId, updateParams);
+    const firstItem = subscription2.items.data[0];
+    await updateStrapiSubscription(stripeSubscriptionId, {
+      stripe_price_id: firstItem?.price?.id,
+      stripe_product_id: firstItem?.price?.product,
+      cancel_at_period_end: subscription2.cancel_at_period_end,
+      status: mapStripeSubscriptionStatus(subscription2.status),
+      metadata: subscription2.metadata
+    });
+    getLogger().info("Subscription updated", { stripeSubscriptionId });
+    return subscription2;
+  };
+  const retrieveSubscription = async (stripeSubscriptionId) => {
+    const stripe2 = await initializeStripe();
+    return stripe2.subscriptions.retrieve(stripeSubscriptionId, {
+      expand: ["latest_invoice", "customer"]
+    });
+  };
   return {
     initializeStripe,
     createPaymentIntent,
@@ -2126,7 +2692,13 @@ const stripeService = ({ strapi: strapi2 }) => {
     createCustomerRecord,
     createOrderRecord,
     initializePaymentFlow,
-    getStripe
+    getStripe,
+    createSubscription,
+    cancelSubscription,
+    updateSubscription,
+    retrieveSubscription,
+    createStrapiSubscriptionRecord,
+    updateStrapiSubscription
   };
 };
 const services = {