@goweekdays/core 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @goweekdays/core
 
+## 1.1.0
+
+### Minor Changes
+
+- 794d115: Add paid invoice webhook
+
 ## 1.0.0
 
 ### Major Changes

package/dist/index.d.ts

@@ -1995,10 +1995,37 @@ declare function useInvoiceRepo(): {
         } | undefined;
         createdAt?: Date | undefined;
     } | null>;
+    getByTransactionId: (id: string) => Promise<{
+        type: "organization-subscription" | "affiliate-subscription" | "one-time-payment" | "other";
+        status: "pending" | "cancelled" | "paid" | "overdue";
+        amount: number;
+        invoiceNumber: string;
+        dueDate: Date;
+        items: {
+            description: string;
+            unitPrice: number;
+            quantity: number;
+            total: number;
+            seats?: number | undefined;
+        }[];
+        _id?: ObjectId | undefined;
+        updatedAt?: Date | undefined;
+        metadata?: {
+            description?: string | undefined;
+            userId?: string | ObjectId | undefined;
+            orgId?: string | ObjectId | undefined;
+            transactionId?: string | undefined;
+            currency?: string | undefined;
+            subscriptionId?: string | ObjectId | undefined;
+            billingCycle?: "monthly" | "yearly" | "quarterly" | undefined;
+        } | undefined;
+        createdAt?: Date | undefined;
+    } | null>;
 };
 
 declare function useInvoiceService(): {
     processOverDueInvoices: (BATCH_SIZE?: number, MAX_RETRIES?: number) => Promise<void>;
+    paypalPaidInvoiceWebhookHandler: (invoiceId: string, status: string) => Promise<"Payment processed successfully." | undefined>;
 };
 
 declare function useInvoiceController(): {

package/dist/index.js

@@ -21101,6 +21101,15 @@ function useInvoiceRepo() {
       throw new import_utils63.InternalServerError("Failed to get invoice by invoice number.");
     }
   }
+  async function getByTransactionId(id) {
+    try {
+      return await collection.findOne({
+        "metadata.transactionId": id
+      });
+    } catch (error) {
+      throw new import_utils63.InternalServerError("Failed to get invoice by transaction ID.");
+    }
+  }
   async function getBySubscriptionId({ page, search, limit, sort, id } = {}) {
     try {
       try {
@@ -21183,7 +21192,8 @@ function useInvoiceRepo() {
     updateStatusByInvoiceNumber,
     getOverdueInvoices,
     getBySubscriptionId,
-    getByNumber
+    getByNumber,
+    getByTransactionId
   };
 }
 
@@ -24781,16 +24791,18 @@ function useOrderController() {
 // src/services/invoice.service.ts
 var import_utils84 = require("@goweekdays/utils");
 function useInvoiceService() {
-  const { getOverdueInvoices, updateStatusByInvoiceNumber, getByNumber } = useInvoiceRepo();
+  const {
+    getOverdueInvoices,
+    updateStatusByInvoiceNumber,
+    getByTransactionId
+  } = useInvoiceRepo();
   const {
     getById,
     processSuccessfulPayment,
     updateMaxSeatsById,
-    markSubscriptionAsFailed,
     updateStatusById
   } = useSubscriptionRepo();
-  const { pay, getPaymentMethodById } = useXenditService();
-  const { add: addPayment, getByInvoiceId } = usePaymentRepo();
+  const { add: addPayment } = usePaymentRepo();
   const { getInvoiceById } = usePaypalService();
   async function processOverDueInvoices(BATCH_SIZE = 100, MAX_RETRIES = 7) {
     while (true) {
@@ -24933,8 +24945,95 @@ function useInvoiceService() {
       });
     }
   }
+  async function paypalPaidInvoiceWebhookHandler(invoiceId, status) {
+    if (!invoiceId) {
+      throw new import_utils84.BadRequestError("Invoice ID is required.");
+    }
+    if (!status) {
+      throw new import_utils84.BadRequestError("Status is required.");
+    }
+    const session = import_utils84.useAtlas.getClient()?.startSession();
+    if (!session) {
+      import_utils84.logger.log({
+        level: "error",
+        message: "Failed to start session."
+      });
+      return;
+    }
+    try {
+      const invoice = await getByTransactionId(invoiceId);
+      if (!invoice) {
+        throw new import_utils84.NotFoundError("Invoice not found.");
+      }
+      if (!invoice.metadata?.subscriptionId) {
+        throw new import_utils84.BadRequestError(
+          "Subscription ID is missing in invoice metadata."
+        );
+      }
+      session?.startTransaction();
+      const subscription = await getById(invoice.metadata.subscriptionId);
+      if (!subscription) {
+        throw new import_utils84.NotFoundError("Subscription not found.");
+      }
+      if (!subscription._id) {
+        throw new import_utils84.BadRequestError("Subscription ID is missing.");
+      }
+      if (subscription.status !== "active") {
+        await updateStatusById(subscription._id.toString(), "active", session);
+      }
+      await updateStatusByInvoiceNumber(invoice.invoiceNumber, "paid", session);
+      await processSuccessfulPayment(
+        {
+          _id: subscription._id,
+          nextBillingDate: subscription.nextBillingDate
+        },
+        session
+      );
+      const paymentData = {
+        invoiceId: invoice.invoiceNumber,
+        amount: invoice.amount,
+        status: "completed",
+        paymentMethod: "PAYPAL",
+        metadata: {
+          userId: String(subscription.user || ""),
+          orgId: String(subscription.org || ""),
+          currency: subscription.currency,
+          payment: invoice.metadata.transactionId,
+          subscriptionId: subscription._id?.toString()
+        }
+      };
+      if (!paymentData.metadata.userId) {
+        delete paymentData.metadata.userId;
+      }
+      if (!paymentData.metadata.orgId) {
+        delete paymentData.metadata.orgId;
+      }
+      await addPayment(paymentData, session);
+      if (!subscription.paidSeats) {
+        throw new Error("Subscription paid seats is missing.");
+      }
+      await updateMaxSeatsById(
+        {
+          _id: subscription._id.toString(),
+          seats: subscription.paidSeats
+        },
+        session
+      );
+      await session.commitTransaction();
+      return "Payment processed successfully.";
+    } catch (error) {
+      session?.abortTransaction();
+      import_utils84.logger.log({
+        level: "error",
+        message: String(error)
+      });
+    } finally {
+      session?.endSession();
+    }
+  }
   return {
-    processOverDueInvoices
+    processOverDueInvoices,
+    paypalPaidInvoiceWebhookHandler
   };
 }
 
@@ -25025,6 +25124,28 @@ function useInvoiceController() {
       next(error2);
     }
   }
+  const { paypalPaidInvoiceWebhookHandler } = useInvoiceService();
+  async function paidInvoiceWebhookHandler(req, res, next) {
+    const invoiceId = req.body.resource.id ?? "";
+    const status = req.body.resource.status ?? "";
+    const validation = import_joi28.default.object({
+      invoiceId: import_joi28.default.string().required(),
+      status: import_joi28.default.string().valid("PAID").required()
+    });
+    const { error } = validation.validate({ invoiceId, status });
+    if (error) {
+      next(new import_utils85.BadRequestError(error.message));
+      return;
+    }
+    try {
+      await paypalPaidInvoiceWebhookHandler(invoiceId, status);
+      res.status(200).json({ message: "Webhook processed successfully." });
+      return;
+    } catch (error2) {
+      next(error2);
+      return;
+    }
+  }
   return {
     getBySubscriptionId,
     getByNumber,