paykitjs 0.0.1

package/dist/customer/customer.api.js

@@ -0,0 +1,47 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "../core/errors.js";
+import { getCustomerWithDetails, getProviderCustomerIdForCustomer, hardDeleteCustomer, listCustomers, syncCustomerWithDefaults } from "./customer.service.js";
+import { definePayKitMethod, returnUrl } from "../api/define-route.js";
+import * as z from "zod";
+//#region src/customer/customer.api.ts
+const upsertCustomerSchema = z.object({
+	id: z.string(),
+	email: z.string().optional(),
+	name: z.string().optional(),
+	metadata: z.record(z.string(), z.string()).optional()
+});
+const customerIdSchema = z.object({ id: z.string() });
+const listCustomersSchema = z.object({
+	limit: z.number().int().positive().optional(),
+	offset: z.number().int().min(0).optional(),
+	planIds: z.array(z.string()).optional()
+}).optional();
+const upsertCustomer = definePayKitMethod({ input: upsertCustomerSchema }, async (ctx) => syncCustomerWithDefaults(ctx.paykit, ctx.input));
+const getCustomer = definePayKitMethod({ input: customerIdSchema }, async (ctx) => getCustomerWithDetails(ctx.paykit, ctx.input.id));
+const deleteCustomer = definePayKitMethod({ input: customerIdSchema }, async (ctx) => {
+	await hardDeleteCustomer(ctx.paykit, ctx.input.id);
+	return { success: true };
+});
+const listCustomersMethod = definePayKitMethod({ input: listCustomersSchema }, async (ctx) => listCustomers(ctx.paykit, ctx.input));
+/** Opens the provider customer portal for the resolved customer. */
+const customerPortal = definePayKitMethod({
+	input: z.object({ returnUrl: returnUrl() }),
+	requireCustomer: true,
+	route: {
+		client: true,
+		method: "POST",
+		path: "/customer-portal"
+	}
+}, async (ctx) => {
+	const providerCustomerId = await getProviderCustomerIdForCustomer(ctx.paykit.database, {
+		customerId: ctx.customer.id,
+		providerId: ctx.paykit.provider.id
+	});
+	if (!providerCustomerId) throw PayKitError.from("NOT_FOUND", PAYKIT_ERROR_CODES.PROVIDER_CUSTOMER_NOT_FOUND);
+	const { url } = await ctx.paykit.stripe.createPortalSession({
+		providerCustomerId,
+		returnUrl: ctx.input.returnUrl
+	});
+	return { url };
+});
+//#endregion
+export { customerPortal, deleteCustomer, getCustomer, listCustomersMethod, upsertCustomer };

package/dist/customer/customer.service.js

@@ -0,0 +1,342 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "../core/errors.js";
+import { customer, entitlement, invoice, paymentMethod, product, subscription } from "../database/schema.js";
+import { getLatestProduct } from "../product/product.service.js";
+import { getActiveSubscriptionInGroup, getCurrentSubscriptions, getScheduledSubscriptionsInGroup, insertSubscriptionRecord } from "../subscription/subscription.service.js";
+import { and, count, countDistinct, desc, eq, inArray, isNull, or, sql } from "drizzle-orm";
+//#region src/customer/customer.service.ts
+async function syncCustomer(database, input) {
+	const now = /* @__PURE__ */ new Date();
+	const existing = await database.query.customer.findFirst({ where: eq(customer.id, input.id) });
+	if (existing) {
+		const row = (await database.update(customer).set({
+			email: input.email ?? existing.email ?? null,
+			name: input.name ?? existing.name ?? null,
+			metadata: input.metadata ?? existing.metadata ?? null,
+			deletedAt: null,
+			updatedAt: now
+		}).where(eq(customer.id, existing.id)).returning())[0];
+		if (!row) throw PayKitError.from("INTERNAL_SERVER_ERROR", PAYKIT_ERROR_CODES.CUSTOMER_UPDATE_FAILED);
+		return row;
+	}
+	const row = (await database.insert(customer).values({
+		id: input.id,
+		email: input.email ?? null,
+		name: input.name ?? null,
+		metadata: input.metadata ?? null,
+		deletedAt: null
+	}).returning())[0];
+	if (!row) throw PayKitError.from("INTERNAL_SERVER_ERROR", PAYKIT_ERROR_CODES.CUSTOMER_CREATE_FAILED);
+	return row;
+}
+async function ensureDefaultPlansForCustomer(ctx, customerId) {
+	const defaultPlans = ctx.plans.plans.filter((plan) => plan.isDefault);
+	if (defaultPlans.length === 0) return;
+	for (const defaultPlan of defaultPlans) {
+		if (!defaultPlan.group) continue;
+		if (await getActiveSubscriptionInGroup(ctx.database, {
+			customerId,
+			group: defaultPlan.group
+		})) continue;
+		if ((await getScheduledSubscriptionsInGroup(ctx.database, {
+			customerId,
+			group: defaultPlan.group
+		})).length > 0) continue;
+		const storedPlan = await getLatestProduct(ctx.database, defaultPlan.id);
+		if (!storedPlan) continue;
+		if (storedPlan.priceAmount !== null) {
+			ctx.logger.warn({
+				planId: defaultPlan.id,
+				customerId
+			}, "skipping default plan: paid default plans are not auto-attached yet");
+			continue;
+		}
+		await insertSubscriptionRecord(ctx.database, {
+			customerId,
+			planFeatures: defaultPlan.includes,
+			productInternalId: storedPlan.internalId,
+			startedAt: /* @__PURE__ */ new Date(),
+			status: "active"
+		});
+	}
+}
+async function syncCustomerWithDefaults(ctx, input) {
+	const syncedCustomer = await syncCustomer(ctx.database, input);
+	await ensureDefaultPlansForCustomer(ctx, syncedCustomer.id);
+	const providerCustomer = await ensureTestingProviderCustomer(ctx, syncedCustomer.id);
+	if (!providerCustomer) return syncedCustomer;
+	return {
+		...syncedCustomer,
+		provider: {
+			...syncedCustomer.provider ?? {},
+			[ctx.provider.id]: providerCustomer
+		}
+	};
+}
+async function applyCustomerWebhookAction(database, action) {
+	if (action.type === "customer.upsert") {
+		await syncCustomer(database, action.data);
+		return action.data.id;
+	}
+	await deleteCustomerFromDatabase(database, action.data.id);
+	return action.data.id;
+}
+async function getCustomerById(database, customerId) {
+	return await database.query.customer.findFirst({ where: and(eq(customer.id, customerId), isNull(customer.deletedAt)) }) ?? null;
+}
+async function getCustomerByIdOrThrow(database, customerId) {
+	const existingCustomer = await getCustomerById(database, customerId);
+	if (!existingCustomer) throw PayKitError.from("NOT_FOUND", PAYKIT_ERROR_CODES.CUSTOMER_NOT_FOUND);
+	return existingCustomer;
+}
+async function getCustomerWithDetails(ctx, customerId) {
+	const customerRow = await getCustomerById(ctx.database, customerId);
+	if (!customerRow) return null;
+	const subRows = await ctx.database.select({
+		planGroup: product.group,
+		planId: product.id,
+		status: subscription.status,
+		cancelAtPeriodEnd: subscription.cancelAtPeriodEnd,
+		currentPeriodStart: subscription.currentPeriodStartAt,
+		currentPeriodEnd: subscription.currentPeriodEndAt
+	}).from(subscription).innerJoin(product, eq(product.internalId, subscription.productInternalId)).where(and(eq(subscription.customerId, customerId), inArray(subscription.status, [
+		"active",
+		"trialing",
+		"past_due",
+		"scheduled"
+	]), or(isNull(subscription.endedAt), sql`${subscription.endedAt} > now()`))).orderBy(desc(subscription.createdAt));
+	const subscriptionsByGroup = /* @__PURE__ */ new Map();
+	for (const row of subRows) {
+		const currentGroup = subscriptionsByGroup.get(row.planGroup) ?? [];
+		currentGroup.push(row.planId);
+		subscriptionsByGroup.set(row.planGroup, currentGroup);
+	}
+	for (const [group, planIds] of subscriptionsByGroup) {
+		if (planIds.length < 2) continue;
+		ctx.logger.warn({
+			customerId,
+			group,
+			planIds
+		}, "multiple active subscriptions detected while reading customer details");
+	}
+	const entRows = await ctx.database.select({
+		featureId: entitlement.featureId,
+		balance: entitlement.balance,
+		limit: entitlement.limit,
+		nextResetAt: entitlement.nextResetAt
+	}).from(entitlement).innerJoin(subscription, eq(subscription.id, entitlement.subscriptionId)).where(and(eq(entitlement.customerId, customerId), inArray(subscription.status, [
+		"active",
+		"trialing",
+		"past_due"
+	]), or(isNull(subscription.endedAt), sql`${subscription.endedAt} > now()`)));
+	const entitlements = {};
+	for (const row of entRows) {
+		const isUnlimited = row.limit === null;
+		entitlements[row.featureId] = {
+			featureId: row.featureId,
+			balance: row.balance ?? 0,
+			limit: row.limit ?? 0,
+			usage: isUnlimited ? 0 : (row.limit ?? 0) - (row.balance ?? 0),
+			unlimited: isUnlimited,
+			nextResetAt: row.nextResetAt
+		};
+	}
+	return {
+		...customerRow,
+		subscriptions: subRows.map((row) => ({
+			planId: row.planId,
+			status: row.status,
+			cancelAtPeriodEnd: row.cancelAtPeriodEnd,
+			currentPeriodStart: row.currentPeriodStart,
+			currentPeriodEnd: row.currentPeriodEnd
+		})),
+		entitlements
+	};
+}
+function getProviderCustomer(customerRow, providerId) {
+	return (customerRow.provider ?? {})[providerId] ?? null;
+}
+async function setProviderCustomer(database, input) {
+	const providerMap = (await getCustomerByIdOrThrow(database, input.customerId)).provider ?? {};
+	providerMap[input.providerId] = input.providerCustomer;
+	await database.update(customer).set({
+		provider: providerMap,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(customer.id, input.customerId));
+}
+function getProviderCustomerId(customerRow, providerId) {
+	return getProviderCustomer(customerRow, providerId)?.id ?? null;
+}
+async function getProviderCustomerIdForCustomer(database, input) {
+	const row = await database.query.customer.findFirst({ where: eq(customer.id, input.customerId) });
+	if (!row) return null;
+	return getProviderCustomerId(row, input.providerId);
+}
+async function findCustomerByProviderCustomerId(database, input) {
+	return await database.query.customer.findFirst({ where: sql`${customer.provider}->${input.providerId}->>'id' = ${input.providerCustomerId}` }) ?? null;
+}
+async function upsertProviderCustomer(ctx, input) {
+	const providerId = ctx.provider.id;
+	const existingCustomer = await getCustomerByIdOrThrow(ctx.database, input.customerId);
+	const existingProviderCustomer = getProviderCustomer(existingCustomer, providerId);
+	const existingProviderCustomerId = existingProviderCustomer?.id ?? null;
+	if (existingProviderCustomerId) return {
+		customerId: input.customerId,
+		providerCustomer: existingProviderCustomer,
+		providerCustomerId: existingProviderCustomerId
+	};
+	const { providerCustomer } = await ctx.stripe.upsertCustomer({
+		createTestClock: ctx.options.testing?.enabled === true,
+		id: existingCustomer.id,
+		email: existingCustomer.email ?? void 0,
+		name: existingCustomer.name ?? void 0,
+		metadata: existingCustomer.metadata ?? void 0
+	});
+	const providerCustomerId = providerCustomer.id;
+	await setProviderCustomer(ctx.database, {
+		customerId: input.customerId,
+		providerCustomer,
+		providerId
+	});
+	return {
+		customerId: input.customerId,
+		providerCustomer,
+		providerCustomerId
+	};
+}
+async function ensureTestingProviderCustomer(ctx, customerId) {
+	if (ctx.options.testing?.enabled !== true) return null;
+	const { providerCustomer } = await upsertProviderCustomer(ctx, { customerId });
+	return providerCustomer;
+}
+async function deleteCustomerFromDatabase(database, customerId) {
+	const sIds = (await database.select({ id: subscription.id }).from(subscription).where(eq(subscription.customerId, customerId))).map((row) => row.id);
+	if (sIds.length > 0) await database.delete(entitlement).where(inArray(entitlement.subscriptionId, sIds));
+	await database.delete(subscription).where(eq(subscription.customerId, customerId));
+	await database.delete(invoice).where(eq(invoice.customerId, customerId));
+	await database.delete(paymentMethod).where(eq(paymentMethod.customerId, customerId));
+	await database.delete(customer).where(eq(customer.id, customerId));
+}
+async function hardDeleteCustomer(ctx, customerId) {
+	const providerCustomerId = getProviderCustomerId(await getCustomerByIdOrThrow(ctx.database, customerId), ctx.provider.id);
+	if (providerCustomerId) try {
+		const activeSubscriptions = await ctx.stripe.listActiveSubscriptions({ providerCustomerId });
+		for (const sub of activeSubscriptions) await ctx.stripe.cancelSubscription({ providerSubscriptionId: sub.providerSubscriptionId });
+		await ctx.stripe.deleteCustomer({ providerCustomerId });
+	} catch (error) {
+		ctx.logger.error({
+			providerCustomerId,
+			err: error
+		}, "failed to clean up Stripe customer");
+	}
+	await deleteCustomerFromDatabase(ctx.database, customerId);
+}
+async function emitCustomerUpdated(ctx, customerId) {
+	const payload = {
+		customerId,
+		subscriptions: await getCurrentSubscriptions(ctx.database, customerId)
+	};
+	try {
+		await ctx.options.on?.["customer.updated"]?.({
+			name: "customer.updated",
+			payload
+		});
+		await ctx.options.on?.["*"]?.({ event: {
+			name: "customer.updated",
+			payload
+		} });
+	} catch (error) {
+		ctx.logger.error({ err: error }, "error in customer.updated event handler");
+	}
+}
+async function listCustomers(ctx, input) {
+	const limit = input?.limit ?? 50;
+	const offset = input?.offset ?? 0;
+	const planIds = input?.planIds;
+	let customerRows;
+	let total;
+	if (planIds && planIds.length > 0) {
+		const planFilter = and(inArray(product.id, planIds), inArray(subscription.status, [
+			"active",
+			"trialing",
+			"past_due"
+		]), or(isNull(subscription.endedAt), sql`${subscription.endedAt} > now()`), isNull(customer.deletedAt));
+		customerRows = (await ctx.database.selectDistinct({ customer }).from(customer).innerJoin(subscription, eq(subscription.customerId, customer.id)).innerJoin(product, eq(product.internalId, subscription.productInternalId)).where(planFilter).orderBy(desc(customer.createdAt)).limit(limit).offset(offset)).map((r) => r.customer);
+		total = (await ctx.database.select({ count: countDistinct(customer.id) }).from(customer).innerJoin(subscription, eq(subscription.customerId, customer.id)).innerJoin(product, eq(product.internalId, subscription.productInternalId)).where(planFilter))[0]?.count ?? 0;
+	} else {
+		total = (await ctx.database.select({ count: count() }).from(customer).where(isNull(customer.deletedAt)))[0]?.count ?? 0;
+		customerRows = await ctx.database.query.customer.findMany({
+			where: isNull(customer.deletedAt),
+			orderBy: (c, { desc }) => [desc(c.createdAt)],
+			limit,
+			offset
+		});
+	}
+	const customerIds = customerRows.map((c) => c.id);
+	const data = [];
+	if (customerIds.length > 0) {
+		const subRows = await ctx.database.select({
+			customerId: subscription.customerId,
+			planId: product.id,
+			status: subscription.status,
+			cancelAtPeriodEnd: subscription.cancelAtPeriodEnd,
+			currentPeriodStart: subscription.currentPeriodStartAt,
+			currentPeriodEnd: subscription.currentPeriodEndAt
+		}).from(subscription).innerJoin(product, eq(product.internalId, subscription.productInternalId)).where(and(inArray(subscription.customerId, customerIds), inArray(subscription.status, [
+			"active",
+			"trialing",
+			"past_due",
+			"scheduled"
+		]), or(isNull(subscription.endedAt), sql`${subscription.endedAt} > now()`))).orderBy(desc(subscription.createdAt));
+		const entRows = await ctx.database.select({
+			customerId: entitlement.customerId,
+			featureId: entitlement.featureId,
+			balance: entitlement.balance,
+			limit: entitlement.limit,
+			nextResetAt: entitlement.nextResetAt
+		}).from(entitlement).innerJoin(subscription, eq(subscription.id, entitlement.subscriptionId)).where(and(inArray(entitlement.customerId, customerIds), inArray(subscription.status, [
+			"active",
+			"trialing",
+			"past_due"
+		]), or(isNull(subscription.endedAt), sql`${subscription.endedAt} > now()`)));
+		const subscriptionsByCustomer = /* @__PURE__ */ new Map();
+		for (const row of subRows) {
+			const list = subscriptionsByCustomer.get(row.customerId) ?? [];
+			list.push({
+				planId: row.planId,
+				status: row.status,
+				cancelAtPeriodEnd: row.cancelAtPeriodEnd,
+				currentPeriodStart: row.currentPeriodStart,
+				currentPeriodEnd: row.currentPeriodEnd
+			});
+			subscriptionsByCustomer.set(row.customerId, list);
+		}
+		const entitlementsByCustomer = /* @__PURE__ */ new Map();
+		for (const row of entRows) {
+			const map = entitlementsByCustomer.get(row.customerId) ?? {};
+			const isUnlimited = row.limit === null;
+			map[row.featureId] = {
+				featureId: row.featureId,
+				balance: row.balance ?? 0,
+				limit: row.limit ?? 0,
+				usage: isUnlimited ? 0 : (row.limit ?? 0) - (row.balance ?? 0),
+				unlimited: isUnlimited,
+				nextResetAt: row.nextResetAt
+			};
+			entitlementsByCustomer.set(row.customerId, map);
+		}
+		for (const c of customerRows) data.push({
+			...c,
+			subscriptions: subscriptionsByCustomer.get(c.id) ?? [],
+			entitlements: entitlementsByCustomer.get(c.id) ?? {}
+		});
+	}
+	return {
+		data,
+		total,
+		hasMore: offset + limit < total,
+		limit,
+		offset
+	};
+}
+//#endregion
+export { applyCustomerWebhookAction, emitCustomerUpdated, findCustomerByProviderCustomerId, getCustomerByIdOrThrow, getCustomerWithDetails, getProviderCustomer, getProviderCustomerIdForCustomer, hardDeleteCustomer, listCustomers, setProviderCustomer, syncCustomerWithDefaults, upsertProviderCustomer };

package/dist/customer/customer.types.d.ts

@@ -0,0 +1,31 @@
+import { Customer } from "../types/models.js";
+
+//#region src/customer/customer.types.d.ts
+interface CustomerSubscription {
+  planId: string;
+  status: string;
+  cancelAtPeriodEnd: boolean;
+  currentPeriodStart: Date | null;
+  currentPeriodEnd: Date | null;
+}
+interface CustomerEntitlement {
+  featureId: string;
+  balance: number;
+  limit: number;
+  usage: number;
+  unlimited: boolean;
+  nextResetAt: Date | null;
+}
+interface CustomerWithDetails extends Customer {
+  subscriptions: CustomerSubscription[];
+  entitlements: Record<string, CustomerEntitlement>;
+}
+interface ListCustomersResult {
+  data: CustomerWithDetails[];
+  total: number;
+  hasMore: boolean;
+  limit: number;
+  offset: number;
+}
+//#endregion
+export { CustomerEntitlement, CustomerSubscription, CustomerWithDetails, ListCustomersResult };

package/dist/database/index.d.ts

@@ -0,0 +1,8 @@
+import { schema_d_exports } from "./schema.js";
+import { Pool } from "pg";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+
+//#region src/database/index.d.ts
+type PayKitDatabase = NodePgDatabase<typeof schema_d_exports>;
+//#endregion
+export { PayKitDatabase };

package/dist/database/index.js

@@ -0,0 +1,32 @@
+import { schema_exports } from "./schema.js";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { migrate } from "drizzle-orm/node-postgres/migrator";
+//#region src/database/index.ts
+const migrationsSchema = "public";
+const migrationsTable = "paykit_migrations";
+const migrationsFolder = path.join(path.dirname(fileURLToPath(import.meta.url)), "migrations");
+async function createDatabase(database) {
+	return drizzle(database, { schema: schema_exports });
+}
+async function migrateDatabase(database) {
+	await migrate(drizzle(database, { schema: schema_exports }), {
+		migrationsFolder,
+		migrationsSchema,
+		migrationsTable
+	});
+}
+async function getPendingMigrationCount(database) {
+	const journalPath = path.join(migrationsFolder, "meta", "_journal.json");
+	const totalMigrations = JSON.parse(fs.readFileSync(journalPath, "utf-8")).entries.length;
+	try {
+		const appliedCount = (await database.query(`SELECT count(*)::int AS count FROM ${migrationsSchema}.${migrationsTable}`)).rows[0]?.count ?? 0;
+		return Math.max(0, totalMigrations - appliedCount);
+	} catch {
+		return totalMigrations;
+	}
+}
+//#endregion
+export { createDatabase, getPendingMigrationCount, migrateDatabase };

package/dist/database/migrations/0000_init.sql

@@ -0,0 +1,157 @@
+CREATE TABLE "paykit_customer" (
+	"id" text PRIMARY KEY NOT NULL,
+	"email" text,
+	"name" text,
+	"metadata" jsonb,
+	"provider" jsonb DEFAULT '{}'::jsonb NOT NULL,
+	"deleted_at" timestamp,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_entitlement" (
+	"id" text PRIMARY KEY NOT NULL,
+	"subscription_id" text,
+	"customer_id" text NOT NULL,
+	"feature_id" text NOT NULL,
+	"limit" integer,
+	"balance" integer,
+	"next_reset_at" timestamp,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_feature" (
+	"id" text PRIMARY KEY NOT NULL,
+	"type" text NOT NULL,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_invoice" (
+	"id" text PRIMARY KEY NOT NULL,
+	"customer_id" text NOT NULL,
+	"subscription_id" text,
+	"type" text NOT NULL,
+	"status" text NOT NULL,
+	"amount" integer NOT NULL,
+	"currency" text NOT NULL,
+	"description" text,
+	"hosted_url" text,
+	"provider_id" text NOT NULL,
+	"provider_data" jsonb NOT NULL,
+	"period_start_at" timestamp,
+	"period_end_at" timestamp,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_metadata" (
+	"id" text PRIMARY KEY NOT NULL,
+	"provider_id" text NOT NULL,
+	"type" text NOT NULL,
+	"data" jsonb NOT NULL,
+	"provider_checkout_session_id" text,
+	"expires_at" timestamp,
+	"created_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_payment_method" (
+	"id" text PRIMARY KEY NOT NULL,
+	"customer_id" text NOT NULL,
+	"provider_id" text NOT NULL,
+	"provider_data" jsonb NOT NULL,
+	"is_default" boolean DEFAULT false NOT NULL,
+	"deleted_at" timestamp,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_product" (
+	"internal_id" text PRIMARY KEY NOT NULL,
+	"id" text NOT NULL,
+	"version" integer DEFAULT 1 NOT NULL,
+	"name" text NOT NULL,
+	"group" text DEFAULT '' NOT NULL,
+	"is_default" boolean DEFAULT false NOT NULL,
+	"price_amount" integer,
+	"price_interval" text,
+	"hash" text,
+	"provider" jsonb DEFAULT '{}'::jsonb NOT NULL,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_product_feature" (
+	"product_internal_id" text NOT NULL,
+	"feature_id" text NOT NULL,
+	"limit" integer,
+	"reset_interval" text,
+	"config" jsonb,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL,
+	CONSTRAINT "paykit_product_feature_product_internal_id_feature_id_pk" PRIMARY KEY("product_internal_id","feature_id")
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_subscription" (
+	"id" text PRIMARY KEY NOT NULL,
+	"customer_id" text NOT NULL,
+	"product_internal_id" text NOT NULL,
+	"provider_id" text,
+	"provider_data" jsonb,
+	"status" text NOT NULL,
+	"canceled" boolean DEFAULT false NOT NULL,
+	"cancel_at_period_end" boolean DEFAULT false NOT NULL,
+	"started_at" timestamp,
+	"trial_ends_at" timestamp,
+	"current_period_start_at" timestamp,
+	"current_period_end_at" timestamp,
+	"canceled_at" timestamp,
+	"ended_at" timestamp,
+	"scheduled_product_id" text,
+	"quantity" integer DEFAULT 1 NOT NULL,
+	"created_at" timestamp NOT NULL,
+	"updated_at" timestamp NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "paykit_webhook_event" (
+	"id" text PRIMARY KEY NOT NULL,
+	"provider_id" text NOT NULL,
+	"provider_event_id" text NOT NULL,
+	"type" text NOT NULL,
+	"payload" jsonb NOT NULL,
+	"status" text NOT NULL,
+	"error" text,
+	"trace_id" text,
+	"received_at" timestamp NOT NULL,
+	"processed_at" timestamp
+);
+--> statement-breakpoint
+ALTER TABLE "paykit_entitlement" ADD CONSTRAINT "paykit_entitlement_subscription_id_paykit_subscription_id_fk" FOREIGN KEY ("subscription_id") REFERENCES "public"."paykit_subscription"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_entitlement" ADD CONSTRAINT "paykit_entitlement_customer_id_paykit_customer_id_fk" FOREIGN KEY ("customer_id") REFERENCES "public"."paykit_customer"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_entitlement" ADD CONSTRAINT "paykit_entitlement_feature_id_paykit_feature_id_fk" FOREIGN KEY ("feature_id") REFERENCES "public"."paykit_feature"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_invoice" ADD CONSTRAINT "paykit_invoice_customer_id_paykit_customer_id_fk" FOREIGN KEY ("customer_id") REFERENCES "public"."paykit_customer"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_invoice" ADD CONSTRAINT "paykit_invoice_subscription_id_paykit_subscription_id_fk" FOREIGN KEY ("subscription_id") REFERENCES "public"."paykit_subscription"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_payment_method" ADD CONSTRAINT "paykit_payment_method_customer_id_paykit_customer_id_fk" FOREIGN KEY ("customer_id") REFERENCES "public"."paykit_customer"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_product_feature" ADD CONSTRAINT "paykit_product_feature_product_internal_id_paykit_product_internal_id_fk" FOREIGN KEY ("product_internal_id") REFERENCES "public"."paykit_product"("internal_id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_product_feature" ADD CONSTRAINT "paykit_product_feature_feature_id_paykit_feature_id_fk" FOREIGN KEY ("feature_id") REFERENCES "public"."paykit_feature"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_subscription" ADD CONSTRAINT "paykit_subscription_customer_id_paykit_customer_id_fk" FOREIGN KEY ("customer_id") REFERENCES "public"."paykit_customer"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "paykit_subscription" ADD CONSTRAINT "paykit_subscription_product_internal_id_paykit_product_internal_id_fk" FOREIGN KEY ("product_internal_id") REFERENCES "public"."paykit_product"("internal_id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
+CREATE INDEX "paykit_customer_deleted_at_idx" ON "paykit_customer" USING btree ("deleted_at");--> statement-breakpoint
+CREATE INDEX "paykit_entitlement_subscription_idx" ON "paykit_entitlement" USING btree ("subscription_id");--> statement-breakpoint
+CREATE INDEX "paykit_entitlement_customer_feature_idx" ON "paykit_entitlement" USING btree ("customer_id","feature_id");--> statement-breakpoint
+CREATE INDEX "paykit_entitlement_next_reset_idx" ON "paykit_entitlement" USING btree ("next_reset_at");--> statement-breakpoint
+CREATE INDEX "paykit_invoice_customer_idx" ON "paykit_invoice" USING btree ("customer_id","created_at");--> statement-breakpoint
+CREATE INDEX "paykit_invoice_subscription_idx" ON "paykit_invoice" USING btree ("subscription_id");--> statement-breakpoint
+CREATE INDEX "paykit_invoice_provider_idx" ON "paykit_invoice" USING btree ("provider_id");--> statement-breakpoint
+CREATE UNIQUE INDEX "paykit_metadata_checkout_session_unique" ON "paykit_metadata" USING btree ("provider_id","provider_checkout_session_id");--> statement-breakpoint
+CREATE INDEX "paykit_payment_method_customer_idx" ON "paykit_payment_method" USING btree ("customer_id","deleted_at");--> statement-breakpoint
+CREATE INDEX "paykit_payment_method_provider_idx" ON "paykit_payment_method" USING btree ("provider_id");--> statement-breakpoint
+CREATE UNIQUE INDEX "paykit_product_id_version_unique" ON "paykit_product" USING btree ("id","version");--> statement-breakpoint
+CREATE INDEX "paykit_product_default_idx" ON "paykit_product" USING btree ("is_default");--> statement-breakpoint
+CREATE INDEX "paykit_product_feature_feature_idx" ON "paykit_product_feature" USING btree ("feature_id");--> statement-breakpoint
+CREATE INDEX "paykit_subscription_customer_status_idx" ON "paykit_subscription" USING btree ("customer_id","status","ended_at");--> statement-breakpoint
+CREATE INDEX "paykit_subscription_product_idx" ON "paykit_subscription" USING btree ("product_internal_id");--> statement-breakpoint
+CREATE INDEX "paykit_subscription_provider_idx" ON "paykit_subscription" USING btree ("provider_id");--> statement-breakpoint
+CREATE UNIQUE INDEX "paykit_webhook_event_provider_unique" ON "paykit_webhook_event" USING btree ("provider_id","provider_event_id");--> statement-breakpoint
+CREATE INDEX "paykit_webhook_event_status_idx" ON "paykit_webhook_event" USING btree ("provider_id","status");