paykitjs 0.1.0-alpha.2

package/dist/database/schema.js

@@ -0,0 +1,150 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { boolean, index, integer, jsonb, pgTableCreator, primaryKey, text, timestamp, uniqueIndex } from "drizzle-orm/pg-core";
+//#region src/database/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	customer: () => customer,
+	entitlement: () => entitlement,
+	feature: () => feature,
+	invoice: () => invoice,
+	metadata: () => metadata,
+	paymentMethod: () => paymentMethod,
+	product: () => product,
+	productFeature: () => productFeature,
+	subscription: () => subscription,
+	webhookEvent: () => webhookEvent
+});
+const pgTable = pgTableCreator((name) => `paykit_${name}`);
+const createdAt = timestamp("created_at").notNull().$defaultFn(() => /* @__PURE__ */ new Date());
+const updatedAt = timestamp("updated_at").notNull().$defaultFn(() => /* @__PURE__ */ new Date()).$onUpdateFn(() => /* @__PURE__ */ new Date());
+const customer = pgTable("customer", {
+	id: text("id").primaryKey(),
+	email: text("email"),
+	name: text("name"),
+	metadata: jsonb("metadata").$type(),
+	provider: jsonb("provider").$type().notNull().default({}),
+	deletedAt: timestamp("deleted_at"),
+	createdAt,
+	updatedAt
+}, (table) => [index("paykit_customer_deleted_at_idx").on(table.deletedAt)]);
+const paymentMethod = pgTable("payment_method", {
+	id: text("id").primaryKey(),
+	customerId: text("customer_id").notNull().references(() => customer.id),
+	providerId: text("provider_id").notNull(),
+	providerData: jsonb("provider_data").$type().notNull(),
+	isDefault: boolean("is_default").notNull().default(false),
+	deletedAt: timestamp("deleted_at"),
+	createdAt,
+	updatedAt
+}, (table) => [index("paykit_payment_method_customer_idx").on(table.customerId, table.deletedAt), index("paykit_payment_method_provider_idx").on(table.providerId)]);
+const feature = pgTable("feature", {
+	id: text("id").primaryKey(),
+	type: text("type").notNull(),
+	createdAt,
+	updatedAt
+});
+const product = pgTable("product", {
+	internalId: text("internal_id").primaryKey(),
+	id: text("id").notNull(),
+	version: integer("version").notNull().default(1),
+	name: text("name").notNull(),
+	group: text("group").notNull().default(""),
+	isDefault: boolean("is_default").notNull().default(false),
+	priceAmount: integer("price_amount"),
+	priceInterval: text("price_interval"),
+	hash: text("hash"),
+	provider: jsonb("provider").$type().notNull().default({}),
+	createdAt,
+	updatedAt
+}, (table) => [uniqueIndex("paykit_product_id_version_unique").on(table.id, table.version), index("paykit_product_default_idx").on(table.isDefault)]);
+const productFeature = pgTable("product_feature", {
+	productInternalId: text("product_internal_id").notNull().references(() => product.internalId),
+	featureId: text("feature_id").notNull().references(() => feature.id),
+	limit: integer("limit"),
+	resetInterval: text("reset_interval"),
+	config: jsonb("config").$type(),
+	createdAt,
+	updatedAt
+}, (table) => [primaryKey({ columns: [table.productInternalId, table.featureId] }), index("paykit_product_feature_feature_idx").on(table.featureId)]);
+const subscription = pgTable("subscription", {
+	id: text("id").primaryKey(),
+	customerId: text("customer_id").notNull().references(() => customer.id),
+	productInternalId: text("product_internal_id").notNull().references(() => product.internalId),
+	providerId: text("provider_id"),
+	providerData: jsonb("provider_data").$type(),
+	status: text("status").notNull(),
+	canceled: boolean("canceled").notNull().default(false),
+	cancelAtPeriodEnd: boolean("cancel_at_period_end").notNull().default(false),
+	startedAt: timestamp("started_at"),
+	trialEndsAt: timestamp("trial_ends_at"),
+	currentPeriodStartAt: timestamp("current_period_start_at"),
+	currentPeriodEndAt: timestamp("current_period_end_at"),
+	canceledAt: timestamp("canceled_at"),
+	endedAt: timestamp("ended_at"),
+	scheduledProductId: text("scheduled_product_id"),
+	quantity: integer("quantity").notNull().default(1),
+	createdAt,
+	updatedAt
+}, (table) => [
+	index("paykit_subscription_customer_status_idx").on(table.customerId, table.status, table.endedAt),
+	index("paykit_subscription_product_idx").on(table.productInternalId),
+	index("paykit_subscription_provider_idx").on(table.providerId)
+]);
+const entitlement = pgTable("entitlement", {
+	id: text("id").primaryKey(),
+	subscriptionId: text("subscription_id").references(() => subscription.id),
+	customerId: text("customer_id").notNull().references(() => customer.id),
+	featureId: text("feature_id").notNull().references(() => feature.id),
+	limit: integer("limit"),
+	balance: integer("balance"),
+	nextResetAt: timestamp("next_reset_at"),
+	createdAt,
+	updatedAt
+}, (table) => [
+	index("paykit_entitlement_subscription_idx").on(table.subscriptionId),
+	index("paykit_entitlement_customer_feature_idx").on(table.customerId, table.featureId),
+	index("paykit_entitlement_next_reset_idx").on(table.nextResetAt)
+]);
+const invoice = pgTable("invoice", {
+	id: text("id").primaryKey(),
+	customerId: text("customer_id").notNull().references(() => customer.id),
+	subscriptionId: text("subscription_id").references(() => subscription.id),
+	type: text("type").notNull(),
+	status: text("status").notNull(),
+	amount: integer("amount").notNull(),
+	currency: text("currency").notNull(),
+	description: text("description"),
+	hostedUrl: text("hosted_url"),
+	providerId: text("provider_id").notNull(),
+	providerData: jsonb("provider_data").$type().notNull(),
+	periodStartAt: timestamp("period_start_at"),
+	periodEndAt: timestamp("period_end_at"),
+	createdAt,
+	updatedAt
+}, (table) => [
+	index("paykit_invoice_customer_idx").on(table.customerId, table.createdAt),
+	index("paykit_invoice_subscription_idx").on(table.subscriptionId),
+	index("paykit_invoice_provider_idx").on(table.providerId)
+]);
+const metadata = pgTable("metadata", {
+	id: text("id").primaryKey(),
+	providerId: text("provider_id").notNull(),
+	type: text("type").notNull(),
+	data: jsonb("data").$type().notNull(),
+	providerCheckoutSessionId: text("provider_checkout_session_id"),
+	expiresAt: timestamp("expires_at"),
+	createdAt
+}, (table) => [uniqueIndex("paykit_metadata_checkout_session_unique").on(table.providerId, table.providerCheckoutSessionId)]);
+const webhookEvent = pgTable("webhook_event", {
+	id: text("id").primaryKey(),
+	providerId: text("provider_id").notNull(),
+	providerEventId: text("provider_event_id").notNull(),
+	type: text("type").notNull(),
+	payload: jsonb("payload").$type().notNull(),
+	status: text("status").notNull(),
+	error: text("error"),
+	traceId: text("trace_id"),
+	receivedAt: timestamp("received_at").notNull(),
+	processedAt: timestamp("processed_at")
+}, (table) => [uniqueIndex("paykit_webhook_event_provider_unique").on(table.providerId, table.providerEventId), index("paykit_webhook_event_status_idx").on(table.providerId, table.status)]);
+//#endregion
+export { customer, entitlement, feature, invoice, paymentMethod, product, productFeature, schema_exports, subscription, webhookEvent };

package/dist/entitlement/entitlement.api.js

@@ -0,0 +1,33 @@
+import { definePayKitMethod } from "../api/define-route.js";
+import { getCustomerCurrentTime } from "../testing/testing.service.js";
+import { checkEntitlement, reportEntitlement } from "./entitlement.service.js";
+import * as z from "zod";
+//#region src/entitlement/entitlement.api.ts
+const entitlementCheckSchema = z.object({
+	featureId: z.string(),
+	required: z.number().positive().optional()
+});
+const entitlementReportSchema = z.object({
+	featureId: z.string(),
+	amount: z.number().positive().optional()
+});
+const check = definePayKitMethod({
+	input: entitlementCheckSchema,
+	requireCustomer: true
+}, async (ctx) => checkEntitlement(ctx.paykit.database, {
+	customerId: ctx.customer.id,
+	featureId: ctx.input.featureId,
+	now: getCustomerCurrentTime(ctx.paykit, ctx.customer),
+	required: ctx.input.required
+}));
+const report = definePayKitMethod({
+	input: entitlementReportSchema,
+	requireCustomer: true
+}, async (ctx) => reportEntitlement(ctx.paykit.database, {
+	amount: ctx.input.amount,
+	customerId: ctx.customer.id,
+	featureId: ctx.input.featureId,
+	now: getCustomerCurrentTime(ctx.paykit, ctx.customer)
+}));
+//#endregion
+export { check, report };

package/dist/entitlement/entitlement.service.d.ts

@@ -0,0 +1,17 @@
+//#region src/entitlement/entitlement.service.d.ts
+interface EntitlementBalance {
+  limit: number;
+  remaining: number;
+  resetAt: Date | null;
+  unlimited: boolean;
+}
+interface CheckResult {
+  allowed: boolean;
+  balance: EntitlementBalance | null;
+}
+interface ReportResult {
+  balance: EntitlementBalance | null;
+  success: boolean;
+}
+//#endregion
+export { CheckResult, EntitlementBalance, ReportResult };

package/dist/entitlement/entitlement.service.js

@@ -0,0 +1,123 @@
+import { entitlement, productFeature, subscription } from "../database/schema.js";
+import { and, eq, inArray, isNull, lte, or, sql } from "drizzle-orm";
+//#region src/entitlement/entitlement.service.ts
+function addResetInterval(date, resetInterval) {
+	const next = new Date(date);
+	if (resetInterval === "day") next.setUTCDate(next.getUTCDate() + 1);
+	if (resetInterval === "week") next.setUTCDate(next.getUTCDate() + 7);
+	if (resetInterval === "month") {
+		const day = next.getUTCDate();
+		next.setUTCMonth(next.getUTCMonth() + 1);
+		if (next.getUTCDate() !== day) next.setUTCDate(0);
+	}
+	if (resetInterval === "year") {
+		const day = next.getUTCDate();
+		next.setUTCFullYear(next.getUTCFullYear() + 1);
+		if (next.getUTCDate() !== day) next.setUTCDate(0);
+	}
+	return next;
+}
+function getNextResetAt(currentResetAt, now, resetInterval) {
+	let nextResetAt = new Date(currentResetAt);
+	while (nextResetAt <= now) nextResetAt = addResetInterval(nextResetAt, resetInterval);
+	return nextResetAt;
+}
+function aggregateBalance(rows) {
+	if (rows.length === 0) return null;
+	if (rows.some((row) => row.originalLimit === null)) return {
+		limit: 0,
+		remaining: 0,
+		resetAt: null,
+		unlimited: true
+	};
+	let remaining = 0;
+	let limit = 0;
+	let resetAt = null;
+	for (const row of rows) {
+		remaining += row.balance;
+		limit += row.originalLimit;
+		if (row.nextResetAt) {
+			if (!resetAt || row.nextResetAt < resetAt) resetAt = row.nextResetAt;
+		}
+	}
+	return {
+		limit,
+		remaining,
+		resetAt,
+		unlimited: false
+	};
+}
+/** Fetch all active entitlements for a customer+feature, with product feature metadata. */
+async function getActiveEntitlements(db, customerId, featureId) {
+	return await db.select({
+		id: entitlement.id,
+		balance: entitlement.balance,
+		nextResetAt: entitlement.nextResetAt,
+		originalLimit: productFeature.limit,
+		resetInterval: productFeature.resetInterval
+	}).from(entitlement).innerJoin(subscription, eq(entitlement.subscriptionId, subscription.id)).innerJoin(productFeature, and(eq(productFeature.productInternalId, subscription.productInternalId), eq(productFeature.featureId, entitlement.featureId))).where(and(eq(entitlement.customerId, customerId), eq(entitlement.featureId, featureId), inArray(subscription.status, ["active", "trialing"]), or(isNull(subscription.endedAt), sql`${subscription.endedAt} > now()`)));
+}
+/** Lazy-reset any stale entitlements and return the refreshed rows. */
+async function resetStaleEntitlements(db, rows, now) {
+	for (const row of rows) if (row.nextResetAt && row.nextResetAt <= now && row.resetInterval && row.originalLimit != null) {
+		const nextReset = getNextResetAt(row.nextResetAt, now, row.resetInterval);
+		await db.update(entitlement).set({
+			balance: row.originalLimit,
+			nextResetAt: nextReset,
+			updatedAt: now
+		}).where(and(eq(entitlement.id, row.id), lte(entitlement.nextResetAt, now)));
+		row.balance = row.originalLimit;
+		row.nextResetAt = nextReset;
+	}
+	return rows;
+}
+async function checkEntitlement(database, input) {
+	const required = input.required ?? 1;
+	const rows = await getActiveEntitlements(database, input.customerId, input.featureId);
+	await resetStaleEntitlements(database, rows, input.now ?? /* @__PURE__ */ new Date());
+	const balance = aggregateBalance(rows);
+	if (!balance) return {
+		allowed: false,
+		balance: null
+	};
+	if (balance.unlimited) return {
+		allowed: true,
+		balance
+	};
+	return {
+		allowed: balance.remaining >= required,
+		balance
+	};
+}
+async function reportEntitlement(database, input) {
+	const amount = input.amount ?? 1;
+	const rows = await getActiveEntitlements(database, input.customerId, input.featureId);
+	await resetStaleEntitlements(database, rows, input.now ?? /* @__PURE__ */ new Date());
+	if (rows.length === 0) return {
+		balance: null,
+		success: false
+	};
+	if (rows.some((row) => row.originalLimit === null)) return {
+		balance: aggregateBalance(rows),
+		success: true
+	};
+	let deducted = false;
+	for (const row of rows) {
+		if (row.originalLimit === null || row.balance < amount) continue;
+		const result = await database.update(entitlement).set({
+			balance: sql`${entitlement.balance} - ${amount}`,
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where(and(eq(entitlement.id, row.id), sql`${entitlement.balance} >= ${amount}`)).returning({ balance: entitlement.balance });
+		if (result.length > 0) {
+			row.balance = result[0].balance;
+			deducted = true;
+			break;
+		}
+	}
+	return {
+		balance: aggregateBalance(rows),
+		success: deducted
+	};
+}
+//#endregion
+export { checkEntitlement, reportEntitlement };

package/dist/handlers/next.d.ts

@@ -0,0 +1,9 @@
+import { PayKitInstance } from "../types/instance.js";
+
+//#region src/handlers/next.d.ts
+declare function paykitHandler(paykit: Pick<PayKitInstance, "handler">): {
+  GET: (request: Request) => Promise<Response>;
+  POST: (request: Request) => Promise<Response>;
+};
+//#endregion
+export { paykitHandler };

package/dist/handlers/next.js

@@ -0,0 +1,9 @@
+//#region src/handlers/next.ts
+function paykitHandler(paykit) {
+	return {
+		GET: paykit.handler,
+		POST: paykit.handler
+	};
+}
+//#endregion
+export { paykitHandler };

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { NormalizedInvoice, NormalizedPayment, NormalizedPaymentMethod, NormalizedSubscription, NormalizedWebhookEvent, NormalizedWebhookEventMap, NormalizedWebhookEventName, PayKitEventHandlers, PayKitEventMap, PayKitEventName, WebhookApplyAction } from "./types/events.js";
+import { PayKitProvider, ProviderCustomer, ProviderCustomerMap, ProviderTestClock, StripeProviderConfig, StripeProviderOptions } from "./providers/provider.js";
+import { PayKitPlugin } from "./types/plugin.js";
+import { FeatureType, MeteredFeatureConfig, MeteredResetInterval, NormalizedPlan, NormalizedPlanFeature, NormalizedSchema, PayKitFeature, PayKitFeatureDefinition, PayKitFeatureInclude, PayKitPlan, PayKitPlanConfig, PayKitPlansModule, PlanPrice, PriceInterval, feature, plan } from "./types/schema.js";
+import { PayKitLoggingOptions, PayKitOptions, PayKitTestingOptions } from "./types/options.js";
+import { Customer, StoredFeature, StoredInvoice, StoredProduct, StoredProductFeature, StoredSubscription } from "./types/models.js";
+import { createPayKitEndpoint, definePayKitMethod, returnUrl } from "./api/define-route.js";
+import { CustomerEntitlement, CustomerSubscription, CustomerWithDetails, ListCustomersResult } from "./customer/customer.types.js";
+import { PayKitAdvanceTestClockInput, PayKitCheckInput, PayKitClientAdvanceTestClockInput, PayKitClientCustomerPortalInput, PayKitClientGetTestClockInput, PayKitClientSubscribeInput, PayKitCustomerPortalInput, PayKitGetTestClockInput, PayKitInstance, PayKitReportInput, PayKitSubscribeInput, PayKitSubscribeResult } from "./types/instance.js";
+import { createPayKit } from "./core/create-paykit.js";
+import { CheckResult, EntitlementBalance, ReportResult } from "./entitlement/entitlement.service.js";
+import { RawError, defineErrorCodes } from "./core/error-codes.js";
+import { PAYKIT_ERROR_CODES, PayKitError, PayKitErrorCode } from "./core/errors.js";
+export { type CheckResult, type Customer, type CustomerEntitlement, type CustomerSubscription, type CustomerWithDetails, type EntitlementBalance, type FeatureType, type ListCustomersResult, type MeteredFeatureConfig, type MeteredResetInterval, type NormalizedInvoice, type NormalizedPayment, type NormalizedPaymentMethod, type NormalizedPlan, type NormalizedPlanFeature, type NormalizedSchema, type NormalizedSubscription, type NormalizedWebhookEvent, type NormalizedWebhookEventMap, type NormalizedWebhookEventName, PAYKIT_ERROR_CODES, type PayKitAdvanceTestClockInput, type PayKitCheckInput, type PayKitClientAdvanceTestClockInput, type PayKitClientCustomerPortalInput, type PayKitClientGetTestClockInput, type PayKitClientSubscribeInput, type PayKitCustomerPortalInput, PayKitError, type PayKitErrorCode, type PayKitEventHandlers, type PayKitEventMap, type PayKitEventName, type PayKitFeature, type PayKitFeatureDefinition, type PayKitFeatureInclude, type PayKitGetTestClockInput, type PayKitInstance, type PayKitLoggingOptions, type PayKitOptions, type PayKitPlan, type PayKitPlanConfig, type PayKitPlansModule, type PayKitPlugin, type PayKitProvider, type PayKitReportInput, type PayKitSubscribeInput, type PayKitSubscribeResult, type PayKitTestingOptions, type PlanPrice, type PriceInterval, type ProviderCustomer, type ProviderCustomerMap, type ProviderTestClock, type RawError, type ReportResult, type StoredFeature, type StoredInvoice, type StoredProduct, type StoredProductFeature, type StoredSubscription, type StripeProviderConfig, type StripeProviderOptions, type WebhookApplyAction, createPayKit, createPayKitEndpoint, defineErrorCodes, definePayKitMethod, feature, plan, returnUrl };

package/dist/index.js

@@ -0,0 +1,6 @@
+import { defineErrorCodes } from "./core/error-codes.js";
+import { PAYKIT_ERROR_CODES, PayKitError } from "./core/errors.js";
+import { createPayKitEndpoint, definePayKitMethod, returnUrl } from "./api/define-route.js";
+import { feature, plan } from "./types/schema.js";
+import { createPayKit } from "./core/create-paykit.js";
+export { PAYKIT_ERROR_CODES, PayKitError, createPayKit, createPayKitEndpoint, defineErrorCodes, definePayKitMethod, feature, plan, returnUrl };

package/dist/invoice/invoice.service.js

@@ -0,0 +1,54 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "../core/errors.js";
+import { invoice, subscription } from "../database/schema.js";
+import { generateId } from "../core/utils.js";
+import { findCustomerByProviderCustomerId } from "../customer/customer.service.js";
+import { and, eq, sql } from "drizzle-orm";
+//#region src/invoice/invoice.service.ts
+async function upsertInvoiceRecord(database, input) {
+	const now = /* @__PURE__ */ new Date();
+	const providerData = { invoiceId: input.invoice.providerInvoiceId };
+	const existing = await database.query.invoice.findFirst({ where: and(eq(invoice.providerId, input.providerId), sql`${invoice.providerData}->>'invoiceId' = ${input.invoice.providerInvoiceId}`) });
+	const values = {
+		amount: input.invoice.totalAmount,
+		currency: input.invoice.currency,
+		customerId: input.customerId,
+		description: null,
+		hostedUrl: input.invoice.hostedUrl ?? null,
+		periodEndAt: input.invoice.periodEndAt ?? null,
+		periodStartAt: input.invoice.periodStartAt ?? null,
+		providerData,
+		providerId: input.providerId,
+		status: input.invoice.status ?? "open",
+		subscriptionId: input.subscriptionId ?? null,
+		type: "subscription",
+		updatedAt: now
+	};
+	if (existing) {
+		const row = (await database.update(invoice).set(values).where(eq(invoice.id, existing.id)).returning())[0];
+		if (!row) throw PayKitError.from("INTERNAL_SERVER_ERROR", PAYKIT_ERROR_CODES.INVOICE_UPSERT_FAILED);
+		return row;
+	}
+	const row = (await database.insert(invoice).values({
+		...values,
+		id: generateId("inv")
+	}).returning())[0];
+	if (!row) throw PayKitError.from("INTERNAL_SERVER_ERROR", PAYKIT_ERROR_CODES.INVOICE_UPSERT_FAILED);
+	return row;
+}
+async function applyInvoiceWebhookAction(ctx, action) {
+	const customerRow = await findCustomerByProviderCustomerId(ctx.database, {
+		providerCustomerId: action.data.providerCustomerId,
+		providerId: ctx.provider.id
+	});
+	if (!customerRow) return null;
+	const subscriptionRecord = action.data.providerSubscriptionId ? await ctx.database.query.subscription.findFirst({ where: and(eq(subscription.providerId, ctx.provider.id), sql`${subscription.providerData}->>'subscriptionId' = ${action.data.providerSubscriptionId}`) }) : null;
+	await upsertInvoiceRecord(ctx.database, {
+		customerId: customerRow.id,
+		invoice: action.data.invoice,
+		providerId: ctx.provider.id,
+		subscriptionId: subscriptionRecord?.id ?? null
+	});
+	return customerRow.id;
+}
+//#endregion
+export { applyInvoiceWebhookAction, upsertInvoiceRecord };

package/dist/payment/payment.service.js

@@ -0,0 +1,49 @@
+import { invoice } from "../database/schema.js";
+import { generateId } from "../core/utils.js";
+import { findCustomerByProviderCustomerId } from "../customer/customer.service.js";
+import { and, eq, sql } from "drizzle-orm";
+//#region src/payment/payment.service.ts
+async function syncPaymentByProviderCustomer(database, input) {
+	const customerRow = await findCustomerByProviderCustomerId(database, {
+		providerCustomerId: input.providerCustomerId,
+		providerId: input.providerId
+	});
+	if (!customerRow) return;
+	const providerData = {
+		paymentId: input.payment.providerPaymentId,
+		methodId: input.payment.providerMethodId ?? null
+	};
+	const existing = await database.query.invoice.findFirst({ where: and(eq(invoice.providerId, input.providerId), sql`${invoice.providerData}->>'paymentId' = ${input.payment.providerPaymentId}`) });
+	if (existing) {
+		await database.update(invoice).set({
+			status: input.payment.status,
+			amount: input.payment.amount,
+			updatedAt: /* @__PURE__ */ new Date()
+		}).where(eq(invoice.id, existing.id));
+		return;
+	}
+	await database.insert(invoice).values({
+		id: generateId("inv"),
+		customerId: customerRow.id,
+		type: "charge",
+		status: input.payment.status,
+		amount: input.payment.amount,
+		currency: input.payment.currency,
+		description: input.payment.description ?? null,
+		providerId: input.providerId,
+		providerData
+	});
+}
+async function applyPaymentWebhookAction(ctx, action) {
+	await syncPaymentByProviderCustomer(ctx.database, {
+		payment: action.data.payment,
+		providerCustomerId: action.data.providerCustomerId,
+		providerId: ctx.provider.id
+	});
+	return (await findCustomerByProviderCustomerId(ctx.database, {
+		providerCustomerId: action.data.providerCustomerId,
+		providerId: ctx.provider.id
+	}))?.id ?? null;
+}
+//#endregion
+export { applyPaymentWebhookAction };

package/dist/payment-method/payment-method.service.js

@@ -0,0 +1,78 @@
+import { paymentMethod } from "../database/schema.js";
+import { generateId } from "../core/utils.js";
+import { findCustomerByProviderCustomerId } from "../customer/customer.service.js";
+import { and, eq, isNull, sql } from "drizzle-orm";
+//#region src/payment-method/payment-method.service.ts
+async function getDefaultPaymentMethod(database, input) {
+	return await database.query.paymentMethod.findFirst({
+		orderBy(fields, operators) {
+			return [operators.desc(fields.isDefault), operators.desc(fields.createdAt)];
+		},
+		where: and(eq(paymentMethod.customerId, input.customerId), eq(paymentMethod.isDefault, true), eq(paymentMethod.providerId, input.providerId), isNull(paymentMethod.deletedAt))
+	}) ?? null;
+}
+async function syncPaymentMethodByProviderCustomer(database, input) {
+	const customerRow = await findCustomerByProviderCustomerId(database, {
+		providerCustomerId: input.providerCustomerId,
+		providerId: input.providerId
+	});
+	if (!customerRow) return;
+	const now = /* @__PURE__ */ new Date();
+	const providerData = {
+		methodId: input.paymentMethod.providerMethodId,
+		type: input.paymentMethod.type,
+		last4: input.paymentMethod.last4 ?? null,
+		expiryMonth: input.paymentMethod.expiryMonth ?? null,
+		expiryYear: input.paymentMethod.expiryYear ?? null
+	};
+	const existingRow = await database.query.paymentMethod.findFirst({ where: and(eq(paymentMethod.providerId, input.providerId), sql`${paymentMethod.providerData}->>'methodId' = ${input.paymentMethod.providerMethodId}`, isNull(paymentMethod.deletedAt)) });
+	if (input.paymentMethod.isDefault) await database.update(paymentMethod).set({
+		isDefault: false,
+		updatedAt: now
+	}).where(and(eq(paymentMethod.customerId, customerRow.id), eq(paymentMethod.providerId, input.providerId)));
+	if (existingRow) {
+		await database.update(paymentMethod).set({
+			customerId: customerRow.id,
+			deletedAt: null,
+			isDefault: input.paymentMethod.isDefault ?? existingRow.isDefault,
+			providerData,
+			updatedAt: now
+		}).where(eq(paymentMethod.id, existingRow.id));
+		return;
+	}
+	await database.insert(paymentMethod).values({
+		customerId: customerRow.id,
+		deletedAt: null,
+		id: generateId("pm"),
+		isDefault: input.paymentMethod.isDefault ?? false,
+		providerId: input.providerId,
+		providerData
+	});
+}
+async function deletePaymentMethodByProviderId(database, input) {
+	await database.update(paymentMethod).set({
+		deletedAt: /* @__PURE__ */ new Date(),
+		isDefault: false,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(and(eq(paymentMethod.providerId, input.providerId), sql`${paymentMethod.providerData}->>'methodId' = ${input.providerMethodId}`));
+}
+async function applyPaymentMethodWebhookAction(ctx, action) {
+	if (action.type === "payment_method.upsert") {
+		await syncPaymentMethodByProviderCustomer(ctx.database, {
+			paymentMethod: action.data.paymentMethod,
+			providerCustomerId: action.data.providerCustomerId,
+			providerId: ctx.provider.id
+		});
+		return (await findCustomerByProviderCustomerId(ctx.database, {
+			providerCustomerId: action.data.providerCustomerId,
+			providerId: ctx.provider.id
+		}))?.id ?? null;
+	}
+	await deletePaymentMethodByProviderId(ctx.database, {
+		providerId: ctx.provider.id,
+		providerMethodId: action.data.providerMethodId
+	});
+	return null;
+}
+//#endregion
+export { applyPaymentMethodWebhookAction, getDefaultPaymentMethod };

package/dist/product/product-sync.service.js

@@ -0,0 +1,111 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "../core/errors.js";
+import { getLatestProductSnapshot, getProviderProduct, insertProductVersion, replaceProductFeatures, updateProductName, upsertFeature, upsertProviderProduct } from "./product.service.js";
+//#region src/product/product-sync.service.ts
+function serializeFeatureConfig(config) {
+	return JSON.stringify(config ?? null);
+}
+function featuresChanged(existing, next) {
+	if (existing.length !== next.length) return true;
+	return existing.some((storedFeature, index) => {
+		const nextFeature = next[index];
+		if (!nextFeature) return true;
+		return storedFeature.featureId !== nextFeature.id || storedFeature.limit !== nextFeature.limit || storedFeature.resetInterval !== nextFeature.resetInterval || serializeFeatureConfig(storedFeature.config) !== serializeFeatureConfig(nextFeature.config);
+	});
+}
+function planChanged(existing, next) {
+	if (!existing) return true;
+	return existing.product.group !== next.group || existing.product.isDefault !== next.isDefault || (existing.product.priceAmount ?? null) !== next.priceAmount || (existing.product.priceInterval ?? null) !== next.priceInterval || featuresChanged(existing.features, next.includes);
+}
+async function dryRunSyncProducts(ctx) {
+	const results = [];
+	for (const plan of ctx.plans.plans) {
+		const existing = await getLatestProductSnapshot(ctx.database, plan.id);
+		let action = "unchanged";
+		if (!existing) action = "created";
+		else if (planChanged(existing, plan)) action = "created";
+		else if (existing.product.name !== plan.name) action = "updated";
+		results.push({
+			action,
+			id: plan.id,
+			version: existing ? existing.product.version : 1
+		});
+	}
+	return results;
+}
+async function syncProducts(ctx) {
+	const results = [];
+	const providerId = ctx.provider.id;
+	for (const schemaFeature of ctx.plans.features) await upsertFeature(ctx.database, schemaFeature);
+	for (const plan of ctx.plans.plans) {
+		const existing = await getLatestProductSnapshot(ctx.database, plan.id);
+		const existingProviderProduct = existing ? await getProviderProduct(ctx.database, existing.product.internalId, providerId) : null;
+		let storedProduct = existing?.product ?? null;
+		let action = "unchanged";
+		if (!existing) {
+			storedProduct = await insertProductVersion(ctx.database, {
+				group: plan.group,
+				hash: plan.hash,
+				id: plan.id,
+				isDefault: plan.isDefault,
+				name: plan.name,
+				priceAmount: plan.priceAmount,
+				priceInterval: plan.priceInterval,
+				version: 1
+			});
+			await replaceProductFeatures(ctx.database, {
+				features: plan.includes,
+				productInternalId: storedProduct.internalId
+			});
+			action = "created";
+		} else if (planChanged(existing, plan)) {
+			storedProduct = await insertProductVersion(ctx.database, {
+				group: plan.group,
+				hash: plan.hash,
+				id: plan.id,
+				isDefault: plan.isDefault,
+				name: plan.name,
+				priceAmount: plan.priceAmount,
+				priceInterval: plan.priceInterval,
+				version: existing.product.version + 1
+			});
+			await replaceProductFeatures(ctx.database, {
+				features: plan.includes,
+				productInternalId: storedProduct.internalId
+			});
+			action = "created";
+		} else if (existing.product.name !== plan.name) {
+			await updateProductName(ctx.database, existing.product.internalId, plan.name);
+			storedProduct = {
+				...existing.product,
+				name: plan.name
+			};
+			action = "updated";
+		}
+		if (!storedProduct) throw PayKitError.from("INTERNAL_SERVER_ERROR", PAYKIT_ERROR_CODES.PLAN_SYNC_FAILED, `Failed to sync plan "${plan.id}"`);
+		if (storedProduct.priceAmount !== null && storedProduct.priceInterval !== null) {
+			const shouldReuseExistingPriceId = action !== "created" && existingProviderProduct?.priceId !== void 0;
+			const providerResult = await ctx.stripe.syncProduct({
+				existingProviderPriceId: shouldReuseExistingPriceId ? existingProviderProduct?.priceId ?? null : null,
+				existingProviderProductId: existingProviderProduct?.productId ?? null,
+				id: plan.id,
+				name: plan.name,
+				priceAmount: storedProduct.priceAmount,
+				priceInterval: storedProduct.priceInterval
+			});
+			await upsertProviderProduct(ctx.database, {
+				productInternalId: storedProduct.internalId,
+				providerId,
+				providerProductId: providerResult.providerProductId,
+				providerPriceId: providerResult.providerPriceId
+			});
+		}
+		results.push({
+			action,
+			id: plan.id,
+			version: storedProduct.version
+		});
+	}
+	return results;
+}
+//#endregion
+export { dryRunSyncProducts, syncProducts };