billsdk 0.0.1 → 0.1.1

package/dist/index.js

@@ -1,36 +1,1300 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+export * from '@billsdk/core';
+export { drizzleAdapter } from '@billsdk/drizzle-adapter';
+import { memoryAdapter } from '@billsdk/memory-adapter';
+export { memoryAdapter } from '@billsdk/memory-adapter';
+import { paymentAdapter } from '@billsdk/payment-adapter';
+export { paymentAdapter } from '@billsdk/payment-adapter';
+import { z } from 'zod';
+
+// src/index.ts
+var createCustomerSchema = z.object({
+  externalId: z.string().min(1),
+  email: z.string().email(),
+  name: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var getCustomerQuerySchema = z.object({
+  externalId: z.string().min(1)
+});
+var customerEndpoints = {
+  createCustomer: {
+    path: "/customer",
+    options: {
+      method: "POST",
+      body: createCustomerSchema
+    },
+    handler: async (context) => {
+      const { ctx, body } = context;
+      const existing = await ctx.internalAdapter.findCustomerByExternalId(
+        body.externalId
+      );
+      if (existing) {
+        return { customer: existing };
+      }
+      const customer = await ctx.internalAdapter.createCustomer(body);
+      return { customer };
+    }
+  },
+  getCustomer: {
+    path: "/customer",
+    options: {
+      method: "GET",
+      query: getCustomerQuerySchema
+    },
+    handler: async (context) => {
+      const { ctx, query } = context;
+      const customer = await ctx.internalAdapter.findCustomerByExternalId(
+        query.externalId
+      );
+      if (!customer) {
+        return { customer: null };
+      }
+      return { customer };
+    }
+  }
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+var checkFeatureQuerySchema = z.object({
+  customerId: z.string().min(1),
+  feature: z.string().min(1)
+});
+var listFeaturesQuerySchema = z.object({
+  customerId: z.string().min(1)
+});
+var featureEndpoints = {
+  checkFeature: {
+    path: "/features/check",
+    options: {
+      method: "GET",
+      query: checkFeatureQuerySchema
+    },
+    handler: async (context) => {
+      const { ctx, query } = context;
+      const result = await ctx.internalAdapter.checkFeatureAccess(
+        query.customerId,
+        query.feature
+      );
+      return result;
+    }
+  },
+  listFeatures: {
+    path: "/features",
+    options: {
+      method: "GET",
+      query: listFeaturesQuerySchema
+    },
+    handler: async (context) => {
+      const { ctx, query } = context;
+      const customer = await ctx.internalAdapter.findCustomerByExternalId(
+        query.customerId
+      );
+      if (!customer) {
+        return { features: [] };
+      }
+      const subscription = await ctx.internalAdapter.findSubscriptionByCustomerId(customer.id);
+      if (!subscription) {
+        return { features: [] };
+      }
+      const featureCodes = ctx.internalAdapter.getPlanFeatures(
+        subscription.planCode
+      );
+      const features = featureCodes.map((code) => {
+        const feature = ctx.internalAdapter.findFeatureByCode(code);
+        return {
+          code,
+          name: feature?.name ?? code,
+          type: feature?.type ?? "boolean",
+          enabled: true
+        };
+      });
+      return { features };
+    }
   }
-  return to;
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  billsdk: () => billsdk,
-  version: () => version
+// src/api/routes/health.ts
+var healthEndpoint = {
+  health: {
+    path: "/health",
+    options: {
+      method: "GET"
+    },
+    handler: async () => {
+      return {
+        status: "ok",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        version: "0.1.0"
+      };
+    }
+  }
+};
+var planEndpoints = {
+  listPlans: {
+    path: "/plans",
+    options: {
+      method: "GET"
+    },
+    handler: async (context) => {
+      const { ctx } = context;
+      const plans = ctx.internalAdapter.listPlans({ includePrivate: false });
+      return { plans };
+    }
+  },
+  getPlan: {
+    path: "/plan",
+    options: {
+      method: "GET",
+      query: z.object({
+        code: z.string()
+      })
+    },
+    handler: async (context) => {
+      const { ctx, query } = context;
+      const plan = ctx.internalAdapter.findPlanByCode(query.code);
+      if (!plan) {
+        return { plan: null };
+      }
+      return { plan };
+    }
+  }
+};
+var getSubscriptionQuerySchema = z.object({
+  customerId: z.string().min(1)
+});
+var createSubscriptionSchema = z.object({
+  customerId: z.string().min(1),
+  planCode: z.string().min(1),
+  interval: z.enum(["monthly", "yearly"]).optional().default("monthly"),
+  successUrl: z.string().url().optional(),
+  cancelUrl: z.string().url().optional()
 });
-module.exports = __toCommonJS(index_exports);
-var version = "0.0.1";
-function billsdk() {
-  return "Billsdk package reserved";
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  billsdk,
-  version
+var cancelSubscriptionSchema = z.object({
+  customerId: z.string().min(1),
+  cancelAt: z.enum(["period_end", "immediately"]).optional().default("period_end")
 });
+var subscriptionEndpoints = {
+  getSubscription: {
+    path: "/subscription",
+    options: {
+      method: "GET",
+      query: getSubscriptionQuerySchema
+    },
+    handler: async (context) => {
+      const { ctx, query } = context;
+      const customer = await ctx.internalAdapter.findCustomerByExternalId(
+        query.customerId
+      );
+      if (!customer) {
+        return { subscription: null };
+      }
+      const subscription = await ctx.internalAdapter.findSubscriptionByCustomerId(customer.id);
+      if (!subscription) {
+        return { subscription: null };
+      }
+      const plan = ctx.internalAdapter.findPlanByCode(subscription.planCode);
+      const price = plan ? ctx.internalAdapter.getPlanPrice(
+        subscription.planCode,
+        subscription.interval
+      ) : null;
+      return {
+        subscription,
+        plan,
+        price
+      };
+    }
+  },
+  createSubscription: {
+    path: "/subscription",
+    options: {
+      method: "POST",
+      body: createSubscriptionSchema
+    },
+    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,
+        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
+        }
+      });
+      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: {
+    path: "/subscription/cancel",
+    options: {
+      method: "POST",
+      body: cancelSubscriptionSchema
+    },
+    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
+      };
+    }
+  }
+};
+
+// src/api/routes/webhook.ts
+var webhookEndpoints = {
+  handleWebhook: {
+    path: "/webhook",
+    options: {
+      method: "POST"
+    },
+    handler: async (context) => {
+      const { ctx, request } = context;
+      if (!ctx.paymentAdapter) {
+        throw new Error("Payment adapter not configured");
+      }
+      if (!ctx.paymentAdapter.confirmPayment) {
+        ctx.logger.debug("Payment adapter does not support confirmPayment");
+        return { received: true };
+      }
+      const result = await ctx.paymentAdapter.confirmPayment(request);
+      if (!result) {
+        ctx.logger.debug("Webhook event acknowledged but not processed");
+        return { received: true };
+      }
+      ctx.logger.debug("Payment confirmation received", {
+        subscriptionId: result.subscriptionId,
+        status: result.status
+      });
+      if (result.status === "active") {
+        const subscription = await ctx.internalAdapter.findSubscriptionById(
+          result.subscriptionId
+        );
+        if (subscription) {
+          const existingSubscriptions = await ctx.internalAdapter.listSubscriptions(
+            subscription.customerId
+          );
+          for (const existing of existingSubscriptions) {
+            if (existing.id !== subscription.id && (existing.status === "active" || existing.status === "trialing")) {
+              await ctx.internalAdapter.cancelSubscription(existing.id);
+              ctx.logger.info("Canceled previous subscription", {
+                subscriptionId: existing.id,
+                planCode: existing.planCode
+              });
+            }
+          }
+          await ctx.internalAdapter.updateSubscription(subscription.id, {
+            status: "active",
+            providerSubscriptionId: result.providerSubscriptionId
+          });
+          if (result.providerCustomerId) {
+            const customer = await ctx.internalAdapter.findCustomerById(
+              subscription.customerId
+            );
+            if (customer && !customer.providerCustomerId) {
+              await ctx.internalAdapter.updateCustomer(customer.id, {
+                providerCustomerId: result.providerCustomerId
+              });
+            }
+          }
+          ctx.logger.info("Subscription activated via webhook", {
+            subscriptionId: subscription.id,
+            providerSubscriptionId: result.providerSubscriptionId
+          });
+        } else {
+          ctx.logger.warn("Subscription not found for confirmation", {
+            subscriptionId: result.subscriptionId
+          });
+        }
+      } else if (result.status === "failed") {
+        const subscription = await ctx.internalAdapter.findSubscriptionById(
+          result.subscriptionId
+        );
+        if (subscription) {
+          await ctx.internalAdapter.updateSubscription(subscription.id, {
+            status: "canceled"
+          });
+          ctx.logger.warn("Payment failed, subscription canceled", {
+            subscriptionId: subscription.id
+          });
+        }
+      }
+      return { received: true };
+    }
+  }
+};
+
+// src/api/router.ts
+function getEndpoints(ctx) {
+  const baseEndpoints = {
+    ...healthEndpoint,
+    ...customerEndpoints,
+    ...planEndpoints,
+    ...subscriptionEndpoints,
+    ...featureEndpoints,
+    ...webhookEndpoints
+  };
+  let allEndpoints = { ...baseEndpoints };
+  for (const plugin of ctx.plugins) {
+    if (plugin.endpoints) {
+      allEndpoints = { ...allEndpoints, ...plugin.endpoints };
+    }
+  }
+  return allEndpoints;
+}
+function parseUrl(url, basePath) {
+  const urlObj = new URL(url);
+  let path = urlObj.pathname;
+  if (path.startsWith(basePath)) {
+    path = path.slice(basePath.length);
+  }
+  if (!path.startsWith("/")) {
+    path = `/${path}`;
+  }
+  return { path, query: urlObj.searchParams };
+}
+function queryToObject(query) {
+  const obj = {};
+  query.forEach((value, key) => {
+    obj[key] = value;
+  });
+  return obj;
+}
+function jsonResponse(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+function errorResponse(code, message, status = 400) {
+  return jsonResponse({ error: { code, message } }, status);
+}
+function createRouter(ctx) {
+  const endpoints = getEndpoints(ctx);
+  const handler = async (request) => {
+    const method = request.method.toUpperCase();
+    const { path, query } = parseUrl(request.url, ctx.basePath);
+    ctx.logger.debug(`${method} ${path}`);
+    if (ctx.options.hooks.before) {
+      const result = await ctx.options.hooks.before({
+        request,
+        path,
+        method
+      });
+      if (result instanceof Response) {
+        return result;
+      }
+    }
+    for (const plugin of ctx.plugins) {
+      if (plugin.hooks?.before) {
+        for (const hook of plugin.hooks.before) {
+          if (hook.matcher({ path, method })) {
+            const result = await hook.handler({
+              request,
+              path,
+              method,
+              billingContext: ctx
+            });
+            if (result instanceof Response) {
+              return result;
+            }
+          }
+        }
+      }
+    }
+    const endpointKey = Object.keys(endpoints).find((key) => {
+      const endpoint2 = endpoints[key];
+      if (!endpoint2) return false;
+      if (endpoint2.options.method !== method) return false;
+      return endpoint2.path === path;
+    });
+    if (!endpointKey) {
+      return errorResponse(
+        "NOT_FOUND",
+        `No endpoint found for ${method} ${path}`,
+        404
+      );
+    }
+    const endpoint = endpoints[endpointKey];
+    try {
+      const requestForHandler = request.clone();
+      let body;
+      if (["POST", "PUT", "PATCH"].includes(method) && endpoint.options.body) {
+        try {
+          const text = await request.text();
+          if (text) {
+            body = JSON.parse(text);
+          }
+        } catch {
+        }
+      }
+      if (endpoint.options.body && body) {
+        const result = endpoint.options.body.safeParse(body);
+        if (!result.success) {
+          const issues = "issues" in result.error ? result.error.issues : [];
+          return errorResponse(
+            "VALIDATION_ERROR",
+            issues.map((e) => e.message).join(", "),
+            400
+          );
+        }
+        body = result.data;
+      }
+      let queryObj = queryToObject(query);
+      if (endpoint.options.query) {
+        const result = endpoint.options.query.safeParse(queryObj);
+        if (!result.success) {
+          const issues = "issues" in result.error ? result.error.issues : [];
+          return errorResponse(
+            "VALIDATION_ERROR",
+            issues.map((e) => e.message).join(", "),
+            400
+          );
+        }
+        queryObj = result.data;
+      }
+      const endpointContext = {
+        request: requestForHandler,
+        body,
+        query: queryObj,
+        headers: requestForHandler.headers,
+        params: {},
+        ctx
+        // Add billing context
+      };
+      const response = await endpoint.handler(endpointContext);
+      let finalResponse = jsonResponse(response);
+      for (const plugin of ctx.plugins) {
+        if (plugin.hooks?.after) {
+          for (const hook of plugin.hooks.after) {
+            if (hook.matcher({ path, method })) {
+              const result = await hook.handler({
+                request,
+                path,
+                method,
+                billingContext: ctx
+              });
+              if (result instanceof Response) {
+                finalResponse = result;
+              }
+            }
+          }
+        }
+      }
+      if (ctx.options.hooks.after) {
+        const result = await ctx.options.hooks.after({
+          request,
+          path,
+          method
+        });
+        if (result instanceof Response) {
+          finalResponse = result;
+        }
+      }
+      return finalResponse;
+    } catch (error) {
+      ctx.logger.error("Endpoint error", error);
+      if (error instanceof Error) {
+        return errorResponse("INTERNAL_ERROR", error.message, 500);
+      }
+      return errorResponse(
+        "INTERNAL_ERROR",
+        "An unexpected error occurred",
+        500
+      );
+    }
+  };
+  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 {
+    code: config.code,
+    name: config.name,
+    description: config.description,
+    isPublic: config.isPublic ?? true,
+    prices: config.prices.map((p) => ({
+      amount: p.amount,
+      currency: p.currency ?? "usd",
+      interval: p.interval,
+      trialDays: p.trialDays
+    })),
+    features: config.features ?? []
+  };
+}
+function featureConfigToFeature(config) {
+  return {
+    code: config.code,
+    name: config.name,
+    type: config.type ?? "boolean"
+  };
+}
+function createInternalAdapter(adapter, plans = [], features = []) {
+  const plansByCode = /* @__PURE__ */ new Map();
+  for (const config of plans) {
+    plansByCode.set(config.code, planConfigToPlan(config));
+  }
+  const featuresByCode = /* @__PURE__ */ new Map();
+  for (const config of features) {
+    featuresByCode.set(config.code, featureConfigToFeature(config));
+  }
+  return {
+    // Customer operations (DB)
+    async createCustomer(data) {
+      const now = /* @__PURE__ */ new Date();
+      return adapter.create({
+        model: TABLES.CUSTOMER,
+        data: {
+          ...data,
+          createdAt: now,
+          updatedAt: now
+        }
+      });
+    },
+    async findCustomerById(id) {
+      return adapter.findOne({
+        model: TABLES.CUSTOMER,
+        where: [{ field: "id", operator: "eq", value: id }]
+      });
+    },
+    async findCustomerByExternalId(externalId) {
+      return adapter.findOne({
+        model: TABLES.CUSTOMER,
+        where: [{ field: "externalId", operator: "eq", value: externalId }]
+      });
+    },
+    async updateCustomer(id, data) {
+      return adapter.update({
+        model: TABLES.CUSTOMER,
+        where: [{ field: "id", operator: "eq", value: id }],
+        update: { ...data, updatedAt: /* @__PURE__ */ new Date() }
+      });
+    },
+    async deleteCustomer(id) {
+      await adapter.delete({
+        model: TABLES.CUSTOMER,
+        where: [{ field: "id", operator: "eq", value: id }]
+      });
+    },
+    async listCustomers(options) {
+      return adapter.findMany({
+        model: TABLES.CUSTOMER,
+        limit: options?.limit,
+        offset: options?.offset,
+        sortBy: { field: "createdAt", direction: "desc" }
+      });
+    },
+    // Plan operations (from config - synchronous)
+    findPlanByCode(code) {
+      return plansByCode.get(code) ?? null;
+    },
+    listPlans(options) {
+      const allPlans = Array.from(plansByCode.values());
+      if (options?.includePrivate) {
+        return allPlans;
+      }
+      return allPlans.filter((p) => p.isPublic);
+    },
+    getPlanPrice(planCode, interval) {
+      const plan = plansByCode.get(planCode);
+      if (!plan) return null;
+      return plan.prices.find((p) => p.interval === interval) ?? plan.prices[0] ?? null;
+    },
+    // Feature operations (from config - synchronous)
+    findFeatureByCode(code) {
+      return featuresByCode.get(code) ?? null;
+    },
+    listFeatures() {
+      return Array.from(featuresByCode.values());
+    },
+    getPlanFeatures(planCode) {
+      const plan = plansByCode.get(planCode);
+      return plan?.features ?? [];
+    },
+    // Subscription operations (DB)
+    async createSubscription(data) {
+      const now = /* @__PURE__ */ new Date();
+      const interval = data.interval ?? "monthly";
+      const currentPeriodEnd = new Date(now);
+      if (interval === "yearly") {
+        currentPeriodEnd.setFullYear(currentPeriodEnd.getFullYear() + 1);
+      } else if (interval === "quarterly") {
+        currentPeriodEnd.setMonth(currentPeriodEnd.getMonth() + 3);
+      } else {
+        currentPeriodEnd.setMonth(currentPeriodEnd.getMonth() + 1);
+      }
+      let trialStart;
+      let trialEnd;
+      let status = data.status ?? "pending_payment";
+      if (data.trialDays && data.trialDays > 0) {
+        trialStart = now;
+        trialEnd = new Date(now);
+        trialEnd.setDate(trialEnd.getDate() + data.trialDays);
+        status = "trialing";
+      }
+      return adapter.create({
+        model: TABLES.SUBSCRIPTION,
+        data: {
+          customerId: data.customerId,
+          planCode: data.planCode,
+          interval,
+          status,
+          providerSubscriptionId: data.providerSubscriptionId,
+          providerCheckoutSessionId: data.providerCheckoutSessionId,
+          currentPeriodStart: now,
+          currentPeriodEnd: trialEnd ?? currentPeriodEnd,
+          trialStart,
+          trialEnd,
+          metadata: data.metadata,
+          createdAt: now,
+          updatedAt: now
+        }
+      });
+    },
+    async findSubscriptionById(id) {
+      return adapter.findOne({
+        model: TABLES.SUBSCRIPTION,
+        where: [{ field: "id", operator: "eq", value: id }]
+      });
+    },
+    async findSubscriptionByCustomerId(customerId) {
+      return adapter.findOne({
+        model: TABLES.SUBSCRIPTION,
+        where: [
+          { field: "customerId", operator: "eq", value: customerId },
+          {
+            field: "status",
+            operator: "in",
+            value: ["active", "trialing", "past_due", "pending_payment"]
+          }
+        ]
+      });
+    },
+    async findSubscriptionByProviderSessionId(sessionId) {
+      return adapter.findOne({
+        model: TABLES.SUBSCRIPTION,
+        where: [
+          {
+            field: "providerCheckoutSessionId",
+            operator: "eq",
+            value: sessionId
+          }
+        ]
+      });
+    },
+    async updateSubscription(id, data) {
+      return adapter.update({
+        model: TABLES.SUBSCRIPTION,
+        where: [{ field: "id", operator: "eq", value: id }],
+        update: { ...data, updatedAt: /* @__PURE__ */ new Date() }
+      });
+    },
+    async cancelSubscription(id, cancelAt) {
+      const now = /* @__PURE__ */ new Date();
+      return adapter.update({
+        model: TABLES.SUBSCRIPTION,
+        where: [{ field: "id", operator: "eq", value: id }],
+        update: {
+          status: cancelAt ? "active" : "canceled",
+          canceledAt: now,
+          cancelAt: cancelAt ?? now,
+          updatedAt: now
+        }
+      });
+    },
+    async listSubscriptions(customerId) {
+      return adapter.findMany({
+        model: TABLES.SUBSCRIPTION,
+        where: [{ field: "customerId", operator: "eq", value: customerId }],
+        sortBy: { field: "createdAt", direction: "desc" }
+      });
+    },
+    // Feature access check
+    async checkFeatureAccess(customerId, featureCode) {
+      const customer = await adapter.findOne({
+        model: TABLES.CUSTOMER,
+        where: [{ field: "externalId", operator: "eq", value: customerId }]
+      });
+      if (!customer) {
+        return { allowed: false };
+      }
+      const subscription = await adapter.findOne({
+        model: TABLES.SUBSCRIPTION,
+        where: [
+          { field: "customerId", operator: "eq", value: customer.id },
+          { field: "status", operator: "in", value: ["active", "trialing"] }
+        ]
+      });
+      if (!subscription) {
+        return { allowed: false };
+      }
+      const planFeatures = this.getPlanFeatures(subscription.planCode);
+      return { allowed: planFeatures.includes(featureCode) };
+    }
+  };
+}
+
+// src/context/create-context.ts
+function createLogger(options) {
+  const level = options?.level ?? "info";
+  const disabled = options?.disabled ?? false;
+  const levels = ["debug", "info", "warn", "error"];
+  const currentLevelIndex = levels.indexOf(level);
+  const shouldLog = (logLevel) => {
+    if (disabled) return false;
+    return levels.indexOf(logLevel) >= currentLevelIndex;
+  };
+  return {
+    debug: (message, ...args) => {
+      if (shouldLog("debug")) console.debug(`[billsdk] ${message}`, ...args);
+    },
+    info: (message, ...args) => {
+      if (shouldLog("info")) console.info(`[billsdk] ${message}`, ...args);
+    },
+    warn: (message, ...args) => {
+      if (shouldLog("warn")) console.warn(`[billsdk] ${message}`, ...args);
+    },
+    error: (message, ...args) => {
+      if (shouldLog("error")) console.error(`[billsdk] ${message}`, ...args);
+    }
+  };
+}
+function resolveOptions(options, adapter) {
+  return {
+    database: adapter,
+    payment: options.payment,
+    basePath: options.basePath ?? "/api/billing",
+    secret: options.secret ?? generateDefaultSecret(),
+    plans: options.plans,
+    features: options.features,
+    plugins: options.plugins ?? [],
+    hooks: options.hooks ?? {},
+    logger: {
+      level: options.logger?.level ?? "info",
+      disabled: options.logger?.disabled ?? false
+    }
+  };
+}
+function generateDefaultSecret() {
+  return "billsdk-development-secret-change-in-production";
+}
+async function createBillingContext(adapter, options) {
+  const resolvedOptions = resolveOptions(options, adapter);
+  const logger = createLogger(options.logger);
+  const plugins = resolvedOptions.plugins;
+  let schema = getBillingSchema();
+  for (const plugin of plugins) {
+    if (plugin.schema) {
+      schema = { ...schema, ...plugin.schema };
+    }
+  }
+  const internalAdapter = createInternalAdapter(
+    adapter,
+    options.plans ?? [],
+    options.features ?? []
+  );
+  const context = {
+    options: resolvedOptions,
+    basePath: resolvedOptions.basePath,
+    adapter,
+    paymentAdapter: options.payment,
+    internalAdapter,
+    schema,
+    plugins,
+    logger,
+    secret: resolvedOptions.secret,
+    hasPlugin(id) {
+      return plugins.some((p) => p.id === id);
+    },
+    getPlugin(id) {
+      const plugin = plugins.find((p) => p.id === id);
+      return plugin ?? null;
+    },
+    generateId() {
+      return crypto.randomUUID();
+    }
+  };
+  for (const plugin of plugins) {
+    if (plugin.init) {
+      await plugin.init(context);
+    }
+  }
+  logger.debug("BillingContext created", {
+    basePath: context.basePath,
+    plugins: plugins.map((p) => p.id),
+    hasPaymentAdapter: !!context.paymentAdapter,
+    plans: options.plans?.length ?? 0,
+    features: options.features?.length ?? 0
+  });
+  return context;
+}
+
+// src/billsdk/base.ts
+var BASE_ERROR_CODES = {
+  CUSTOMER_NOT_FOUND: "CUSTOMER_NOT_FOUND",
+  PLAN_NOT_FOUND: "PLAN_NOT_FOUND",
+  SUBSCRIPTION_NOT_FOUND: "SUBSCRIPTION_NOT_FOUND",
+  FEATURE_NOT_FOUND: "FEATURE_NOT_FOUND",
+  PAYMENT_ADAPTER_NOT_CONFIGURED: "PAYMENT_ADAPTER_NOT_CONFIGURED",
+  INVALID_REQUEST: "INVALID_REQUEST",
+  INTERNAL_ERROR: "INTERNAL_ERROR"
+};
+function createAPI(contextPromise) {
+  return {
+    async getCustomer(params) {
+      const ctx = await contextPromise;
+      return ctx.internalAdapter.findCustomerByExternalId(params.externalId);
+    },
+    async createCustomer(data) {
+      const ctx = await contextPromise;
+      return ctx.internalAdapter.createCustomer(data);
+    },
+    async listPlans() {
+      const ctx = await contextPromise;
+      return ctx.internalAdapter.listPlans();
+    },
+    async getPlan(params) {
+      const ctx = await contextPromise;
+      return ctx.internalAdapter.findPlanByCode(params.code);
+    },
+    async getSubscription(params) {
+      const ctx = await contextPromise;
+      const customer = await ctx.internalAdapter.findCustomerByExternalId(
+        params.customerId
+      );
+      if (!customer) return null;
+      return ctx.internalAdapter.findSubscriptionByCustomerId(customer.id);
+    },
+    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,
+        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 },
+        successUrl: params.successUrl,
+        cancelUrl: params.cancelUrl,
+        metadata: { subscriptionId: subscription.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
+          });
+        }
+        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
+      );
+    },
+    async checkFeature(params) {
+      const ctx = await contextPromise;
+      return ctx.internalAdapter.checkFeatureAccess(
+        params.customerId,
+        params.feature
+      );
+    },
+    async listFeatures(params) {
+      const ctx = await contextPromise;
+      const customer = await ctx.internalAdapter.findCustomerByExternalId(
+        params.customerId
+      );
+      if (!customer) return [];
+      const subscription = await ctx.internalAdapter.findSubscriptionByCustomerId(customer.id);
+      if (!subscription) return [];
+      const featureCodes = ctx.internalAdapter.getPlanFeatures(
+        subscription.planCode
+      );
+      return featureCodes.map((code) => {
+        const feature = ctx.internalAdapter.findFeatureByCode(code);
+        return feature ? {
+          code: feature.code,
+          name: feature.name,
+          enabled: true
+        } : { code, name: code, enabled: true };
+      });
+    },
+    async health() {
+      return {
+        status: "ok",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  };
+}
+async function init(options) {
+  const database = options.database ?? memoryAdapter();
+  const payment = options.payment ?? paymentAdapter();
+  return createBillingContext(database, { ...options, payment });
+}
+function createBillSDK(options) {
+  const contextPromise = init(options);
+  const errorCodes = {};
+  for (const plugin of options.plugins ?? []) {
+    if (plugin.$ERROR_CODES) {
+      Object.assign(errorCodes, plugin.$ERROR_CODES);
+    }
+  }
+  const handler = async (request) => {
+    const ctx = await contextPromise;
+    const { handler: routeHandler } = createRouter(ctx);
+    return routeHandler(request);
+  };
+  const api = createAPI(contextPromise);
+  return {
+    handler,
+    api,
+    options,
+    $context: contextPromise,
+    $Infer: {},
+    $ERROR_CODES: {
+      ...BASE_ERROR_CODES,
+      ...errorCodes
+    }
+  };
+}
+function billsdk(options) {
+  return createBillSDK(options);
+}
+
+export { billsdk };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map