nomkit 0.0.0

package/dist/core/pg_db/schema.js

@@ -0,0 +1,124 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { bigint, index, integer, jsonb, pgEnum, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+//#region core/pg_db/schema.ts
+var schema_exports = /* @__PURE__ */ __exportAll({
+	customers: () => customers,
+	entitlements: () => entitlements,
+	featureTypeEnum: () => featureTypeEnum,
+	features: () => features,
+	invoiceStatusEnum: () => invoiceStatusEnum,
+	invoices: () => invoices,
+	paymentMethods: () => paymentMethods,
+	productFeatures: () => productFeatures,
+	products: () => products,
+	subscriptionStatusEnum: () => subscriptionStatusEnum,
+	subscriptions: () => subscriptions
+});
+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 products = pgTable("nomkit_product", {
+	internalId: uuid("internal_id").defaultRandom().primaryKey(),
+	id: text("id").notNull(),
+	label: text("label").notNull(),
+	hash: text("product_hash").notNull(),
+	priceAmount: integer("price_amount"),
+	priceInterval: text("product_interval"),
+	version: integer("version").notNull().default(1),
+	createdAt,
+	updatedAt
+}, (table) => [index("product_idx").on(table.id), uniqueIndex("product_hash_version_unique").on(table.id, table.hash, table.version)]);
+const features = pgTable("nomkit_feature", {
+	internalId: uuid("internal_id").defaultRandom().primaryKey(),
+	id: text("id").notNull(),
+	label: text("label").notNull(),
+	createdAt,
+	updatedAt
+}, (table) => [index("feature_idx").on(table.internalId), uniqueIndex("feature_unique").on(table.id)]);
+const featureTypeEnum = pgEnum("feature_type", ["boolean", "metered"]);
+const productFeatures = pgTable("nomkit_product_features", {
+	internalId: uuid("id").defaultRandom().primaryKey(),
+	featureInternalId: uuid("feature_internal_id").notNull().references(() => features.internalId),
+	type: featureTypeEnum("type").notNull(),
+	limit: bigint("limit", { mode: "bigint" }),
+	resetInterval: text("reset_interval"),
+	hash: text("feature_hash").notNull(),
+	productId: text("product_id").notNull(),
+	productVersion: integer("product_version").notNull(),
+	createdAt,
+	updatedAt
+}, (table) => [index("project_feature_idx").on(table.internalId), uniqueIndex("product_feature_unique_version").on(table.internalId, table.productId, table.featureInternalId, table.productVersion)]);
+const customers = pgTable("nomkit_customer", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	name: text("name"),
+	email: text("email").unique().notNull(),
+	metadata: jsonb("metadata").$type(),
+	externalId: text("external_id").unique(),
+	createdAt,
+	updatedAt
+}, (table) => [index("customer_created_at_id_idx").on(table.createdAt, table.id)]);
+const paymentMethods = pgTable("nomkit_payment_method", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	customerId: uuid("customer_id").notNull().references(() => customers.id, { onDelete: "cascade" }),
+	tokenKey: text("token_key").notNull().unique(),
+	email: text("email").notNull(),
+	cardType: text("card_type").notNull(),
+	cardPan: text("card_pan").notNull(),
+	tokenExpirationDate: text("token_expiration_date").notNull(),
+	createdAt,
+	updatedAt
+});
+const subscriptionStatusEnum = pgEnum("subscription_status", [
+	"active",
+	"cancelled",
+	"past_due",
+	"pending",
+	"scheduled"
+]);
+const subscriptions = pgTable("nomkit_subscription", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	customerId: uuid("customer_id").notNull().references(() => customers.id, { onDelete: "cascade" }),
+	productInternalId: uuid("product_internal_id").notNull().references(() => products.internalId, { onDelete: "cascade" }),
+	paymentMethodId: uuid("payment_method_id").references(() => paymentMethods.id),
+	nextSubscriptionId: uuid("next_subscription_id").references(() => subscriptions.id, { onDelete: "set null" }),
+	status: subscriptionStatusEnum("status").notNull().default("active"),
+	currentPeriodStart: timestamp("current_period_start"),
+	currentPeriodEnd: timestamp("current_period_end"),
+	createdAt,
+	updatedAt,
+	endedAt: timestamp("ended_at")
+}, (table) => [index("subscription_customer_idx").on(table.customerId)]);
+const entitlements = pgTable("nomkit_entitlement", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	subscriptionId: uuid("subscription_id").notNull().references(() => subscriptions.id, { onDelete: "cascade" }),
+	customerId: uuid("customer_id").notNull().references(() => customers.id, { onDelete: "cascade" }),
+	featureInternalId: uuid("feature_internal_id").notNull().references(() => features.internalId, { onDelete: "cascade" }),
+	limit: bigint("limit", { mode: "bigint" }),
+	remaining: bigint("remaining", { mode: "bigint" }),
+	resetAt: timestamp("reset_at"),
+	createdAt,
+	updatedAt
+}, (table) => [
+	index("entitlement_customer_idx").on(table.customerId),
+	index("entitlement_subscription_idx").on(table.subscriptionId),
+	uniqueIndex("subscription_feature_unique").on(table.subscriptionId, table.featureInternalId)
+]);
+const invoiceStatusEnum = pgEnum("invoice_status", [
+	"paid",
+	"failed",
+	"void",
+	"pending"
+]);
+const invoices = pgTable("nomkit_invoice", {
+	id: uuid("id").defaultRandom().primaryKey(),
+	customerId: uuid("customer_id").notNull().references(() => customers.id),
+	subscriptionId: uuid("subscription_id").notNull().references(() => subscriptions.id),
+	status: invoiceStatusEnum("status").notNull().default("pending"),
+	amount: integer("amount").notNull(),
+	currency: text("currency").notNull(),
+	periodStart: timestamp("period_start"),
+	periodEnd: timestamp("period_end"),
+	createdAt,
+	updatedAt
+}, (table) => [uniqueIndex("invoice_period_unique").on(table.subscriptionId, table.periodStart, table.periodEnd)]);
+//#endregion
+export { customers, entitlements, featureTypeEnum, features, invoiceStatusEnum, invoices, paymentMethods, productFeatures, products, schema_exports, subscriptionStatusEnum, subscriptions };

package/dist/endpoints/customers/api.js

@@ -0,0 +1,51 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { defineNomkitMethod } from "../../lib/utils.js";
+import { z as z$1 } from "zod";
+//#region endpoints/customers/api.ts
+var api_exports = /* @__PURE__ */ __exportAll({
+	deleteCustomer: () => deleteCustomer,
+	getCustomer: () => getCustomer,
+	listCustomers: () => listCustomers,
+	upsertCustomer: () => upsertCustomer
+});
+const getCustomer = defineNomkitMethod({
+	input: z$1.object({
+		customerId: z$1.string().optional(),
+		externalId: z$1.string().optional()
+	}),
+	route: { path: "/customers/get" }
+}, async (ctx) => {
+	ctx.nomkit.database;
+	return {};
+});
+const upsertCustomer = defineNomkitMethod({
+	input: z$1.object({
+		name: z$1.string().optional(),
+		externalId: z$1.string().min(1).max(60).optional(),
+		email: z$1.email().min(1).max(60),
+		metadata: z$1.union([z$1.record(z$1.string(), z$1.string()), z$1.null()]).default(null)
+	}),
+	route: { path: "/customers/upsert" }
+}, async (ctx) => {
+	ctx.nomkit.database;
+	return true;
+});
+const listCustomers = defineNomkitMethod({
+	input: z$1.object({
+		cursor: z$1.string().optional(),
+		limit: z$1.number().default(20)
+	}),
+	route: { path: "/customers/list" }
+}, async (ctx) => {
+	ctx.nomkit.database;
+	return [];
+});
+const deleteCustomer = defineNomkitMethod({
+	input: z$1.object({ customerId: z$1.string().optional() }),
+	route: { path: "/customers/delete" }
+}, async (ctx) => {
+	ctx.nomkit.database;
+	return true;
+});
+//#endregion
+export { api_exports, deleteCustomer, getCustomer, listCustomers, upsertCustomer };

package/dist/endpoints/entitlements/api.js

@@ -0,0 +1,42 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { defineNomkitMethod } from "../../lib/utils.js";
+import { z as z$1 } from "zod";
+//#region endpoints/entitlements/api.ts
+var api_exports = /* @__PURE__ */ __exportAll({
+	checkEntitlements: () => checkEntitlements,
+	consumeEntitlements: () => consumeEntitlements
+});
+const checkEntitlements = defineNomkitMethod({
+	input: z$1.object({
+		customerId: z$1.string(),
+		featureId: z$1.string()
+	}),
+	route: { path: "/entitlements/check" }
+}, async (ctx) => {
+	return ctx.input.featureId === "bluetick" ? { allowed: true } : {
+		allowed: true,
+		balance: {
+			limit: 100,
+			remaining: 99,
+			resetAt: (/* @__PURE__ */ new Date()).toUTCString(),
+			unlimited: false
+		}
+	};
+});
+const consumeEntitlements = defineNomkitMethod({
+	input: z$1.object({
+		customerId: z$1.string(),
+		featureId: z$1.string(),
+		amount: z$1.number()
+	}),
+	route: { path: "/entitlements/consume" }
+}, async (ctx) => {
+	return {
+		featureId: ctx.input.featureId,
+		balance: 0,
+		limit: 100,
+		unlimited: false
+	};
+});
+//#endregion
+export { api_exports, checkEntitlements, consumeEntitlements };

package/dist/endpoints/routes.d.ts

@@ -0,0 +1,15 @@
+//#region endpoints/routes.d.ts
+declare const nomkitWebhooks: {
+  readonly invoiceWebhook: import("better-call").Endpoint<"/invoice-webhook", "POST", {
+    billing: Record<string, never>;
+    signature: string;
+    status: "success" | "cancelled" | "retrying";
+    policy: string;
+  }, Record<string, any> | undefined, [], {
+    status: string;
+  }, {
+    scope: "http";
+  }, undefined>;
+};
+//#endregion
+export { nomkitWebhooks };

package/dist/endpoints/routes.js

@@ -0,0 +1,15 @@
+import { api_exports } from "./customers/api.js";
+import { api_exports as api_exports$1 } from "./entitlements/api.js";
+import { api_exports as api_exports$2 } from "./subscriptions/api.js";
+import { api_exports as api_exports$3 } from "./webhooks/invoice/api.js";
+import { api_exports as api_exports$4 } from "./webhooks/nomba/api.js";
+({ ...api_exports$3 });
+const routes = {
+	...api_exports$2,
+	...api_exports$1,
+	...api_exports,
+	...api_exports$4,
+	...api_exports$3
+};
+//#endregion
+export { routes };

package/dist/endpoints/subscriptions/api.js

@@ -0,0 +1,263 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import { subscriptions } from "../../core/pg_db/schema.js";
+import { defineNomkitMethod, getOrderReference } from "../../lib/utils.js";
+import { buildBaseCheckoutMetadata, classifyChange, computeUpgradeProration, getCurrentSubscription, getScheduledPeriodBounds, isFreePlan, persistProrationOnCustomer } from "./utils.js";
+import { z as z$1 } from "zod";
+import { and, eq } from "drizzle-orm";
+//#region endpoints/subscriptions/api.ts
+var api_exports = /* @__PURE__ */ __exportAll({
+	mockSubscribe: () => mockSubscribe,
+	subscribe: () => subscribe
+});
+const SubscribeSchema = z$1.object({
+	customerId: z$1.string().min(1).max(60),
+	planID: z$1.string().min(1).max(60),
+	successURL: z$1.url().min(1).max(60),
+	cancelURL: z$1.string().optional()
+});
+const subscribe = defineNomkitMethod({
+	input: SubscribeSchema,
+	route: { path: "/subscribe" }
+}, async (ctx) => {
+	const db = ctx.nomkit.database;
+	const input = ctx.input;
+	const nombaAPI = ctx.nomkit.nomba;
+	const customer = await db.query.customers.findFirst({ where: { id: input.customerId } });
+	if (!customer) {
+		console.log("customer not found");
+		return null;
+	}
+	const plan = await db.query.products.findFirst({
+		where: { id: input.planID },
+		orderBy: (products, { desc }) => [desc(products.version)]
+	});
+	if (!plan) {
+		console.log("Plan not found");
+		return null;
+	}
+	const currentSubscription = await getCurrentSubscription(db, customer.id);
+	if (!currentSubscription) return startNewSubscription(db, customer, plan, nombaAPI);
+	if (currentSubscription.productInternalId === plan.internalId) {
+		console.log("Already on this plan");
+		return { checkoutURL: null };
+	}
+	const previousPlan = await db.query.products.findFirst({ where: { internalId: currentSubscription.productInternalId } });
+	if (!previousPlan) {
+		console.log("Failed to query previous plan");
+		return null;
+	}
+	return switchSubscriptionPlan(db, {
+		customer,
+		plan,
+		previousPlan,
+		currentSubscription,
+		nomba: nombaAPI
+	});
+});
+const mockSubscribe = defineNomkitMethod({
+	input: SubscribeSchema,
+	route: { path: "/mmock-subscribe" }
+}, async (ctx) => {
+	const db = ctx.nomkit.database;
+	const input = ctx.input;
+	const nombaAPI = ctx.nomkit.nomba;
+	const customer = await db.query.customers.findFirst({ where: { id: input.customerId } });
+	if (!customer) {
+		console.log("customer not found");
+		return null;
+	}
+	const plan = await db.query.products.findFirst({
+		where: { id: input.planID },
+		orderBy: (products, { desc }) => [desc(products.version)]
+	});
+	if (!plan) {
+		console.log("Plan not found");
+		return null;
+	}
+	const currentSubscription = await getCurrentSubscription(db, customer.id);
+	if (!currentSubscription) return startNewSubscription(db, customer, plan, nombaAPI);
+	if (currentSubscription.productInternalId === plan.internalId) {
+		console.log("Already on this plan");
+		return { checkoutURL: null };
+	}
+	const previousPlan = await db.query.products.findFirst({ where: { internalId: currentSubscription.productInternalId } });
+	if (!previousPlan) {
+		console.log("Failed to query previous plan");
+		return null;
+	}
+	return switchSubscriptionPlan(db, {
+		customer,
+		plan,
+		previousPlan,
+		currentSubscription,
+		nomba: nombaAPI
+	});
+});
+async function startNewSubscription(db, customer, plan, nomba) {
+	const newSubscription = {
+		customerId: customer.id,
+		productInternalId: plan.internalId,
+		status: "pending"
+	};
+	const [subscription] = await db.insert(subscriptions).values(newSubscription).returning();
+	const amount = plan.priceAmount;
+	if (!amount) {
+		await db.update(subscriptions).set({
+			status: "active",
+			currentPeriodStart: /* @__PURE__ */ new Date()
+		}).where(eq(subscriptions.id, subscription.id));
+		return { checkoutURL: null };
+	}
+	const reference = getOrderReference();
+	const checkout = await nomba.checkOut({
+		amount: amount.toString(),
+		customerEmail: customer.email,
+		reference,
+		successURL: "input.successURL",
+		metadata: buildBaseCheckoutMetadata({
+			reference,
+			subscriptionId: subscription.id,
+			customer,
+			plan,
+			kind: "new"
+		})
+	});
+	console.log("Checkout for brand new subscription");
+	return { checkoutURL: checkout.checkoutLink };
+}
+async function activateSwitchedSubscriptionWithCredit(db, params) {
+	const { subscriptionId, previousSubscriptionId, now, periodEnd } = params;
+	await db.update(subscriptions).set({
+		status: "active",
+		currentPeriodStart: new Date(now.epochMilliseconds),
+		currentPeriodEnd: new Date(periodEnd.epochMilliseconds)
+	}).where(eq(subscriptions.id, subscriptionId));
+	await db.update(subscriptions).set({
+		status: "cancelled",
+		endedAt: new Date(now.epochMilliseconds)
+	}).where(eq(subscriptions.id, previousSubscriptionId));
+}
+async function switchSubscriptionPlan(db, params) {
+	const { customer, plan, previousPlan, currentSubscription } = params;
+	if (isFreePlan(previousPlan) || !currentSubscription.currentPeriodEnd) return switchSubscriptionImmediately(db, {
+		customer,
+		plan,
+		previousPlan,
+		currentSubscription,
+		prorate: false,
+		nomba: params.nomba
+	});
+	if (classifyChange(previousPlan, plan) === "upgrade") return switchSubscriptionImmediately(db, {
+		customer,
+		plan,
+		previousPlan,
+		currentSubscription,
+		prorate: true,
+		nomba: params.nomba
+	});
+	return scheduleSubscriptionSwitch(db, {
+		customer,
+		plan,
+		previousPlan,
+		currentSubscription
+	});
+}
+async function switchSubscriptionImmediately(db, params) {
+	const { customer, plan, previousPlan, currentSubscription, prorate } = params;
+	if (params.previousPlan) await db.update(subscriptions).set({ status: "cancelled" }).where(and(eq(subscriptions.productInternalId, params.previousPlan.internalId), eq(subscriptions.status, "active")));
+	if (currentSubscription.nextSubscriptionId) {
+		await db.delete(subscriptions).where(eq(subscriptions.id, currentSubscription.nextSubscriptionId));
+		await db.update(subscriptions).set({ nextSubscriptionId: null }).where(eq(subscriptions.id, currentSubscription.id));
+	}
+	const newSubscription = {
+		customerId: customer.id,
+		productInternalId: plan.internalId,
+		status: isFreePlan(plan) ? "active" : "pending"
+	};
+	const [subscription] = await db.insert(subscriptions).values(newSubscription).returning();
+	if (isFreePlan(plan)) {
+		await db.update(subscriptions).set({ currentPeriodStart: /* @__PURE__ */ new Date() }).where(eq(subscriptions.id, subscription.id));
+		await db.update(subscriptions).set({
+			status: "cancelled",
+			endedAt: /* @__PURE__ */ new Date()
+		}).where(eq(subscriptions.id, currentSubscription.id));
+		return { checkoutURL: null };
+	}
+	if (!prorate) {
+		const reference = getOrderReference();
+		return { checkoutURL: (await params.nomba.checkOut({
+			amount: (plan.priceAmount ?? 0).toString(),
+			customerEmail: customer.email,
+			reference,
+			successURL: "input.successURL",
+			metadata: {
+				...buildBaseCheckoutMetadata({
+					reference,
+					subscriptionId: subscription.id,
+					customer,
+					plan,
+					kind: "new"
+				}),
+				"nomkit.subscription.previous_subscription_id": currentSubscription.id
+			}
+		})).checkoutLink };
+	}
+	const existingMetadata = customer.metadata ?? {};
+	const proration = computeUpgradeProration({
+		currentSubscription,
+		previousPlan,
+		plan,
+		existingBalance: Number(existingMetadata?.creditBalance ?? "0") || 0
+	});
+	await persistProrationOnCustomer(db, customer, previousPlan, plan, proration);
+	if (proration.chargeAmount <= 0) {
+		await activateSwitchedSubscriptionWithCredit(db, {
+			subscriptionId: subscription.id,
+			previousSubscriptionId: currentSubscription.id,
+			plan,
+			now: proration.now,
+			periodEnd: proration.periodEnd
+		});
+		console.log("Upgrade applied using existing credit balance");
+		return { checkoutURL: null };
+	}
+	const reference = getOrderReference();
+	const checkoutMetadata = {
+		...buildBaseCheckoutMetadata({
+			reference,
+			subscriptionId: subscription.id,
+			customer,
+			plan,
+			kind: "upgrade"
+		}),
+		"nomkit.subscription.previous_subscription_id": currentSubscription.id,
+		"nomkit.subscription.previous_internalPlanId": previousPlan.internalId,
+		"nomkit.subscription.prorated_credit_applied": proration.totalCredit.toString()
+	};
+	return { checkoutURL: (await params.nomba.checkOut({
+		amount: proration.chargeAmount.toString(),
+		customerEmail: customer.email,
+		reference,
+		successURL: "input.successURL",
+		metadata: checkoutMetadata
+	})).checkoutLink };
+}
+async function scheduleSubscriptionSwitch(db, params) {
+	const { customer, plan, previousPlan, currentSubscription } = params;
+	const periodEnd = currentSubscription.currentPeriodEnd;
+	if (currentSubscription.nextSubscriptionId) await db.delete(subscriptions).where(eq(subscriptions.id, currentSubscription.nextSubscriptionId));
+	const { start, end } = getScheduledPeriodBounds(periodEnd, plan);
+	const newSubscription = {
+		customerId: customer.id,
+		productInternalId: plan.internalId,
+		status: "scheduled",
+		currentPeriodStart: start,
+		currentPeriodEnd: end
+	};
+	const [scheduled] = await db.insert(subscriptions).values(newSubscription).returning();
+	await db.update(subscriptions).set({ nextSubscriptionId: scheduled.id }).where(eq(subscriptions.id, currentSubscription.id));
+	console.log(`Scheduled switch from plan ${previousPlan.id} to ${plan.id}, effective ${periodEnd.toISOString()}`);
+	return { checkoutURL: null };
+}
+//#endregion
+export { api_exports, mockSubscribe, subscribe };

package/dist/endpoints/subscriptions/utils.js

@@ -0,0 +1,105 @@
+import { customers, subscriptions } from "../../core/pg_db/schema.js";
+import ms from "ms";
+import { Temporal } from "temporal-polyfill";
+import { and, desc, eq, inArray } from "drizzle-orm";
+//#region endpoints/subscriptions/utils.ts
+function getPeriodEnd(args) {
+	const periodStart = Temporal.Instant.from(args.now);
+	const milliseconds = ms(args.interval);
+	if (typeof milliseconds !== "number" || Number.isNaN(milliseconds)) throw new Error("You have an invalid interval");
+	if (milliseconds < 0) throw new Error("timestamp cannot include negative intervals");
+	return periodStart.add(Temporal.Duration.from({ milliseconds }));
+}
+function getScheduledPeriodBounds(periodEnd, plan) {
+	if (isFreePlan(plan)) return {
+		start: periodEnd,
+		end: null
+	};
+	const scheduledEnd = getPeriodEnd({
+		now: Temporal.Instant.fromEpochMilliseconds(periodEnd.getTime()),
+		interval: plan.priceInterval
+	});
+	return {
+		start: periodEnd,
+		end: new Date(scheduledEnd.epochMilliseconds)
+	};
+}
+function isFreePlan(plan) {
+	return plan.priceAmount === null && plan.priceInterval === null;
+}
+function classifyChange(previousPlan, plan) {
+	const oldAmount = previousPlan.priceAmount ?? 0;
+	const newAmount = plan.priceAmount ?? 0;
+	if (newAmount > oldAmount) return "upgrade";
+	if (newAmount < oldAmount) return "downgrade";
+	return "lateral";
+}
+async function getCurrentSubscription(db, customerId) {
+	const [currentSubscription] = await db.select().from(subscriptions).where(and(eq(subscriptions.customerId, customerId), inArray(subscriptions.status, [
+		"active",
+		"pending",
+		"scheduled"
+	]))).orderBy(desc(subscriptions.createdAt)).limit(1);
+	return currentSubscription ?? null;
+}
+function buildBaseCheckoutMetadata(params) {
+	const { reference, subscriptionId, customer, plan, kind } = params;
+	return {
+		"nomkit.order_reference": reference,
+		"nomkit.subscription.id": subscriptionId,
+		"nomkit.subscription.customer_id": customer.id,
+		"nomkit.subscription.customer_email": customer.email,
+		"nomkit.subscription.internalPlanId": plan.internalId,
+		"nomkit.subscription.kind": kind
+	};
+}
+function resolveCurrentPeriod(currentSubscription, plan, now) {
+	const periodStart = currentSubscription.currentPeriodStart ? Temporal.Instant.fromEpochMilliseconds(currentSubscription.currentPeriodStart.getTime()) : now;
+	let periodEnd;
+	if (currentSubscription.currentPeriodEnd) periodEnd = Temporal.Instant.fromEpochMilliseconds(currentSubscription.currentPeriodEnd.getTime());
+	else periodEnd = getPeriodEnd({
+		now,
+		interval: plan.priceInterval
+	});
+	return {
+		periodStart,
+		periodEnd
+	};
+}
+function computeUpgradeProration(params) {
+	const { currentSubscription, previousPlan, plan, existingBalance } = params;
+	const oldAmount = previousPlan.priceAmount ?? 0;
+	const newAmount = plan.priceAmount ?? 0;
+	const now = Temporal.Now.instant();
+	const { periodStart, periodEnd } = resolveCurrentPeriod(currentSubscription, plan, now);
+	const totalPeriodMs = Math.max(0, periodStart.until(periodEnd).total("milliseconds"));
+	const remainingMs = Math.max(0, Math.min(totalPeriodMs, now.until(periodEnd).total("milliseconds")));
+	const remainingRatio = totalPeriodMs > 0 ? remainingMs / totalPeriodMs : 0;
+	const unusedAmount = Math.round(oldAmount * remainingRatio);
+	const proratedNewAmount = Math.round(newAmount * remainingRatio);
+	const totalCredit = existingBalance + unusedAmount;
+	const amountDue = proratedNewAmount - totalCredit;
+	return {
+		now,
+		periodEnd,
+		unusedAmount,
+		proratedNewAmount,
+		totalCredit,
+		chargeAmount: amountDue > 0 ? amountDue : 0,
+		newBalance: amountDue < 0 ? Math.abs(amountDue) : 0
+	};
+}
+async function persistProrationOnCustomer(db, customer, previousPlan, plan, proration) {
+	const updatedMetadata = {
+		...customer.metadata ?? {},
+		creditBalance: proration.newBalance.toString(),
+		lastProrationAt: proration.now.toString(),
+		lastProrationFromPlan: previousPlan.id,
+		lastProrationToPlan: plan.id,
+		lastProrationUnusedAmount: proration.unusedAmount.toString(),
+		lastProrationChargeAmount: proration.chargeAmount.toString()
+	};
+	await db.update(customers).set({ metadata: updatedMetadata }).where(eq(customers.id, customer.id));
+}
+//#endregion
+export { buildBaseCheckoutMetadata, classifyChange, computeUpgradeProration, getCurrentSubscription, getPeriodEnd, getScheduledPeriodBounds, isFreePlan, persistProrationOnCustomer, resolveCurrentPeriod };

package/dist/endpoints/webhooks/invoice/api.js

@@ -0,0 +1,28 @@
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
+import { defineNomkitMethod } from "../../../lib/utils.js";
+import { z as z$1 } from "zod";
+//#region endpoints/webhooks/invoice/api.ts
+var api_exports = /* @__PURE__ */ __exportAll({ invoiceWebhook: () => invoiceWebhook });
+/**
+* Internal: endpoint called after the queue processes a subscription billing
+*/
+const invoiceWebhook = defineNomkitMethod({
+	input: z$1.object({
+		billing: z$1.object({}),
+		signature: z$1.string().min(1).max(10),
+		status: z$1.enum([
+			"success",
+			"retrying",
+			"cancelled"
+		]),
+		policy: z$1.string()
+	}),
+	route: {
+		path: "/invoice-webhook",
+		requireHeaders: true
+	}
+}, async (ctx) => {
+	return { status: "event_recieved" };
+});
+//#endregion
+export { api_exports, invoiceWebhook };