@goweekdays/core 2.11.10 → 2.11.12

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @goweekdays/core
 
+## 2.11.12
+
+### Patch Changes
+
+- ab6a66f: Update dependencies
+
+## 2.11.11
+
+### Patch Changes
+
+- ae3339b: Refactor and simplify subscription fee computation logic
+
 ## 2.11.10
 
 ### Patch Changes

package/dist/index.d.ts

@@ -930,7 +930,7 @@ declare function useSubscriptionService(): {
         promoCode?: string;
         org: string;
         plan: string;
-    }, skipProration?: boolean) => Promise<{
+    }) => Promise<{
         monthlyAmount: number;
         proratedAmount: number;
         subscriptionAmount: number;

package/dist/index.js

@@ -6020,7 +6020,7 @@ var schemaSubscriptionTransaction = import_joi22.default.object({
     "promo-expired",
     "promo-updated"
   ).required(),
-  description: import_joi22.default.string().max(255).optional().allow("", null),
+  description: import_joi22.default.string().optional().allow("", null),
   createdBy: import_joi22.default.string().hex().length(24).required(),
   createdByName: import_joi22.default.string().optional().allow("", null)
 });
@@ -8417,147 +8417,114 @@ function useSubscriptionService() {
     }
     return total;
   }
-  async function computeFee(value, skipProration) {
+  function computeMonthlyAmount(seats, planPrice, promo) {
+    if (!promo)
+      return planPrice * seats;
+    const limit = promo.seats && promo.seats > 0 ? promo.seats : Infinity;
+    switch (promo.type) {
+      case "fixed":
+        return Math.min(seats, limit) * (promo.fixedRate ?? 0) + Math.max(seats - limit, 0) * planPrice;
+      case "flat":
+        return (promo.flatRate ?? 0) + Math.max(0, seats - limit) * planPrice;
+      case "volume":
+        return promo.tiers?.length ? calculateVolumeTierAmount(promo.tiers, 1, seats, planPrice) : planPrice * seats;
+      default:
+        return planPrice * seats;
+    }
+  }
+  function computeAdditionalSeatAmount(additionalSeats, planPrice, promo, paidSeats) {
+    if (additionalSeats <= 0)
+      return 0;
+    if (!promo) {
+      return additionalSeats * planPrice;
+    }
+    const limit = promo.seats && promo.seats > 0 ? promo.seats : Infinity;
+    switch (promo.type) {
+      case "flat": {
+        const chargeableSeats = Math.max(0, paidSeats + additionalSeats - limit) - Math.max(0, paidSeats - limit);
+        return chargeableSeats * planPrice;
+      }
+      case "fixed": {
+        const promoSeatsLeft = Math.max(0, limit - paidSeats);
+        const promoSeats = Math.min(additionalSeats, promoSeatsLeft);
+        const normalSeats = additionalSeats - promoSeats;
+        return promoSeats * (promo.fixedRate ?? 0) + normalSeats * planPrice;
+      }
+      case "volume":
+        return promo.tiers?.length ? calculateVolumeTierAmount(
+          promo.tiers,
+          paidSeats + 1,
+          additionalSeats,
+          planPrice
+        ) : additionalSeats * planPrice;
+      default:
+        return additionalSeats * planPrice;
+    }
+  }
+  function computeProration(subscription, seats, plan, promo) {
+    const additionalSeats = Math.max(0, seats - subscription.paidSeats);
+    if (additionalSeats === 0)
+      return 0;
+    const today = /* @__PURE__ */ new Date();
+    const nextBilling = new Date(subscription.nextBillingDate);
+    const daysRemaining = Math.max(
+      0,
+      (nextBilling.getTime() - today.getTime()) / 864e5
+    );
+    const cycleDays = plan.billingCycle === "yearly" ? 365 : 30;
+    if (daysRemaining === 0)
+      return 0;
+    const additionalAmount = computeAdditionalSeatAmount(
+      additionalSeats,
+      plan.price,
+      promo,
+      subscription.paidSeats
+    );
+    return additionalAmount / cycleDays * daysRemaining;
+  }
+  async function computeFee(value) {
     const { error } = schemaSubscriptionCompute.validate(value);
     if (error) {
       throw new import_utils44.BadRequestError(`Invalid subscription data: ${error.message}`);
     }
     const existingSubscription = await getByOrg(value.org);
     const plan = await getPlanById(value.plan);
-    if (!plan) {
+    if (!plan)
       throw new import_utils44.BadRequestError("Plan not found.");
+    const isNew = !existingSubscription;
+    const isPromoChange = !!existingSubscription && value.promoCode !== void 0 && value.promoCode !== existingSubscription.promoCode;
+    const isSeatIncrease = !!existingSubscription && value.seats > existingSubscription.seats;
+    if (isPromoChange && isSeatIncrease) {
+      throw new import_utils44.BadRequestError(
+        "Cannot change promo code while increasing seats. Perform actions separately."
+      );
     }
-    const org = await getOrgById(value.org);
-    if (!org) {
-      throw new import_utils44.BadRequestError("Organization not found.");
-    }
-    let promo = null;
-    const promoCode = value.promoCode;
-    if (promoCode) {
-      promo = await getPromoByCode(promoCode);
-      if (!promo) {
-        throw new import_utils44.BadRequestError("Promo code not found.");
-      }
-      if (promo.usage && promo.usage > 0) {
-        const currentUsageCount = await countByPromoId(
-          promo._id?.toString() ?? ""
-        );
-        const isAlreadyUsingPromo = existingSubscription?.promoCode === promoCode;
-        if (!isAlreadyUsingPromo && currentUsageCount >= promo.usage) {
-          throw new import_utils44.BadRequestError(
-            "Promo code has reached its maximum usage limit."
-          );
-        }
-      }
-    }
-    let monthlyAmount = plan.price * value.seats;
-    if (promo) {
-      const promoSeatLimit = promo.seats && promo.seats > 0 ? promo.seats : Infinity;
-      switch (promo.type) {
-        case "fixed": {
-          const promoSeats = Math.min(value.seats, promoSeatLimit);
-          const standardSeats = Math.max(value.seats - promoSeatLimit, 0);
-          monthlyAmount = Math.max(promo.fixedRate ?? 0, 0) * promoSeats + plan.price * standardSeats;
-          break;
-        }
-        case "flat": {
-          const standardSeats = Math.max(value.seats - promoSeatLimit, 0);
-          monthlyAmount = (promo.flatRate ?? 0) + plan.price * standardSeats;
-          break;
-        }
-        case "volume": {
-          if (promo.tiers && promo.tiers.length > 0) {
-            monthlyAmount = calculateVolumeTierAmount(
-              promo.tiers,
-              1,
-              value.seats,
-              plan.price
-            );
-          }
-          break;
-        }
-        default:
-          monthlyAmount = plan.price * value.seats;
-      }
-    }
+    const effectivePromoCode = isPromoChange ? value.promoCode : existingSubscription?.promoCode;
+    const promo = effectivePromoCode ? await getPromoByCode(effectivePromoCode) : null;
+    const monthlyAmount = computeMonthlyAmount(value.seats, plan.price, promo);
     let proratedAmount = 0;
-    let daysRemaining = 0;
-    let totalDaysInCycle = 30;
-    if (existingSubscription) {
-      const today = /* @__PURE__ */ new Date();
-      const nextBillingDate = new Date(existingSubscription.nextBillingDate);
-      const timeDiff = nextBillingDate.getTime() - today.getTime();
-      daysRemaining = Math.max(0, Math.ceil(timeDiff / (1e3 * 60 * 60 * 24)));
-      if (plan.billingCycle === "yearly") {
-        totalDaysInCycle = 365;
-      }
-      daysRemaining = Math.min(daysRemaining, totalDaysInCycle);
-      const daysElapsed = totalDaysInCycle - daysRemaining;
-      const additionalSeats = Math.max(
-        0,
-        value.seats - existingSubscription.paidSeats
+    if (existingSubscription && isSeatIncrease && !isPromoChange) {
+      proratedAmount = computeProration(
+        existingSubscription,
+        value.seats,
+        plan,
+        promo
       );
-      if (additionalSeats > 0 && daysRemaining > 0 && daysElapsed > 0 && !skipProration) {
-        let additionalSeatsAmount = 0;
-        if (promo?.type === "volume" && promo.tiers && promo.tiers.length > 0) {
-          additionalSeatsAmount = calculateVolumeTierAmount(
-            promo.tiers,
-            existingSubscription.paidSeats + 1,
-            additionalSeats,
-            plan.price
-          );
-        } else if (promo?.type === "fixed") {
-          const promoSeatLimit = promo.seats && promo.seats > 0 ? promo.seats : Infinity;
-          const startSeat = existingSubscription.paidSeats + 1;
-          const endSeat = value.seats;
-          const promoSeatsInRange = Math.max(
-            0,
-            Math.min(promoSeatLimit, endSeat) - startSeat + 1
-          );
-          const standardSeatsInRange = Math.max(
-            0,
-            additionalSeats - promoSeatsInRange
-          );
-          additionalSeatsAmount = (promo.fixedRate ?? 0) * promoSeatsInRange + plan.price * standardSeatsInRange;
-        } else if (promo?.type === "flat") {
-          const promoSeatLimit = promo.seats && promo.seats > 0 ? promo.seats : Infinity;
-          const startSeat = existingSubscription.paidSeats + 1;
-          const endSeat = value.seats;
-          if (startSeat > promoSeatLimit) {
-            additionalSeatsAmount = plan.price * additionalSeats;
-          } else {
-            const seatsStillCoveredByFlat = Math.max(
-              0,
-              Math.min(promoSeatLimit, endSeat) - startSeat + 1
-            );
-            const seatsAtPlanPrice = additionalSeats - seatsStillCoveredByFlat;
-            additionalSeatsAmount = plan.price * seatsAtPlanPrice;
-          }
-        } else {
-          additionalSeatsAmount = plan.price * additionalSeats;
-        }
-        const dailyRate = additionalSeatsAmount / totalDaysInCycle;
-        proratedAmount = dailyRate * daysRemaining;
-      }
     }
-    const isIncrease = existingSubscription && value.seats > existingSubscription.paidSeats;
     let subscriptionAmount;
-    if (!existingSubscription) {
-      subscriptionAmount = Math.round(monthlyAmount * 100) / 100;
-    } else if (proratedAmount > 0) {
-      subscriptionAmount = Math.round((existingSubscription.amount + proratedAmount) * 100) / 100;
-    } else if (isIncrease) {
-      subscriptionAmount = Math.round(monthlyAmount * 100) / 100;
+    if (isNew) {
+      subscriptionAmount = monthlyAmount;
+    } else if (isPromoChange) {
+      subscriptionAmount = monthlyAmount;
+    } else if (isSeatIncrease) {
+      subscriptionAmount = existingSubscription.amount + proratedAmount;
     } else {
-      subscriptionAmount = Math.round(existingSubscription.amount * 100) / 100;
+      subscriptionAmount = existingSubscription.amount;
     }
     return {
-      // The monthly fee for the next billing cycle
       monthlyAmount: Math.round(monthlyAmount * 100) / 100,
-      // The prorated amount to charge now for mid-cycle seat additions
       proratedAmount: Math.round(proratedAmount * 100) / 100,
-      // The new subscription.amount for updates
-      subscriptionAmount,
+      subscriptionAmount: Math.round(subscriptionAmount * 100) / 100,
       currency: plan.currency
     };
   }
@@ -8699,20 +8666,23 @@ function useSubscriptionService() {
       const { subscriptionAmount, proratedAmount, currency } = await computeFee(
         {
           seats: value.seats,
-          promoCode: value.promoCode ?? "",
           plan: value.plan ?? "",
           org: value.org
         }
       );
       const seatIncreased = value.seats > subscription.paidSeats;
-      const additionalSeats = value.seats - subscription.paidSeats;
-      const paidSeats = seatIncreased ? value.seats : subscription.paidSeats;
+      const additionalSeats = seatIncreased ? value.seats - subscription.paidSeats : 0;
+      const paidSeats = seatIncreased ? subscription.paidSeats + additionalSeats : subscription.paidSeats;
       await updateById(
         subscription._id?.toString() ?? "",
-        { seats: value.seats, amount: subscriptionAmount, paidSeats },
+        {
+          seats: value.seats,
+          amount: subscriptionAmount,
+          paidSeats
+        },
         session
       );
-      if (seatIncreased) {
+      if (seatIncreased && proratedAmount > 0) {
         await addTransaction(
           {
             type: "add-seat",
@@ -8778,15 +8748,12 @@ function useSubscriptionService() {
       if (!plan) {
         throw new import_utils44.BadRequestError("Plan not found.");
       }
-      const { subscriptionAmount, currency } = await computeFee(
-        {
-          seats: subscription.seats,
-          promoCode: value.promoCode ?? "",
-          plan: plan._id?.toString() ?? "",
-          org: value.org
-        },
-        true
-      );
+      const { subscriptionAmount, currency } = await computeFee({
+        seats: subscription.seats,
+        promoCode: value.promoCode ?? "",
+        plan: plan._id?.toString() ?? "",
+        org: value.org
+      });
       await updateById(
         subscription._id?.toString() ?? "",
         { promoCode: value.promoCode ?? "", amount: subscriptionAmount },
@@ -8795,6 +8762,9 @@ function useSubscriptionService() {
       if (subscription.promoCode) {
         await updatePromoUsageStatusByOrgId(value.org, "inactive", session);
       }
+      let description = `Promo code updated to ${value.promoCode ?? "none"}. At the time of update, ${(0, import_utils44.formatNumber)(subscription.paidSeats, {
+        decimalPlaces: 0
+      })} seat(s) were already included in the subscription.`;
       if (promo && promo._id) {
         await addPromoUsage(
           {
@@ -8804,11 +8774,44 @@ function useSubscriptionService() {
           },
           session
         );
+        const additionalDescription = `${promo.seats ? `Seats beyond ${(0, import_utils44.formatNumber)(promo.seats, {
+          decimalPlaces: 0
+        })} are charged at the standard rate.` : ""}`;
+        if (promo.type === "flat") {
+          description += ` ${(0, import_utils44.formatNumber)(promo.flatRate ?? 0, {
+            currency,
+            useSymbol: true
+          })} ${promo.seats ? `limited to ${(0, import_utils44.formatNumber)(promo.seats, {
+            decimalPlaces: 0
+          })} seat(s)` : " for all seats"}. ${additionalDescription}`;
+        }
+        if (promo.type === "fixed") {
+          description += ` ${(0, import_utils44.formatNumber)(promo.fixedRate ?? 0, {
+            currency,
+            useSymbol: true
+          })} per seat${promo.seats ? `, limited to ${(0, import_utils44.formatNumber)(promo.seats, {
+            decimalPlaces: 0
+          })} seat(s)` : ""}. ${additionalDescription}`;
+        }
+        if (promo.type === "volume") {
+          if (promo.tiers && promo.tiers.length > 0) {
+            const tierDescriptions = promo.tiers.map((tier) => {
+              const maxSeatsDesc = tier.maxSeats === 0 ? "and above" : `to ${(0, import_utils44.formatNumber)(tier.maxSeats, { decimalPlaces: 0 })}`;
+              return `${(0, import_utils44.formatNumber)(tier.minSeats, {
+                decimalPlaces: 0
+              })} ${maxSeatsDesc} ${(0, import_utils44.formatNumber)(tier.rate, {
+                currency,
+                useSymbol: true
+              })} per seat`;
+            }).join(", ");
+            description += ` Volume tiers, ${tierDescriptions}.`;
+          }
+        }
       }
       await addTransaction(
         {
           type: "promo-updated",
-          description: `Updated promo code to ${value.promoCode || "none"}.`,
+          description,
           amount: 0,
           currency,
           subscription: subscription._id?.toString() ?? "",