billsdk 0.1.4 → 0.2.0

package/dist/index.js

@@ -5,6 +5,7 @@ export { memoryAdapter } from '@billsdk/memory-adapter';
 import { paymentAdapter } from '@billsdk/payment-adapter';
 export { paymentAdapter } from '@billsdk/payment-adapter';
 import { z } from 'zod';
+import { getBillingSchema, TABLES } from '@billsdk/core/db';
 
 // src/index.ts
 var createCustomerSchema = z.object({
@@ -127,6 +128,51 @@ var healthEndpoint = {
     }
   }
 };
+var listPaymentsQuerySchema = z.object({
+  customerId: z.string().min(1),
+  limit: z.coerce.number().positive().max(100).optional().default(25),
+  offset: z.coerce.number().nonnegative().optional().default(0)
+});
+var getPaymentQuerySchema = z.object({
+  paymentId: z.string().min(1)
+});
+var paymentEndpoints = {
+  listPayments: {
+    path: "/payments",
+    options: {
+      method: "GET",
+      query: listPaymentsQuerySchema
+    },
+    handler: async (context) => {
+      const { ctx, query } = context;
+      const customer = await ctx.internalAdapter.findCustomerByExternalId(
+        query.customerId
+      );
+      if (!customer) {
+        return { payments: [] };
+      }
+      const payments = await ctx.internalAdapter.listPayments(customer.id, {
+        limit: query.limit,
+        offset: query.offset
+      });
+      return { payments };
+    }
+  },
+  getPayment: {
+    path: "/payment",
+    options: {
+      method: "GET",
+      query: getPaymentQuerySchema
+    },
+    handler: async (context) => {
+      const { ctx, query } = context;
+      const payment = await ctx.internalAdapter.findPaymentById(
+        query.paymentId
+      );
+      return { payment };
+    }
+  }
+};
 var planEndpoints = {
   listPlans: {
     path: "/plans",
@@ -157,6 +203,565 @@ var planEndpoints = {
     }
   }
 };
+
+// src/logic/payment-failed-service.ts
+async function handlePaymentFailed(ctx, params) {
+  const { subscriptionId, error } = params;
+  const subscription = await ctx.internalAdapter.findSubscriptionById(subscriptionId);
+  if (!subscription) {
+    throw new Error("Subscription not found");
+  }
+  ctx.logger.info("Payment failed, marking subscription as past_due", {
+    subscriptionId: subscription.id,
+    error
+  });
+  const updatedSubscription = await ctx.internalAdapter.updateSubscription(
+    subscription.id,
+    { status: "past_due" }
+  );
+  return {
+    subscription: updatedSubscription ?? {
+      ...subscription,
+      status: "past_due"
+    }
+  };
+}
+
+// src/logic/refund-service.ts
+async function createRefund(ctx, params) {
+  const { paymentId, amount, reason } = params;
+  if (!ctx.paymentAdapter?.refund) {
+    throw new Error("Payment adapter does not support refunds");
+  }
+  const payment = await ctx.internalAdapter.findPaymentById(paymentId);
+  if (!payment) {
+    throw new Error("Payment not found");
+  }
+  if (payment.status !== "succeeded") {
+    throw new Error(`Cannot refund payment with status "${payment.status}"`);
+  }
+  const alreadyRefunded = payment.refundedAmount ?? 0;
+  const remainingAmount = payment.amount - alreadyRefunded;
+  if (remainingAmount <= 0) {
+    throw new Error("Payment has already been fully refunded");
+  }
+  const refundAmount = amount ?? remainingAmount;
+  if (refundAmount > remainingAmount) {
+    throw new Error(
+      `Cannot refund ${refundAmount}. Only ${remainingAmount} is available for refund.`
+    );
+  }
+  if (!payment.providerPaymentId) {
+    throw new Error(
+      "Payment does not have a provider payment ID. Cannot process refund."
+    );
+  }
+  const result = await ctx.paymentAdapter.refund({
+    providerPaymentId: payment.providerPaymentId,
+    amount: refundAmount,
+    reason
+  });
+  if (result.status === "failed") {
+    throw new Error(result.error ?? "Refund failed");
+  }
+  const newRefundedAmount = alreadyRefunded + refundAmount;
+  const newStatus = newRefundedAmount >= payment.amount ? "refunded" : "succeeded";
+  await ctx.internalAdapter.updatePayment(payment.id, {
+    status: newStatus,
+    refundedAmount: newRefundedAmount
+  });
+  const refundPayment = await ctx.internalAdapter.createPayment({
+    customerId: payment.customerId,
+    subscriptionId: payment.subscriptionId ?? void 0,
+    type: "refund",
+    status: "succeeded",
+    amount: -refundAmount,
+    // Negative to indicate refund
+    currency: payment.currency,
+    providerPaymentId: result.providerRefundId,
+    metadata: {
+      originalPaymentId: payment.id,
+      reason
+    }
+  });
+  ctx.logger.info("Refund processed", {
+    originalPaymentId: payment.id,
+    refundPaymentId: refundPayment.id,
+    amount: refundAmount
+  });
+  if (payment.subscriptionId) {
+    const subscription = await ctx.internalAdapter.findSubscriptionById(
+      payment.subscriptionId
+    );
+    if (subscription && subscription.status !== "canceled") {
+      ctx.logger.info("Refund includes subscription cancellation", {
+        subscriptionId: subscription.id,
+        paymentId
+      });
+      await ctx.internalAdapter.cancelSubscription(subscription.id);
+    }
+  }
+  return {
+    refund: refundPayment,
+    originalPayment: {
+      ...payment,
+      status: newStatus,
+      refundedAmount: newRefundedAmount
+    }
+  };
+}
+
+// src/logic/proration.ts
+function daysBetween(start, end) {
+  const msPerDay = 1e3 * 60 * 60 * 24;
+  return Math.ceil((end.getTime() - start.getTime()) / msPerDay);
+}
+function calculateProration(params) {
+  const {
+    oldPlanAmount,
+    newPlanAmount,
+    currentPeriodStart,
+    currentPeriodEnd,
+    changeDate = /* @__PURE__ */ new Date()
+  } = params;
+  const totalDays = daysBetween(currentPeriodStart, currentPeriodEnd);
+  const daysRemaining = daysBetween(changeDate, currentPeriodEnd);
+  const effectiveDaysRemaining = Math.max(
+    0,
+    Math.min(daysRemaining, totalDays)
+  );
+  const credit = Math.round(
+    oldPlanAmount / totalDays * effectiveDaysRemaining
+  );
+  const charge = Math.round(
+    newPlanAmount / totalDays * effectiveDaysRemaining
+  );
+  const netAmount = charge - credit;
+  return {
+    credit,
+    charge,
+    netAmount,
+    daysRemaining: effectiveDaysRemaining,
+    totalDays
+  };
+}
+
+// src/logic/subscription-service.ts
+async function createSubscription(ctx, params) {
+  const {
+    customerId,
+    planCode,
+    interval = "monthly",
+    successUrl,
+    cancelUrl
+  } = params;
+  if (!ctx.paymentAdapter) {
+    throw new Error("Payment adapter not configured");
+  }
+  const customer = await ctx.internalAdapter.findCustomerByExternalId(customerId);
+  if (!customer) {
+    throw new Error("Customer not found");
+  }
+  const plan = ctx.internalAdapter.findPlanByCode(planCode);
+  if (!plan) {
+    throw new Error("Plan not found");
+  }
+  const price = ctx.internalAdapter.getPlanPrice(planCode, interval);
+  if (!price) {
+    throw new Error(
+      `No price found for plan ${planCode} with interval ${interval}`
+    );
+  }
+  const subscription = await ctx.internalAdapter.createSubscription({
+    customerId: customer.id,
+    planCode,
+    interval,
+    status: "pending_payment",
+    trialDays: price.trialDays
+  });
+  const result = await ctx.paymentAdapter.processPayment({
+    customer: {
+      id: customer.id,
+      email: customer.email,
+      providerCustomerId: customer.providerCustomerId
+    },
+    plan: {
+      code: plan.code,
+      name: plan.name
+    },
+    price: {
+      amount: price.amount,
+      currency: price.currency,
+      interval: price.interval
+    },
+    subscription: {
+      id: subscription.id
+    },
+    successUrl,
+    cancelUrl,
+    metadata: {
+      subscriptionId: subscription.id,
+      customerId: customer.id
+    }
+  });
+  if (result.status === "active") {
+    const existingSubscriptions = await ctx.internalAdapter.listSubscriptions(
+      customer.id
+    );
+    for (const existing of existingSubscriptions) {
+      if (existing.id !== subscription.id && (existing.status === "active" || existing.status === "trialing")) {
+        await ctx.internalAdapter.cancelSubscription(existing.id);
+      }
+    }
+    const activeSubscription = await ctx.internalAdapter.updateSubscription(
+      subscription.id,
+      { status: "active" }
+    );
+    if (result.providerCustomerId && !customer.providerCustomerId) {
+      await ctx.internalAdapter.updateCustomer(customer.id, {
+        providerCustomerId: result.providerCustomerId
+      });
+    }
+    if (price.amount > 0) {
+      await ctx.internalAdapter.createPayment({
+        customerId: customer.id,
+        subscriptionId: subscription.id,
+        type: "subscription",
+        status: "succeeded",
+        amount: price.amount,
+        currency: price.currency,
+        metadata: {
+          planCode: plan.code,
+          interval
+        }
+      });
+    }
+    return {
+      subscription: activeSubscription ?? {
+        ...subscription,
+        status: "active"
+      }
+    };
+  }
+  if (result.status === "pending") {
+    await ctx.internalAdapter.updateSubscription(subscription.id, {
+      providerCheckoutSessionId: result.sessionId
+    });
+    if (result.providerCustomerId && !customer.providerCustomerId) {
+      await ctx.internalAdapter.updateCustomer(customer.id, {
+        providerCustomerId: result.providerCustomerId
+      });
+    }
+    return {
+      subscription,
+      redirectUrl: result.redirectUrl
+    };
+  }
+  await ctx.internalAdapter.updateSubscription(subscription.id, {
+    status: "canceled"
+  });
+  throw new Error(result.error);
+}
+async function cancelSubscription(ctx, params) {
+  const { customerId, cancelAt = "period_end" } = params;
+  const customer = await ctx.internalAdapter.findCustomerByExternalId(customerId);
+  if (!customer) {
+    throw new Error("Customer not found");
+  }
+  const subscription = await ctx.internalAdapter.findSubscriptionByCustomerId(
+    customer.id
+  );
+  if (!subscription) {
+    throw new Error("No active subscription found");
+  }
+  if (cancelAt === "immediately") {
+    const canceled2 = await ctx.internalAdapter.cancelSubscription(
+      subscription.id
+    );
+    return { subscription: canceled2, canceledImmediately: true };
+  }
+  const canceled = await ctx.internalAdapter.cancelSubscription(
+    subscription.id,
+    subscription.currentPeriodEnd
+  );
+  return {
+    subscription: canceled,
+    canceledImmediately: false,
+    accessUntil: subscription.currentPeriodEnd
+  };
+}
+async function changeSubscription(ctx, params) {
+  const { customerId, newPlanCode, prorate = true } = params;
+  const customer = await ctx.internalAdapter.findCustomerByExternalId(customerId);
+  if (!customer) {
+    throw new Error("Customer not found");
+  }
+  const subscription = await ctx.internalAdapter.findSubscriptionByCustomerId(
+    customer.id
+  );
+  if (!subscription) {
+    throw new Error("No active subscription found");
+  }
+  if (subscription.planCode === newPlanCode) {
+    throw new Error("Already on this plan");
+  }
+  const oldPlan = ctx.internalAdapter.findPlanByCode(subscription.planCode);
+  const oldPrice = ctx.internalAdapter.getPlanPrice(
+    subscription.planCode,
+    subscription.interval
+  );
+  if (!oldPrice) {
+    throw new Error("Current plan price not found");
+  }
+  const newPlan = ctx.internalAdapter.findPlanByCode(newPlanCode);
+  if (!newPlan) {
+    throw new Error("New plan not found");
+  }
+  const newPrice = ctx.internalAdapter.getPlanPrice(
+    newPlanCode,
+    subscription.interval
+  );
+  if (!newPrice) {
+    throw new Error(
+      `No price found for plan ${newPlanCode} with interval ${subscription.interval}`
+    );
+  }
+  let payment = null;
+  if (prorate) {
+    const prorationResult = calculateProration({
+      oldPlanAmount: oldPrice.amount,
+      newPlanAmount: newPrice.amount,
+      currentPeriodStart: subscription.currentPeriodStart,
+      currentPeriodEnd: subscription.currentPeriodEnd,
+      changeDate: /* @__PURE__ */ new Date()
+    });
+    ctx.logger.info("Proration calculated", {
+      credit: prorationResult.credit,
+      charge: prorationResult.charge,
+      netAmount: prorationResult.netAmount,
+      daysRemaining: prorationResult.daysRemaining
+    });
+    if (prorationResult.netAmount > 0) {
+      if (!ctx.paymentAdapter?.charge) {
+        throw new Error(
+          "Payment adapter does not support direct charging. Cannot process upgrade."
+        );
+      }
+      if (!customer.providerCustomerId) {
+        throw new Error(
+          "Customer does not have a saved payment method. Cannot process upgrade."
+        );
+      }
+      const chargeResult = await ctx.paymentAdapter.charge({
+        customer: {
+          id: customer.id,
+          email: customer.email,
+          providerCustomerId: customer.providerCustomerId
+        },
+        amount: prorationResult.netAmount,
+        currency: newPrice.currency,
+        description: `Upgrade from ${oldPlan?.name ?? subscription.planCode} to ${newPlan.name}`,
+        metadata: {
+          subscriptionId: subscription.id,
+          customerId: customer.id,
+          type: "upgrade",
+          oldPlanCode: subscription.planCode,
+          newPlanCode
+        }
+      });
+      if (chargeResult.status === "failed") {
+        throw new Error(chargeResult.error ?? "Charge failed");
+      }
+      payment = await ctx.internalAdapter.createPayment({
+        customerId: customer.id,
+        subscriptionId: subscription.id,
+        type: "upgrade",
+        status: "succeeded",
+        amount: prorationResult.netAmount,
+        currency: newPrice.currency,
+        providerPaymentId: chargeResult.providerPaymentId,
+        metadata: {
+          oldPlanCode: subscription.planCode,
+          newPlanCode,
+          proration: {
+            credit: prorationResult.credit,
+            charge: prorationResult.charge
+          }
+        }
+      });
+    }
+  }
+  const updatedSubscription = await ctx.internalAdapter.updateSubscription(
+    subscription.id,
+    { planCode: newPlanCode }
+  );
+  return {
+    subscription: updatedSubscription,
+    previousPlan: oldPlan,
+    newPlan,
+    payment
+  };
+}
+
+// src/logic/trial-end-service.ts
+async function handleTrialEnd(ctx, params) {
+  const { subscriptionId } = params;
+  const subscription = await ctx.internalAdapter.findSubscriptionById(subscriptionId);
+  if (!subscription) {
+    throw new Error("Subscription not found");
+  }
+  const customer = await ctx.internalAdapter.findCustomerById(
+    subscription.customerId
+  );
+  if (!customer) {
+    throw new Error("Customer not found");
+  }
+  const plan = ctx.internalAdapter.findPlanByCode(subscription.planCode);
+  ctx.logger.info("Processing trial end", {
+    subscriptionId: subscription.id,
+    customerId: customer.id,
+    planCode: plan?.code
+  });
+  if (!customer.providerCustomerId) {
+    ctx.logger.info("No payment method, canceling subscription", {
+      subscriptionId: subscription.id
+    });
+    const canceledSubscription = await ctx.internalAdapter.cancelSubscription(
+      subscription.id
+    );
+    return {
+      subscription: canceledSubscription ?? {
+        ...subscription,
+        status: "canceled"
+      },
+      converted: false
+    };
+  }
+  ctx.logger.info("Payment method exists, activating subscription", {
+    subscriptionId: subscription.id
+  });
+  const activeSubscription = await ctx.internalAdapter.updateSubscription(
+    subscription.id,
+    { status: "active" }
+  );
+  return {
+    subscription: activeSubscription ?? { ...subscription, status: "active" },
+    converted: true
+  };
+}
+
+// src/logic/behaviors/defaults.ts
+var defaultBehaviors = {
+  /**
+   * Default onRefund behavior: Delegates to refund service.
+   *
+   * The service handles all business logic:
+   * - Process the refund via payment adapter
+   * - Cancel the associated subscription (BillSDK opinionated default)
+   *
+   * Override this behavior if you want different logic (e.g., refund without cancel).
+   */
+  onRefund: async (ctx, params) => {
+    return createRefund(ctx, {
+      paymentId: params.paymentId,
+      amount: params.amount,
+      reason: params.reason
+    });
+  },
+  /**
+   * Default onPaymentFailed behavior: Delegates to payment-failed service.
+   *
+   * The service handles all business logic:
+   * - Find subscription
+   * - Mark as past_due
+   *
+   * Override this behavior if you want different logic (e.g., immediate cancel).
+   */
+  onPaymentFailed: async (ctx, params) => {
+    return handlePaymentFailed(ctx, {
+      subscriptionId: params.subscriptionId,
+      error: params.error
+    });
+  },
+  /**
+   * Default onSubscriptionCancel behavior: Delegates to cancel service.
+   *
+   * The service handles all business logic:
+   * - Find customer and subscription
+   * - Cancel immediately or at period end
+   *
+   * Override this behavior if you want different logic (e.g., downgrade to free).
+   */
+  onSubscriptionCancel: async (ctx, params) => {
+    return cancelSubscription(ctx, {
+      customerId: params.customerId,
+      cancelAt: params.cancelAt
+    });
+  },
+  /**
+   * Default onTrialEnd behavior: Delegates to trial-end service.
+   *
+   * The service handles all business logic:
+   * - If customer has payment method: activates subscription
+   * - If no payment method: cancels subscription
+   *
+   * Override this behavior if you want different logic (e.g., extend trial).
+   */
+  onTrialEnd: async (ctx, params) => {
+    return handleTrialEnd(ctx, {
+      subscriptionId: params.subscriptionId
+    });
+  }
+};
+
+// src/logic/behaviors/runner.ts
+async function runBehavior(ctx, behaviorName, params) {
+  const userBehavior = ctx.options.behaviors?.[behaviorName];
+  const defaultFn = defaultBehaviors[behaviorName];
+  const defaultBehavior = async () => {
+    return defaultFn(ctx, params);
+  };
+  if (userBehavior) {
+    ctx.logger.debug(`Running user-defined behavior: ${behaviorName}`);
+    return userBehavior(ctx, params, defaultBehavior);
+  }
+  ctx.logger.debug(`Running default behavior: ${behaviorName}`);
+  return defaultBehavior();
+}
+
+// src/api/routes/refund.ts
+var createRefundSchema = z.object({
+  /**
+   * Payment ID to refund (BillSDK payment ID)
+   */
+  paymentId: z.string().min(1),
+  /**
+   * Amount to refund in cents (partial refund)
+   * If omitted, full refund is issued
+   */
+  amount: z.number().positive().optional(),
+  /**
+   * Reason for the refund
+   */
+  reason: z.string().optional()
+});
+var refundEndpoints = {
+  createRefund: {
+    path: "/refund",
+    options: {
+      method: "POST",
+      body: createRefundSchema
+    },
+    handler: async (context) => {
+      const { ctx, body } = context;
+      return runBehavior(ctx, "onRefund", {
+        paymentId: body.paymentId,
+        amount: body.amount,
+        reason: body.reason
+      });
+    }
+  }
+};
 var getSubscriptionQuerySchema = z.object({
   customerId: z.string().min(1)
 });
@@ -171,6 +776,15 @@ var cancelSubscriptionSchema = z.object({
   customerId: z.string().min(1),
   cancelAt: z.enum(["period_end", "immediately"]).optional().default("period_end")
 });
+var changeSubscriptionSchema = z.object({
+  customerId: z.string().min(1),
+  newPlanCode: z.string().min(1),
+  /**
+   * Whether to prorate the charge/credit
+   * If false, the new plan starts at the next billing cycle
+   */
+  prorate: z.boolean().optional().default(true)
+});
 var subscriptionEndpoints = {
   getSubscription: {
     path: "/subscription",
@@ -210,101 +824,13 @@ var subscriptionEndpoints = {
     },
     handler: async (context) => {
       const { ctx, body } = context;
-      if (!ctx.paymentAdapter) {
-        throw new Error("Payment adapter not configured");
-      }
-      const customer = await ctx.internalAdapter.findCustomerByExternalId(
-        body.customerId
-      );
-      if (!customer) {
-        throw new Error("Customer not found");
-      }
-      const plan = ctx.internalAdapter.findPlanByCode(body.planCode);
-      if (!plan) {
-        throw new Error("Plan not found");
-      }
-      const price = ctx.internalAdapter.getPlanPrice(
-        body.planCode,
-        body.interval
-      );
-      if (!price) {
-        throw new Error(
-          `No price found for plan ${body.planCode} with interval ${body.interval}`
-        );
-      }
-      const subscription = await ctx.internalAdapter.createSubscription({
-        customerId: customer.id,
+      return createSubscription(ctx, {
+        customerId: body.customerId,
         planCode: body.planCode,
         interval: body.interval,
-        status: "pending_payment",
-        trialDays: price.trialDays
-      });
-      const result = await ctx.paymentAdapter.processPayment({
-        customer: {
-          id: customer.id,
-          email: customer.email,
-          providerCustomerId: customer.providerCustomerId
-        },
-        plan: {
-          code: plan.code,
-          name: plan.name
-        },
-        price: {
-          amount: price.amount,
-          currency: price.currency,
-          interval: price.interval
-        },
-        subscription: {
-          id: subscription.id
-        },
         successUrl: body.successUrl,
-        cancelUrl: body.cancelUrl,
-        metadata: {
-          subscriptionId: subscription.id,
-          customerId: customer.id
-        }
+        cancelUrl: body.cancelUrl
       });
-      if (result.status === "active") {
-        const existingSubscriptions = await ctx.internalAdapter.listSubscriptions(customer.id);
-        for (const existing of existingSubscriptions) {
-          if (existing.id !== subscription.id && (existing.status === "active" || existing.status === "trialing")) {
-            await ctx.internalAdapter.cancelSubscription(existing.id);
-          }
-        }
-        const activeSubscription = await ctx.internalAdapter.updateSubscription(
-          subscription.id,
-          { status: "active" }
-        );
-        if (result.providerCustomerId && !customer.providerCustomerId) {
-          await ctx.internalAdapter.updateCustomer(customer.id, {
-            providerCustomerId: result.providerCustomerId
-          });
-        }
-        return {
-          subscription: activeSubscription ?? {
-            ...subscription,
-            status: "active"
-          }
-        };
-      }
-      if (result.status === "pending") {
-        await ctx.internalAdapter.updateSubscription(subscription.id, {
-          providerCheckoutSessionId: result.sessionId
-        });
-        if (result.providerCustomerId && !customer.providerCustomerId) {
-          await ctx.internalAdapter.updateCustomer(customer.id, {
-            providerCustomerId: result.providerCustomerId
-          });
-        }
-        return {
-          subscription,
-          redirectUrl: result.redirectUrl
-        };
-      }
-      await ctx.internalAdapter.updateSubscription(subscription.id, {
-        status: "canceled"
-      });
-      throw new Error(result.error);
     }
   },
   cancelSubscription: {
@@ -315,31 +841,22 @@ var subscriptionEndpoints = {
     },
     handler: async (context) => {
       const { ctx, body } = context;
-      const customer = await ctx.internalAdapter.findCustomerByExternalId(
-        body.customerId
-      );
-      if (!customer) {
-        throw new Error("Customer not found");
-      }
-      const subscription = await ctx.internalAdapter.findSubscriptionByCustomerId(customer.id);
-      if (!subscription) {
-        throw new Error("No active subscription found");
-      }
-      if (body.cancelAt === "immediately") {
-        const canceled2 = await ctx.internalAdapter.cancelSubscription(
-          subscription.id
-        );
-        return { subscription: canceled2, canceledImmediately: true };
-      }
-      const canceled = await ctx.internalAdapter.cancelSubscription(
-        subscription.id,
-        subscription.currentPeriodEnd
-      );
-      return {
-        subscription: canceled,
-        canceledImmediately: false,
-        accessUntil: subscription.currentPeriodEnd
-      };
+      return runBehavior(ctx, "onSubscriptionCancel", {
+        customerId: body.customerId,
+        cancelAt: body.cancelAt
+      });
+    }
+  },
+  changeSubscription: {
+    path: "/subscription/change",
+    options: {
+      method: "POST",
+      body: changeSubscriptionSchema
+    },
+    handler: async (context) => {
+      const { ctx, body } = context;
+      const billingCtx = ctx;
+      return changeSubscription(billingCtx, body);
     }
   }
 };
@@ -435,6 +952,8 @@ function getEndpoints(ctx) {
     ...planEndpoints,
     ...subscriptionEndpoints,
     ...featureEndpoints,
+    ...paymentEndpoints,
+    ...refundEndpoints,
     ...webhookEndpoints
   };
   let allEndpoints = { ...baseEndpoints };
@@ -612,151 +1131,6 @@ function createRouter(ctx) {
   return { handler, endpoints };
 }
 
-// src/db/field.ts
-function defineField(attribute) {
-  return {
-    required: true,
-    input: true,
-    returned: true,
-    ...attribute
-  };
-}
-function defineTable(fields) {
-  return { fields };
-}
-
-// src/db/schema.ts
-var generateId = () => crypto.randomUUID();
-var billingSchema = {
-  customer: defineTable({
-    id: defineField({
-      type: "string",
-      primaryKey: true,
-      defaultValue: generateId,
-      input: false
-    }),
-    externalId: defineField({
-      type: "string",
-      unique: true,
-      index: true
-    }),
-    email: defineField({
-      type: "string",
-      index: true
-    }),
-    name: defineField({
-      type: "string",
-      required: false
-    }),
-    providerCustomerId: defineField({
-      type: "string",
-      required: false,
-      index: true
-    }),
-    metadata: defineField({
-      type: "json",
-      required: false
-    }),
-    createdAt: defineField({
-      type: "date",
-      defaultValue: () => /* @__PURE__ */ new Date(),
-      input: false
-    }),
-    updatedAt: defineField({
-      type: "date",
-      defaultValue: () => /* @__PURE__ */ new Date(),
-      input: false
-    })
-  }),
-  subscription: defineTable({
-    id: defineField({
-      type: "string",
-      primaryKey: true,
-      defaultValue: generateId,
-      input: false
-    }),
-    customerId: defineField({
-      type: "string",
-      index: true,
-      references: {
-        model: "customer",
-        field: "id",
-        onDelete: "cascade"
-      }
-    }),
-    // Plan code from config (not a foreign key)
-    planCode: defineField({
-      type: "string",
-      index: true
-    }),
-    // Billing interval
-    interval: defineField({
-      type: "string",
-      // "monthly" | "yearly"
-      defaultValue: "monthly"
-    }),
-    status: defineField({
-      type: "string",
-      // SubscriptionStatus
-      defaultValue: "active"
-    }),
-    providerSubscriptionId: defineField({
-      type: "string",
-      required: false,
-      index: true
-    }),
-    providerCheckoutSessionId: defineField({
-      type: "string",
-      required: false,
-      index: true
-    }),
-    currentPeriodStart: defineField({
-      type: "date",
-      defaultValue: () => /* @__PURE__ */ new Date()
-    }),
-    currentPeriodEnd: defineField({
-      type: "date"
-    }),
-    canceledAt: defineField({
-      type: "date",
-      required: false
-    }),
-    cancelAt: defineField({
-      type: "date",
-      required: false
-    }),
-    trialStart: defineField({
-      type: "date",
-      required: false
-    }),
-    trialEnd: defineField({
-      type: "date",
-      required: false
-    }),
-    metadata: defineField({
-      type: "json",
-      required: false
-    }),
-    createdAt: defineField({
-      type: "date",
-      defaultValue: () => /* @__PURE__ */ new Date(),
-      input: false
-    }),
-    updatedAt: defineField({
-      type: "date",
-      defaultValue: () => /* @__PURE__ */ new Date(),
-      input: false
-    })
-  })
-};
-function getBillingSchema() {
-  return billingSchema;
-}
-var TABLES = {
-  CUSTOMER: "customer",
-  SUBSCRIPTION: "subscription"
-};
-
 // src/db/internal-adapter.ts
 function planConfigToPlan(config) {
   return {
@@ -981,6 +1355,59 @@ function createInternalAdapter(adapter, plans = [], features = []) {
       }
       const planFeatures = this.getPlanFeatures(subscription.planCode);
       return { allowed: planFeatures.includes(featureCode) };
+    },
+    // Payment operations (DB)
+    async createPayment(data) {
+      const now = /* @__PURE__ */ new Date();
+      return adapter.create({
+        model: TABLES.PAYMENT,
+        data: {
+          customerId: data.customerId,
+          subscriptionId: data.subscriptionId,
+          type: data.type,
+          status: data.status ?? "pending",
+          amount: data.amount,
+          currency: data.currency ?? "usd",
+          providerPaymentId: data.providerPaymentId,
+          metadata: data.metadata,
+          createdAt: now,
+          updatedAt: now
+        }
+      });
+    },
+    async findPaymentById(id) {
+      return adapter.findOne({
+        model: TABLES.PAYMENT,
+        where: [{ field: "id", operator: "eq", value: id }]
+      });
+    },
+    async findPaymentByProviderPaymentId(providerPaymentId) {
+      return adapter.findOne({
+        model: TABLES.PAYMENT,
+        where: [
+          {
+            field: "providerPaymentId",
+            operator: "eq",
+            value: providerPaymentId
+          }
+        ]
+      });
+    },
+    async updatePayment(id, data) {
+      return adapter.update({
+        model: TABLES.PAYMENT,
+        where: [{ field: "id", operator: "eq", value: id }],
+        update: { ...data, updatedAt: /* @__PURE__ */ new Date() }
+      });
+    },
+    async listPayments(customerId, options) {
+      return adapter.findMany({
+        model: TABLES.PAYMENT,
+        where: [{ field: "customerId", operator: "eq", value: customerId }],
+        limit: options?.limit,
+        offset: options?.offset,
+        sortBy: { field: "createdAt", direction: "desc" }
+      });
     }
   };
 }
@@ -1020,6 +1447,7 @@ function resolveOptions(options, adapter) {
     features: options.features,
     plugins: options.plugins ?? [],
     hooks: options.hooks ?? {},
+    behaviors: options.behaviors,
     logger: {
       level: options.logger?.level ?? "info",
       disabled: options.logger?.disabled ?? false
@@ -1118,112 +1546,25 @@ function createAPI(contextPromise) {
     },
     async createSubscription(params) {
       const ctx = await contextPromise;
-      if (!ctx.paymentAdapter) {
-        throw new Error("Payment adapter not configured");
-      }
-      const customer = await ctx.internalAdapter.findCustomerByExternalId(
-        params.customerId
-      );
-      if (!customer) {
-        throw new Error("Customer not found");
-      }
-      const plan = ctx.internalAdapter.findPlanByCode(params.planCode);
-      if (!plan) {
-        throw new Error("Plan not found");
-      }
-      const interval = params.interval ?? "monthly";
-      const price = ctx.internalAdapter.getPlanPrice(params.planCode, interval);
-      if (!price) {
-        throw new Error(
-          `No price found for plan ${params.planCode} with interval ${interval}`
-        );
-      }
-      const subscription = await ctx.internalAdapter.createSubscription({
-        customerId: customer.id,
+      return createSubscription(ctx, {
+        customerId: params.customerId,
         planCode: params.planCode,
-        interval,
-        status: "pending_payment",
-        trialDays: price.trialDays
-      });
-      const result = await ctx.paymentAdapter.processPayment({
-        customer: {
-          id: customer.id,
-          email: customer.email,
-          providerCustomerId: customer.providerCustomerId
-        },
-        plan: { code: plan.code, name: plan.name },
-        price: {
-          amount: price.amount,
-          currency: price.currency,
-          interval: price.interval
-        },
-        subscription: { id: subscription.id },
+        interval: params.interval,
         successUrl: params.successUrl,
-        cancelUrl: params.cancelUrl,
-        metadata: { subscriptionId: subscription.id }
+        cancelUrl: params.cancelUrl
       });
-      if (result.status === "active") {
-        const existingSubscriptions = await ctx.internalAdapter.listSubscriptions(customer.id);
-        for (const existing of existingSubscriptions) {
-          if (existing.id !== subscription.id && (existing.status === "active" || existing.status === "trialing")) {
-            await ctx.internalAdapter.cancelSubscription(existing.id);
-          }
-        }
-        const activeSubscription = await ctx.internalAdapter.updateSubscription(
-          subscription.id,
-          { status: "active" }
-        );
-        if (result.providerCustomerId && !customer.providerCustomerId) {
-          await ctx.internalAdapter.updateCustomer(customer.id, {
-            providerCustomerId: result.providerCustomerId
-          });
-        }
-        return {
-          subscription: activeSubscription ?? {
-            ...subscription,
-            status: "active"
-          }
-        };
-      }
-      if (result.status === "pending") {
-        await ctx.internalAdapter.updateSubscription(subscription.id, {
-          providerCheckoutSessionId: result.sessionId
-        });
-        if (result.providerCustomerId && !customer.providerCustomerId) {
-          await ctx.internalAdapter.updateCustomer(customer.id, {
-            providerCustomerId: result.providerCustomerId
-          });
-        }
-        return {
-          subscription,
-          redirectUrl: result.redirectUrl
-        };
-      }
-      await ctx.internalAdapter.updateSubscription(subscription.id, {
-        status: "canceled"
-      });
-      throw new Error(result.error);
     },
     async cancelSubscription(params) {
       const ctx = await contextPromise;
-      const customer = await ctx.internalAdapter.findCustomerByExternalId(
-        params.customerId
-      );
-      if (!customer) {
-        return null;
-      }
-      const subscription = await ctx.internalAdapter.findSubscriptionByCustomerId(customer.id);
-      if (!subscription) {
-        return null;
-      }
-      const cancelAt = params.cancelAt ?? "period_end";
-      if (cancelAt === "immediately") {
-        return ctx.internalAdapter.cancelSubscription(subscription.id);
-      }
-      return ctx.internalAdapter.cancelSubscription(
-        subscription.id,
-        subscription.currentPeriodEnd
-      );
+      const result = await runBehavior(ctx, "onSubscriptionCancel", {
+        customerId: params.customerId,
+        cancelAt: params.cancelAt
+      });
+      return result.subscription;
+    },
+    async changeSubscription(params) {
+      const ctx = await contextPromise;
+      return changeSubscription(ctx, params);
     },
     async checkFeature(params) {
       const ctx = await contextPromise;
@@ -1257,6 +1598,29 @@ function createAPI(contextPromise) {
         status: "ok",
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
+    },
+    async listPayments(params) {
+      const ctx = await contextPromise;
+      const customer = await ctx.internalAdapter.findCustomerByExternalId(
+        params.customerId
+      );
+      if (!customer) return [];
+      return ctx.internalAdapter.listPayments(customer.id, {
+        limit: params.limit,
+        offset: params.offset
+      });
+    },
+    async getPayment(params) {
+      const ctx = await contextPromise;
+      return ctx.internalAdapter.findPaymentById(params.paymentId);
+    },
+    async createRefund(params) {
+      const ctx = await contextPromise;
+      return runBehavior(ctx, "onRefund", {
+        paymentId: params.paymentId,
+        amount: params.amount,
+        reason: params.reason
+      });
     }
   };
 }