@reeboot/strapi-payment-plugin 0.0.4 → 0.0.5

package/dist/server/index.mjs

@@ -102,7 +102,7 @@ const schema$1 = {
       configurable: false
     },
     total_amount: {
-      type: "integer",
+      type: "decimal",
       required: true,
       min: 0,
       configurable: false,
@@ -114,13 +114,31 @@ const schema$1 = {
       default: "usd",
       configurable: false
     },
-    status: {
+    order_status: {
       type: "enumeration",
-      enum: ["pending", "processing", "completed", "failed", "refunded"],
+      enum: [
+        "pending",
+        "processing",
+        "completed",
+        "failed",
+        "refunded"
+      ],
       required: true,
       default: "pending",
       configurable: false
     },
+    payment_status: {
+      type: "enumeration",
+      enum: [
+        "unpaid",
+        "paid",
+        "partially_paid",
+        "refunded"
+      ],
+      required: true,
+      default: "unpaid",
+      configurable: false
+    },
     customer: {
       type: "relation",
       relation: "manyToOne",
@@ -170,7 +188,7 @@ const schema = {
       configurable: false
     },
     amount: {
-      type: "integer",
+      type: "decimal",
       required: true,
       min: 0,
       configurable: false,
@@ -182,9 +200,15 @@ const schema = {
       default: "usd",
       configurable: false
     },
-    status: {
+    payment_status: {
       type: "enumeration",
-      enum: ["pending", "succeeded", "failed", "canceled"],
+      enum: [
+        "pending",
+        "succeeded",
+        "failed",
+        "canceled",
+        "refunded"
+      ],
       required: true,
       default: "pending",
       configurable: false
@@ -381,23 +405,17 @@ const stripeController = {
   async handleWebhook(ctx) {
     try {
       const signature = ctx.request.headers["stripe-signature"];
-      let payload;
-      if (typeof ctx.request.body === "string") {
-        payload = ctx.request.body;
-      } else if (Buffer.isBuffer(ctx.request.body)) {
-        payload = ctx.request.body;
-      } else {
-        payload = JSON.stringify(ctx.request.body);
-      }
+      const unparsedBody = ctx.request.body?.[Symbol.for("unparsedBody")];
+      const rawBody = unparsedBody || ctx.request.body;
       if (!signature) {
         return ctx.badRequest("Missing Stripe signature");
       }
       const stripeService2 = strapi.plugin("payment-plugin").service("stripe");
-      const event = await stripeService2.constructEvent(payload, signature);
+      const event = await stripeService2.constructEvent(rawBody, signature);
       await stripeService2.handleWebhook(event);
       ctx.body = { received: true };
     } catch (error) {
-      strapi.log.error("Failed to handle webhook", { error });
+      strapi.log.error("Failed to handle webhook", { error: error.message, stack: error.stack });
       ctx.badRequest(`Webhook Error: ${error.message}`);
     }
   },
@@ -472,10 +490,11 @@ const stripeController = {
    */
   async listPayments(ctx) {
     try {
-      const { page = 1, pageSize = 25, status, customer: customer2, order: order2 } = ctx.query;
+      const { page = 1, pageSize = 25, payment_status, status, customer: customer2, order: order2 } = ctx.query;
       const { id: userId } = ctx.state.user;
       const filters = {};
-      if (status) filters.status = { $eq: status };
+      const statusValue = payment_status || status;
+      if (statusValue) filters.payment_status = { $eq: statusValue };
       if (customer2) filters.customer = { $eq: customer2 };
       if (order2) filters.order = { $eq: order2 };
       const isAdmin = ctx.state.user.role?.name === "Administrator";
@@ -583,7 +602,7 @@ const stripeController = {
         order_number: orderNumber,
         total_amount: totalAmount,
         currency,
-        status: "pending",
+        order_status: "pending",
         customer: customerId,
         items,
         metadata
@@ -596,7 +615,7 @@ const stripeController = {
         data: {
           orderId: order2.documentId,
           orderNumber: order2.order_number,
-          status: order2.status,
+          order_status: order2.order_status,
           totalAmount: order2.total_amount,
           currency: order2.currency,
           created: order2.createdAt
@@ -654,10 +673,11 @@ const stripeController = {
    */
   async listOrders(ctx) {
     try {
-      const { page = 1, pageSize = 25, status, customer: customer2 } = ctx.query;
+      const { page = 1, pageSize = 25, order_status, status, customer: customer2 } = ctx.query;
       const { id: userId } = ctx.state.user;
       const filters = {};
-      if (status) filters.status = { $eq: status };
+      const statusValue = order_status || status;
+      if (statusValue) filters.order_status = { $eq: statusValue };
       if (customer2) filters.customer = { $eq: customer2 };
       const isAdmin = ctx.state.user.role?.name === "Administrator";
       if (!isAdmin) {
@@ -705,11 +725,11 @@ const stripeController = {
       const startDate = new Date(now.getTime() - days * 24 * 60 * 60 * 1e3);
       const [totalPayments, successfulPayments, failedPayments, totalRevenue] = await Promise.all([
         strapi.documents("plugin::payment-plugin.payment").count({}),
-        strapi.documents("plugin::payment-plugin.payment").count({ filters: { status: { $eq: "succeeded" } } }),
-        strapi.documents("plugin::payment-plugin.payment").count({ filters: { status: { $eq: "failed" } } }),
+        strapi.documents("plugin::payment-plugin.payment").count({ filters: { payment_status: { $eq: "succeeded" } } }),
+        strapi.documents("plugin::payment-plugin.payment").count({ filters: { payment_status: { $eq: "failed" } } }),
         strapi.documents("plugin::payment-plugin.payment").findMany({
           filters: {
-            status: { $eq: "succeeded" },
+            payment_status: { $eq: "succeeded" },
             createdAt: { $gte: startDate.toISOString() }
           },
           fields: ["amount"]
@@ -767,7 +787,7 @@ const stripeController = {
         totalPayments: payments.length,
         totalAmount: payments.reduce((sum, p) => sum + p.amount, 0),
         byStatus: payments.reduce((acc, p) => {
-          acc[p.status] = (acc[p.status] || 0) + 1;
+          acc[p.payment_status] = (acc[p.payment_status] || 0) + 1;
           return acc;
         }, {}),
         byCurrency: payments.reduce((acc, p) => {
@@ -857,7 +877,7 @@ const stripeController = {
       const payments = await strapi.documents("plugin::payment-plugin.payment").findMany({
         filters: {
           createdAt: { $gte: startDate.toISOString() },
-          status: { $eq: "succeeded" }
+          payment_status: { $eq: "succeeded" }
         },
         fields: ["amount", "createdAt", "currency"],
         sort: { createdAt: "asc" }
@@ -896,37 +916,56 @@ const stripeController = {
       if (!paymentId) {
         return ctx.badRequest("Payment ID is required");
       }
-      const payments = await strapi.documents("plugin::payment-plugin.payment").findMany({
-        filters: { documentId: paymentId }
+      const payment2 = await strapi.documents("plugin::payment-plugin.payment").findOne({
+        documentId: paymentId,
+        populate: ["order"]
       });
-      if (payments.length === 0) {
+      if (!payment2) {
         return ctx.notFound("Payment not found");
       }
-      const payment2 = payments[0];
+      if (!payment2.stripe_payment_intent_id) {
+        return ctx.badRequest("This payment record does not have an associated Stripe Payment Intent ID");
+      }
       const stripeService2 = strapi.plugin("payment-plugin").service("stripe");
       const refund = await stripeService2.createRefund({
         paymentIntentId: payment2.stripe_payment_intent_id,
-        amount,
+        amount: amount ? Math.round(amount * 100) : void 0,
         reason,
         metadata: { ...metadata, admin_refund: true }
       });
       await strapi.documents("plugin::payment-plugin.payment").update({
         documentId: payment2.documentId,
-        data: { status: "refunded" }
+        data: { payment_status: "refunded" }
       });
+      if (payment2.order) {
+        const orderId = typeof payment2.order === "object" ? payment2.order.documentId : payment2.order;
+        await strapi.documents("plugin::payment-plugin.order").update({
+          documentId: orderId,
+          data: {
+            order_status: "refunded",
+            payment_status: "refunded"
+          }
+        });
+      }
       ctx.body = {
         success: true,
         data: {
           refundId: refund.id,
-          amount: refund.amount,
+          amount: refund.amount / 100,
+          // Convert back to base units for consistency
           currency: refund.currency,
           status: refund.status,
           reason: refund.reason
         }
       };
     } catch (error) {
-      strapi.log.error("Failed to create admin refund", { error });
-      ctx.internalServerError("Failed to create admin refund");
+      strapi.log.error("Failed to create admin refund:", {
+        message: error.message,
+        stack: error.stack,
+        ...error.raw && { stripeError: error.raw }
+      });
+      const errorMessage = error.message || "Failed to create admin refund";
+      ctx.internalServerError(errorMessage);
     }
   },
   /**
@@ -934,9 +973,10 @@ const stripeController = {
    */
   async adminListPayments(ctx) {
     try {
-      const { page = 1, pageSize = 25, status, customer: customer2, order: order2 } = ctx.query;
+      const { page = 1, pageSize = 25, payment_status, status, customer: customer2, order: order2 } = ctx.query;
       const filters = {};
-      if (status) filters.status = { $eq: status };
+      const statusValue = payment_status || status;
+      if (statusValue) filters.payment_status = { $eq: statusValue };
       if (customer2) filters.customer = { $eq: customer2 };
       if (order2) filters.order = { $eq: order2 };
       const pageNum = parseInt(page);
@@ -985,7 +1025,7 @@ const stripeController = {
           filters,
           populate: {
             payments: {
-              filters: { status: { $eq: "succeeded" } },
+              filters: { payment_status: { $eq: "succeeded" } },
               fields: ["amount"]
             }
           },
@@ -1027,9 +1067,10 @@ const stripeController = {
    */
   async adminListOrders(ctx) {
     try {
-      const { page = 1, pageSize = 25, status, customer: customer2 } = ctx.query;
+      const { page = 1, pageSize = 25, order_status, status, customer: customer2 } = ctx.query;
       const filters = {};
-      if (status) filters.status = { $eq: status };
+      const statusValue = order_status || status;
+      if (statusValue) filters.order_status = { $eq: statusValue };
       if (customer2) filters.customer = { $eq: customer2 };
       const pageNum = parseInt(page);
       const pageSizeNum = parseInt(pageSize);
@@ -1143,19 +1184,32 @@ const stripeController = {
         email: `sample@example.com`,
         firstName: "Sample",
         lastName: "Customer",
-        confirm: true,
-        payment_method: "pm_card_visa",
-        // Still using this for the 'test' button to show a success
+        confirm: false,
+        // Don't auto-confirm, let frontend handle it
         metadata: { is_sample: "true" }
       });
-      if (flowResult.stripePaymentIntent.status === "succeeded") {
-        await stripeService2.updateStrapiOrder(flowResult.order.documentId, {
-          status: "completed"
-        });
+      const store = strapi.store({ type: "plugin", name: "payment-plugin" });
+      const config2 = await store.get({ key: "settings" });
+      const staticConfig = strapi.config.get("plugin::payment-plugin") || {};
+      const mergedConfig = { ...staticConfig || {}, ...config2 || {} };
+      const publishableKey = mergedConfig.stripe?.publishableKey || process.env.STRIPE_PUBLISHABLE_KEY || (process.env.STRIPE_API_KEY?.startsWith("pk_") ? process.env.STRIPE_API_KEY : "") || "";
+      strapi.log.info("Publishing key check:", {
+        hasEnvKey: !!process.env.STRIPE_PUBLISHABLE_KEY,
+        hasConfigKey: !!mergedConfig.stripe?.publishableKey,
+        keyLength: publishableKey?.length || 0,
+        keyPrefix: publishableKey?.substring(0, 7)
+      });
+      if (!publishableKey) {
+        strapi.log.error("Publishable key not found in environment or config");
+        throw new Error("Stripe publishable key not configured. Please set STRIPE_PUBLISHABLE_KEY in your .env file.");
       }
       ctx.body = {
         success: true,
-        data: flowResult
+        data: {
+          ...flowResult,
+          publishableKey,
+          clientSecret: flowResult.stripePaymentIntent.client_secret
+        }
       };
     } catch (error) {
       strapi.log.error("Failed to create sample payment", { error });
@@ -1599,6 +1653,16 @@ const stripeService = ({ strapi: strapi2 }) => {
       const stripe2 = await initializeStripe();
       const logger = getLogger();
       const paymentIntent = await stripe2.paymentIntents.confirm(paymentIntentId);
+      await updateStrapiPayment(paymentIntent.id, {
+        payment_status: mapStripeStatusToStrapi(paymentIntent.status),
+        metadata: paymentIntent.metadata
+      });
+      if (paymentIntent.status === "succeeded" && paymentIntent.metadata?.strapi_order_id) {
+        await updateStrapiOrder(paymentIntent.metadata.strapi_order_id, {
+          order_status: "processing",
+          payment_status: "paid"
+        });
+      }
       logger.info("Payment confirmed", { paymentIntentId, status: paymentIntent.status });
       return paymentIntent;
     } catch (error) {
@@ -1671,15 +1735,25 @@ const stripeService = ({ strapi: strapi2 }) => {
         refundData.reason = reason;
       }
       const refund = await stripe2.refunds.create(refundData);
-      logger.info("Refund processed", {
+      logger.info("Refund processed successfully", {
         refundId: refund.id,
         paymentIntentId,
-        amount: refund.amount
+        amount: refund.amount,
+        status: refund.status
       });
       return refund;
     } catch (error) {
       const logger = getLogger();
-      logger.error("Failed to create refund", { error, params });
+      const errorMessage = error instanceof Error ? error.message : "Unknown Stripe 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,
+        params
+      });
       throw error;
     }
   };
@@ -1707,9 +1781,18 @@ const stripeService = ({ strapi: strapi2 }) => {
         }
       });
       if (existingPayments.length > 0) {
+        const updateData = { ...data };
+        if (data.metadata) {
+          if (!updateData.customer && data.metadata.strapi_customer_id) {
+            updateData.customer = data.metadata.strapi_customer_id;
+          }
+          if (!updateData.order && data.metadata.strapi_order_id) {
+            updateData.order = data.metadata.strapi_order_id;
+          }
+        }
         await strapi2.documents("plugin::payment-plugin.payment").update({
           documentId: existingPayments[0].documentId,
-          data
+          data: updateData
         });
       }
     } catch (error) {
@@ -1760,7 +1843,7 @@ const stripeService = ({ strapi: strapi2 }) => {
     return strapi2.documents("plugin::payment-plugin.order").create({
       data: {
         ...data,
-        status: data.status || "pending"
+        order_status: data.order_status || "pending"
       }
     });
   };
@@ -1773,7 +1856,7 @@ const stripeService = ({ strapi: strapi2 }) => {
         stripe_payment_intent_id: paymentIntent.id,
         amount: paymentIntent.amount / 100,
         currency: paymentIntent.currency,
-        status: mapStripeStatusToStrapi(paymentIntent.status),
+        payment_status: mapStripeStatusToStrapi(paymentIntent.status),
         payment_method: paymentIntent.payment_method || "card",
         metadata: paymentIntent.metadata,
         customer: customerId,
@@ -1851,6 +1934,12 @@ const stripeService = ({ strapi: strapi2 }) => {
       metadata: { ...metadata, flow: "functional_api" }
     });
     const strapiPayment = await createStrapiPaymentRecord(paymentIntent);
+    if (paymentIntent.status === "succeeded") {
+      await updateStrapiOrder(strapiOrder.documentId, {
+        order_status: "processing",
+        payment_status: "paid"
+      });
+    }
     return {
       payment: strapiPayment,
       order: strapiOrder,
@@ -1870,51 +1959,58 @@ const stripeService = ({ strapi: strapi2 }) => {
         });
       }
       switch (event.type) {
-        case "payment_intent.succeeded": {
-          const paymentIntent = event.data.object;
-          try {
-            const existingPayments = await strapi2.documents("plugin::payment-plugin.payment").findMany({
-              filters: {
-                stripe_payment_intent_id: paymentIntent.id
-              }
-            });
-            if (existingPayments.length > 0) {
-              await strapi2.documents("plugin::payment-plugin.payment").update({
-                documentId: existingPayments[0].documentId,
-                data: {
-                  status: "succeeded",
-                  metadata: paymentIntent.metadata
-                }
-              });
-            } else {
-              await createStrapiPaymentRecord(paymentIntent);
-            }
-          } catch (error) {
-            await createStrapiPaymentRecord(paymentIntent);
+        case "payment_intent.succeeded":
+        case "charge.succeeded": {
+          const obj = event.data.object;
+          const paymentIntentId = event.type === "payment_intent.succeeded" ? obj.id : obj.payment_intent;
+          if (!paymentIntentId) break;
+          const metadata = obj.metadata || {};
+          await updateStrapiPayment(paymentIntentId, {
+            payment_status: "succeeded",
+            metadata
+          });
+          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);
           }
-          const orderId = paymentIntent.metadata?.strapi_order_id;
+          const orderId = metadata.strapi_order_id;
           if (orderId) {
             await updateStrapiOrder(orderId, {
-              status: "completed"
+              order_status: "processing",
+              payment_status: "paid"
             });
           }
-          logger.info("Payment succeeded", {
-            paymentIntentId: paymentIntent.id,
-            amount: paymentIntent.amount,
+          logger.info(`Payment succeeded handled for ${event.type}`, {
+            paymentIntentId,
             orderId
           });
           break;
         }
+        case "payment_intent.processing": {
+          const paymentIntent = event.data.object;
+          await updateStrapiPayment(paymentIntent.id, {
+            payment_status: "pending",
+            metadata: paymentIntent.metadata
+          });
+          break;
+        }
         case "payment_intent.payment_failed": {
           const paymentIntent = event.data.object;
           await updateStrapiPayment(paymentIntent.id, {
-            status: "failed",
+            payment_status: "failed",
             metadata: paymentIntent.metadata
           });
           const orderId = paymentIntent.metadata?.strapi_order_id;
           if (orderId) {
             await updateStrapiOrder(orderId, {
-              status: "failed"
+              order_status: "failed",
+              payment_status: "unpaid"
             });
           }
           logger.warn("Payment failed", {
@@ -1927,13 +2023,14 @@ const stripeService = ({ strapi: strapi2 }) => {
         case "payment_intent.canceled": {
           const paymentIntent = event.data.object;
           await updateStrapiPayment(paymentIntent.id, {
-            status: "canceled",
+            payment_status: "canceled",
             metadata: paymentIntent.metadata
           });
           const orderId = paymentIntent.metadata?.strapi_order_id;
           if (orderId) {
             await updateStrapiOrder(orderId, {
-              status: "failed"
+              order_status: "failed",
+              payment_status: "unpaid"
             });
           }
           logger.info("Payment canceled", {
@@ -1946,20 +2043,29 @@ const stripeService = ({ strapi: strapi2 }) => {
           const charge = event.data.object;
           if (charge.payment_intent) {
             await updateStrapiPayment(charge.payment_intent, {
-              status: "refunded"
+              payment_status: "refunded"
             });
-            const orderId = charge.metadata?.strapi_order_id;
+            let orderId = charge.metadata?.strapi_order_id;
+            if (!orderId) {
+              const payments = await strapi2.documents("plugin::payment-plugin.payment").findMany({
+                filters: { stripe_payment_intent_id: charge.payment_intent },
+                populate: ["order"]
+              });
+              if (payments.length > 0 && payments[0].order) {
+                orderId = typeof payments[0].order === "object" ? payments[0].order.documentId : payments[0].order;
+              }
+            }
             if (orderId) {
               await updateStrapiOrder(orderId, {
-                status: "refunded"
+                order_status: "refunded",
+                payment_status: "refunded"
               });
             }
           }
-          logger.info("Charge refunded", {
+          logger.info("Charge refunded handled", {
             chargeId: charge.id,
             paymentIntentId: charge.payment_intent,
-            amount: charge.amount_refunded,
-            orderId: charge.metadata?.strapi_order_id
+            amount: charge.amount_refunded
           });
           break;
         }

package/dist/server/src/content-types/index.d.ts

@@ -105,7 +105,14 @@ declare const _default: {
                     default: string;
                     configurable: boolean;
                 };
-                status: {
+                order_status: {
+                    type: string;
+                    enum: string[];
+                    required: boolean;
+                    default: string;
+                    configurable: boolean;
+                };
+                payment_status: {
                     type: string;
                     enum: string[];
                     required: boolean;
@@ -174,7 +181,7 @@ declare const _default: {
                     default: string;
                     configurable: boolean;
                 };
-                status: {
+                payment_status: {
                     type: string;
                     enum: string[];
                     required: boolean;

package/dist/server/src/content-types/order/index.d.ts

@@ -36,7 +36,14 @@ declare const _default: {
                 default: string;
                 configurable: boolean;
             };
-            status: {
+            order_status: {
+                type: string;
+                enum: string[];
+                required: boolean;
+                default: string;
+                configurable: boolean;
+            };
+            payment_status: {
                 type: string;
                 enum: string[];
                 required: boolean;

package/dist/server/src/content-types/payment/index.d.ts

@@ -36,7 +36,7 @@ declare const _default: {
                 default: string;
                 configurable: boolean;
             };
-            status: {
+            payment_status: {
                 type: string;
                 enum: string[];
                 required: boolean;

package/dist/server/src/index.d.ts

@@ -196,7 +196,14 @@ declare const _default: {
                         default: string;
                         configurable: boolean;
                     };
-                    status: {
+                    order_status: {
+                        type: string;
+                        enum: string[];
+                        required: boolean;
+                        default: string;
+                        configurable: boolean;
+                    };
+                    payment_status: {
                         type: string;
                         enum: string[];
                         required: boolean;
@@ -268,7 +275,7 @@ declare const _default: {
                         default: string;
                         configurable: boolean;
                     };
-                    status: {
+                    payment_status: {
                         type: string;
                         enum: string[];
                         required: boolean;

package/dist/server/src/types/api.d.ts

@@ -0,0 +1,31 @@
+export type PaymentStatus = 'pending' | 'succeeded' | 'failed' | 'canceled' | 'refunded';
+export type OrderStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'refunded';
+export interface PaymentInput {
+    stripe_payment_intent_id: string;
+    amount: number;
+    currency: string;
+    payment_status: PaymentStatus;
+    payment_method?: string;
+    metadata?: Record<string, any>;
+    customer?: string;
+    order?: string;
+}
+export interface OrderInput {
+    order_number: string;
+    total_amount: number;
+    currency: string;
+    order_status: OrderStatus;
+    payment_status: 'unpaid' | 'paid' | 'partially_paid' | 'refunded';
+    customer?: string;
+    items: Record<string, any>;
+    metadata?: Record<string, any>;
+}
+export interface CustomerInput {
+    email: string;
+    stripe_customer_id: string;
+    first_name: string;
+    last_name: string;
+    phone?: string;
+    address?: Record<string, any>;
+    metadata?: Record<string, any>;
+}

package/dist/server/src/types/customer.d.ts

@@ -0,0 +1,2 @@
+import { Modules } from '@strapi/strapi';
+export type Customer = Modules.Documents.Document<'plugin::payment-plugin.customer'>;