billsdk 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,3 +1,4 @@
+import { createDefaultTimeProvider } from '@billsdk/core';
 export * from '@billsdk/core';
 export { drizzleAdapter } from '@billsdk/drizzle-adapter';
 import { memoryAdapter } from '@billsdk/memory-adapter';
@@ -325,7 +326,8 @@ function calculateProration(params) {
     changeDate = /* @__PURE__ */ new Date()
   } = params;
   const totalDays = daysBetween(currentPeriodStart, currentPeriodEnd);
-  const daysRemaining = daysBetween(changeDate, currentPeriodEnd);
+  const daysUsed = daysBetween(currentPeriodStart, changeDate);
+  const daysRemaining = totalDays - daysUsed;
   const effectiveDaysRemaining = Math.max(
     0,
     Math.min(daysRemaining, totalDays)
@@ -333,15 +335,13 @@ function calculateProration(params) {
   const credit = Math.round(
     oldPlanAmount / totalDays * effectiveDaysRemaining
   );
-  const charge = Math.round(
-    newPlanAmount / totalDays * effectiveDaysRemaining
-  );
-  const netAmount = charge - credit;
+  const charge = newPlanAmount;
+  const netAmount = Math.max(0, charge - credit);
   return {
     credit,
     charge,
     netAmount,
-    daysRemaining: effectiveDaysRemaining,
+    daysUsed: Math.max(0, Math.min(daysUsed, totalDays)),
     totalDays
   };
 }
@@ -490,8 +490,19 @@ async function cancelSubscription(ctx, params) {
     accessUntil: subscription.currentPeriodEnd
   };
 }
+var intervalRank = {
+  monthly: 1,
+  quarterly: 2,
+  yearly: 3
+};
+function isUpgrade(oldPrice, newPrice, oldInterval, newInterval) {
+  if (oldInterval !== newInterval) {
+    return intervalRank[newInterval] > intervalRank[oldInterval];
+  }
+  return newPrice > oldPrice;
+}
 async function changeSubscription(ctx, params) {
-  const { customerId, newPlanCode, prorate = true } = params;
+  const { customerId, newPlanCode, newInterval, prorate = true } = params;
   const customer = await ctx.internalAdapter.findCustomerByExternalId(customerId);
   if (!customer) {
     throw new Error("Customer not found");
@@ -502,7 +513,8 @@ async function changeSubscription(ctx, params) {
   if (!subscription) {
     throw new Error("No active subscription found");
   }
-  if (subscription.planCode === newPlanCode) {
+  const targetInterval = newInterval ?? subscription.interval;
+  if (subscription.planCode === newPlanCode && subscription.interval === targetInterval) {
     throw new Error("Already on this plan");
   }
   const oldPlan = ctx.internalAdapter.findPlanByCode(subscription.planCode);
@@ -519,27 +531,67 @@ async function changeSubscription(ctx, params) {
   }
   const newPrice = ctx.internalAdapter.getPlanPrice(
     newPlanCode,
-    subscription.interval
+    targetInterval
   );
   if (!newPrice) {
     throw new Error(
-      `No price found for plan ${newPlanCode} with interval ${subscription.interval}`
+      `No price found for plan ${newPlanCode} with interval ${targetInterval}`
+    );
+  }
+  const upgrade = isUpgrade(
+    oldPrice.amount,
+    newPrice.amount,
+    subscription.interval,
+    targetInterval
+  );
+  ctx.logger.info("Plan change detected", {
+    from: `${subscription.planCode} (${subscription.interval})`,
+    to: `${newPlanCode} (${targetInterval})`,
+    oldAmount: oldPrice.amount,
+    newAmount: newPrice.amount,
+    isUpgrade: upgrade
+  });
+  if (!upgrade) {
+    ctx.logger.info("Downgrade scheduled for period end", {
+      scheduledPlanCode: newPlanCode,
+      scheduledInterval: targetInterval,
+      effectiveAt: subscription.currentPeriodEnd
+    });
+    const updatedSubscription2 = await ctx.internalAdapter.updateSubscription(
+      subscription.id,
+      {
+        scheduledPlanCode: newPlanCode,
+        scheduledInterval: targetInterval
+      }
     );
+    return {
+      subscription: updatedSubscription2,
+      previousPlan: oldPlan,
+      newPlan,
+      payment: null,
+      scheduled: true,
+      effectiveAt: subscription.currentPeriodEnd
+    };
   }
   let payment = null;
+  const changeDate = await ctx.timeProvider.now(params.customerId);
+  ctx.logger.info("changeDate from timeProvider", {
+    changeDate: changeDate.toISOString(),
+    realTime: (/* @__PURE__ */ new Date()).toISOString()
+  });
   if (prorate) {
     const prorationResult = calculateProration({
       oldPlanAmount: oldPrice.amount,
       newPlanAmount: newPrice.amount,
       currentPeriodStart: subscription.currentPeriodStart,
       currentPeriodEnd: subscription.currentPeriodEnd,
-      changeDate: /* @__PURE__ */ new Date()
+      changeDate
     });
     ctx.logger.info("Proration calculated", {
       credit: prorationResult.credit,
       charge: prorationResult.charge,
       netAmount: prorationResult.netAmount,
-      daysRemaining: prorationResult.daysRemaining
+      daysUsed: prorationResult.daysUsed
     });
     if (prorationResult.netAmount > 0) {
       if (!ctx.paymentAdapter?.charge) {
@@ -591,15 +643,36 @@ async function changeSubscription(ctx, params) {
       });
     }
   }
+  const newPeriodStart = changeDate;
+  const newPeriodEnd = new Date(changeDate);
+  if (targetInterval === "yearly") {
+    newPeriodEnd.setFullYear(newPeriodEnd.getFullYear() + 1);
+  } else if (targetInterval === "quarterly") {
+    newPeriodEnd.setMonth(newPeriodEnd.getMonth() + 3);
+  } else {
+    newPeriodEnd.setMonth(newPeriodEnd.getMonth() + 1);
+  }
   const updatedSubscription = await ctx.internalAdapter.updateSubscription(
     subscription.id,
-    { planCode: newPlanCode }
+    {
+      planCode: newPlanCode,
+      interval: targetInterval,
+      currentPeriodStart: newPeriodStart,
+      currentPeriodEnd: newPeriodEnd,
+      scheduledPlanCode: void 0,
+      scheduledInterval: void 0
+    }
   );
+  ctx.logger.info("Period reset", {
+    from: `${subscription.currentPeriodStart.toISOString()} - ${subscription.currentPeriodEnd.toISOString()}`,
+    to: `${newPeriodStart.toISOString()} - ${newPeriodEnd.toISOString()}`
+  });
   return {
     subscription: updatedSubscription,
     previousPlan: oldPlan,
     newPlan,
-    payment
+    payment,
+    scheduled: false
   };
 }
 
@@ -762,6 +835,326 @@ var refundEndpoints = {
     }
   }
 };
+
+// src/logic/renewal-service.ts
+function calculateNewPeriodEnd(from, interval) {
+  const newEnd = new Date(from);
+  if (interval === "yearly") {
+    newEnd.setFullYear(newEnd.getFullYear() + 1);
+  } else if (interval === "quarterly") {
+    newEnd.setMonth(newEnd.getMonth() + 3);
+  } else {
+    newEnd.setMonth(newEnd.getMonth() + 1);
+  }
+  return newEnd;
+}
+async function findDueSubscriptions(ctx, params) {
+  const now = params.customerId ? await ctx.timeProvider.now(params.customerId) : /* @__PURE__ */ new Date();
+  const where = [
+    // Only active or past_due subscriptions
+    {
+      field: "status",
+      operator: "in",
+      value: ["active", "past_due"]
+    },
+    // Period has ended
+    {
+      field: "currentPeriodEnd",
+      operator: "lte",
+      value: now
+    }
+  ];
+  if (params.customerId) {
+    const customer = await ctx.internalAdapter.findCustomerByExternalId(
+      params.customerId
+    );
+    if (!customer) {
+      return [];
+    }
+    where.push({
+      field: "customerId",
+      operator: "eq",
+      value: customer.id
+    });
+  }
+  return ctx.adapter.findMany({
+    model: TABLES.SUBSCRIPTION,
+    where,
+    limit: params.limit,
+    sortBy: { field: "currentPeriodEnd", direction: "asc" }
+  });
+}
+async function applyScheduledChanges(ctx, subscription) {
+  if (!subscription.scheduledPlanCode) {
+    return {
+      planChanged: false,
+      newPlanCode: subscription.planCode,
+      newInterval: subscription.interval
+    };
+  }
+  const newPlanCode = subscription.scheduledPlanCode;
+  const newInterval = subscription.scheduledInterval ?? subscription.interval;
+  ctx.logger.info("Applying scheduled plan change", {
+    subscriptionId: subscription.id,
+    from: subscription.planCode,
+    to: newPlanCode,
+    newInterval
+  });
+  await ctx.internalAdapter.updateSubscription(subscription.id, {
+    planCode: newPlanCode,
+    interval: newInterval,
+    scheduledPlanCode: void 0,
+    scheduledInterval: void 0
+  });
+  return {
+    planChanged: true,
+    newPlanCode,
+    newInterval
+  };
+}
+async function processSubscriptionRenewal(ctx, subscription, dryRun) {
+  const customer = await ctx.internalAdapter.findCustomerById(
+    subscription.customerId
+  );
+  if (!customer) {
+    return {
+      subscriptionId: subscription.id,
+      customerId: subscription.customerId,
+      status: "failed",
+      error: "Customer not found"
+    };
+  }
+  const {
+    planChanged,
+    newPlanCode,
+    newInterval: newIntervalStr
+  } = await applyScheduledChanges(ctx, subscription);
+  const newInterval = newIntervalStr;
+  const price = ctx.internalAdapter.getPlanPrice(newPlanCode, newInterval);
+  if (!price) {
+    return {
+      subscriptionId: subscription.id,
+      customerId: customer.externalId,
+      status: "failed",
+      error: `No price found for plan ${newPlanCode} with interval ${newInterval}`,
+      planChanged: planChanged ? { from: subscription.planCode, to: newPlanCode } : void 0
+    };
+  }
+  const amount = price.amount;
+  const now = await ctx.timeProvider.now(customer.externalId);
+  if (dryRun) {
+    return {
+      subscriptionId: subscription.id,
+      customerId: customer.externalId,
+      status: "succeeded",
+      amount,
+      planChanged: planChanged ? { from: subscription.planCode, to: newPlanCode } : void 0
+    };
+  }
+  if (amount === 0) {
+    const newPeriodEnd2 = calculateNewPeriodEnd(now, newInterval);
+    await ctx.internalAdapter.updateSubscription(subscription.id, {
+      currentPeriodStart: now,
+      currentPeriodEnd: newPeriodEnd2,
+      status: "active"
+    });
+    ctx.logger.info("Free renewal processed", {
+      subscriptionId: subscription.id,
+      newPeriodEnd: newPeriodEnd2.toISOString()
+    });
+    return {
+      subscriptionId: subscription.id,
+      customerId: customer.externalId,
+      status: "succeeded",
+      amount: 0,
+      planChanged: planChanged ? { from: subscription.planCode, to: newPlanCode } : void 0
+    };
+  }
+  if (!customer.providerCustomerId) {
+    ctx.logger.warn("Customer has no payment method, marking as past_due", {
+      subscriptionId: subscription.id,
+      customerId: customer.externalId
+    });
+    await ctx.internalAdapter.updateSubscription(subscription.id, {
+      status: "past_due"
+    });
+    return {
+      subscriptionId: subscription.id,
+      customerId: customer.externalId,
+      status: "failed",
+      error: "No payment method on file",
+      planChanged: planChanged ? { from: subscription.planCode, to: newPlanCode } : void 0
+    };
+  }
+  if (!ctx.paymentAdapter?.charge) {
+    ctx.logger.error("Payment adapter does not support direct charging", {
+      subscriptionId: subscription.id
+    });
+    return {
+      subscriptionId: subscription.id,
+      customerId: customer.externalId,
+      status: "failed",
+      error: "Payment adapter does not support direct charging",
+      planChanged: planChanged ? { from: subscription.planCode, to: newPlanCode } : void 0
+    };
+  }
+  const plan = ctx.internalAdapter.findPlanByCode(newPlanCode);
+  const chargeResult = await ctx.paymentAdapter.charge({
+    customer: {
+      id: customer.id,
+      email: customer.email,
+      providerCustomerId: customer.providerCustomerId
+    },
+    amount,
+    currency: price.currency,
+    description: `Renewal: ${plan?.name ?? newPlanCode} (${newInterval})`,
+    metadata: {
+      subscriptionId: subscription.id,
+      customerId: customer.id,
+      type: "renewal",
+      planCode: newPlanCode
+    }
+  });
+  if (chargeResult.status === "failed") {
+    ctx.logger.warn("Renewal charge failed", {
+      subscriptionId: subscription.id,
+      error: chargeResult.error
+    });
+    await ctx.internalAdapter.updateSubscription(subscription.id, {
+      status: "past_due"
+    });
+    return {
+      subscriptionId: subscription.id,
+      customerId: customer.externalId,
+      status: "failed",
+      error: chargeResult.error ?? "Charge failed",
+      planChanged: planChanged ? { from: subscription.planCode, to: newPlanCode } : void 0
+    };
+  }
+  const newPeriodEnd = calculateNewPeriodEnd(now, newInterval);
+  await ctx.internalAdapter.updateSubscription(subscription.id, {
+    currentPeriodStart: now,
+    currentPeriodEnd: newPeriodEnd,
+    status: "active"
+  });
+  await ctx.internalAdapter.createPayment({
+    customerId: customer.id,
+    subscriptionId: subscription.id,
+    type: "renewal",
+    status: "succeeded",
+    amount,
+    currency: price.currency,
+    providerPaymentId: chargeResult.providerPaymentId,
+    metadata: {
+      planCode: newPlanCode,
+      interval: newInterval
+    }
+  });
+  ctx.logger.info("Renewal succeeded", {
+    subscriptionId: subscription.id,
+    amount,
+    newPeriodEnd: newPeriodEnd.toISOString()
+  });
+  return {
+    subscriptionId: subscription.id,
+    customerId: customer.externalId,
+    status: "succeeded",
+    amount,
+    planChanged: planChanged ? { from: subscription.planCode, to: newPlanCode } : void 0
+  };
+}
+async function processRenewals(ctx, params = {}) {
+  const { dryRun = false } = params;
+  ctx.logger.info("Starting renewal processing", {
+    dryRun,
+    customerId: params.customerId,
+    limit: params.limit
+  });
+  const dueSubscriptions = await findDueSubscriptions(ctx, params);
+  ctx.logger.info(
+    `Found ${dueSubscriptions.length} subscriptions due for renewal`
+  );
+  const result = {
+    processed: 0,
+    succeeded: 0,
+    failed: 0,
+    skipped: 0,
+    renewals: []
+  };
+  for (const subscription of dueSubscriptions) {
+    result.processed++;
+    try {
+      const renewalResult = await processSubscriptionRenewal(
+        ctx,
+        subscription,
+        dryRun
+      );
+      result.renewals.push(renewalResult);
+      if (renewalResult.status === "succeeded") {
+        result.succeeded++;
+      } else if (renewalResult.status === "failed") {
+        result.failed++;
+      } else {
+        result.skipped++;
+      }
+    } catch (error) {
+      ctx.logger.error("Error processing renewal", {
+        subscriptionId: subscription.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      result.failed++;
+      result.renewals.push({
+        subscriptionId: subscription.id,
+        customerId: subscription.customerId,
+        status: "failed",
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  ctx.logger.info("Renewal processing complete", {
+    processed: result.processed,
+    succeeded: result.succeeded,
+    failed: result.failed,
+    skipped: result.skipped
+  });
+  return result;
+}
+
+// src/api/routes/renewals.ts
+var processRenewalsQuerySchema = z.object({
+  /**
+   * Process only a specific customer (useful for testing)
+   */
+  customerId: z.string().optional(),
+  /**
+   * Dry run - don't actually charge, just report what would happen
+   */
+  dryRun: z.string().transform((val) => val === "true").optional(),
+  /**
+   * Maximum number of subscriptions to process (for batching)
+   */
+  limit: z.string().transform((val) => Number.parseInt(val, 10)).refine((val) => !Number.isNaN(val) && val > 0, {
+    message: "limit must be a positive number"
+  }).optional()
+});
+var renewalEndpoints = {
+  processRenewals: {
+    path: "/renewals",
+    options: {
+      method: "GET",
+      query: processRenewalsQuerySchema
+    },
+    handler: async (context) => {
+      const { ctx, query } = context;
+      const result = await processRenewals(ctx, {
+        customerId: query.customerId,
+        dryRun: query.dryRun ?? false,
+        limit: query.limit
+      });
+      return result;
+    }
+  }
+};
 var getSubscriptionQuerySchema = z.object({
   customerId: z.string().min(1)
 });
@@ -954,6 +1347,7 @@ function getEndpoints(ctx) {
     ...featureEndpoints,
     ...paymentEndpoints,
     ...refundEndpoints,
+    ...renewalEndpoints,
     ...webhookEndpoints
   };
   let allEndpoints = { ...baseEndpoints };
@@ -1154,7 +1548,7 @@ function featureConfigToFeature(config) {
     type: config.type ?? "boolean"
   };
 }
-function createInternalAdapter(adapter, plans = [], features = []) {
+function createInternalAdapter(adapter, plans = [], features = [], getNow = async () => /* @__PURE__ */ new Date()) {
   const plansByCode = /* @__PURE__ */ new Map();
   for (const config of plans) {
     plansByCode.set(config.code, planConfigToPlan(config));
@@ -1166,7 +1560,7 @@ function createInternalAdapter(adapter, plans = [], features = []) {
   return {
     // Customer operations (DB)
     async createCustomer(data) {
-      const now = /* @__PURE__ */ new Date();
+      const now = await getNow();
       return adapter.create({
         model: TABLES.CUSTOMER,
         data: {
@@ -1238,7 +1632,7 @@ function createInternalAdapter(adapter, plans = [], features = []) {
     },
     // Subscription operations (DB)
     async createSubscription(data) {
-      const now = /* @__PURE__ */ new Date();
+      const now = await getNow();
       const interval = data.interval ?? "monthly";
       const currentPeriodEnd = new Date(now);
       if (interval === "yearly") {
@@ -1308,14 +1702,15 @@ function createInternalAdapter(adapter, plans = [], features = []) {
       });
     },
     async updateSubscription(id, data) {
+      const now = await getNow();
       return adapter.update({
         model: TABLES.SUBSCRIPTION,
         where: [{ field: "id", operator: "eq", value: id }],
-        update: { ...data, updatedAt: /* @__PURE__ */ new Date() }
+        update: { ...data, updatedAt: now }
       });
     },
     async cancelSubscription(id, cancelAt) {
-      const now = /* @__PURE__ */ new Date();
+      const now = await getNow();
       return adapter.update({
         model: TABLES.SUBSCRIPTION,
         where: [{ field: "id", operator: "eq", value: id }],
@@ -1358,7 +1753,7 @@ function createInternalAdapter(adapter, plans = [], features = []) {
     },
     // Payment operations (DB)
     async createPayment(data) {
-      const now = /* @__PURE__ */ new Date();
+      const now = await getNow();
       return adapter.create({
         model: TABLES.PAYMENT,
         data: {
@@ -1467,10 +1862,12 @@ async function createBillingContext(adapter, options) {
       schema = { ...schema, ...plugin.schema };
     }
   }
+  const getNow = async () => /* @__PURE__ */ new Date();
   const internalAdapter = createInternalAdapter(
     adapter,
     options.plans ?? [],
-    options.features ?? []
+    options.features ?? [],
+    getNow
   );
   const context = {
     options: resolvedOptions,
@@ -1482,6 +1879,7 @@ async function createBillingContext(adapter, options) {
     plugins,
     logger,
     secret: resolvedOptions.secret,
+    timeProvider: createDefaultTimeProvider(),
     hasPlugin(id) {
       return plugins.some((p) => p.id === id);
     },
@@ -1621,6 +2019,10 @@ function createAPI(contextPromise) {
         amount: params.amount,
         reason: params.reason
       });
+    },
+    async processRenewals(params) {
+      const ctx = await contextPromise;
+      return processRenewals(ctx, params);
     }
   };
 }