paykitjs 0.0.1-alpha.1

package/dist/providers/stripe.js

@@ -0,0 +1,547 @@
+import { PAYKIT_ERROR_CODES, PayKitError } from "../core/errors.js";
+import StripeSdk from "stripe";
+//#region src/providers/stripe.ts
+function toDate(value) {
+	return typeof value === "number" ? /* @__PURE__ */ new Date(value * 1e3) : null;
+}
+function getLatestPeriodEnd(subscription) {
+	const firstItem = subscription.items.data[0];
+	if (!firstItem) return subscription.current_period_end ?? null;
+	return subscription.items.data.reduce((latest, item) => {
+		return Math.max(latest, item.current_period_end);
+	}, firstItem.current_period_end);
+}
+function getEarliestPeriodStart(subscription) {
+	const firstItem = subscription.items.data[0];
+	if (!firstItem) return subscription.current_period_start ?? null;
+	return subscription.items.data.reduce((earliest, item) => {
+		return Math.min(earliest, item.current_period_start);
+	}, firstItem.current_period_start);
+}
+function getStripeCustomerId(customer) {
+	if (!customer) return null;
+	return typeof customer === "string" ? customer : customer.id;
+}
+function normalizeStripePaymentMethod(paymentMethod) {
+	return {
+		expiryMonth: paymentMethod.card?.exp_month ?? void 0,
+		expiryYear: paymentMethod.card?.exp_year ?? void 0,
+		last4: paymentMethod.card?.last4 ?? void 0,
+		providerMethodId: paymentMethod.id,
+		type: paymentMethod.type
+	};
+}
+function normalizeStripePaymentIntent(paymentIntent) {
+	const providerMethodId = typeof paymentIntent.payment_method === "string" ? paymentIntent.payment_method : paymentIntent.payment_method?.id;
+	return {
+		amount: paymentIntent.amount_received || paymentIntent.amount,
+		createdAt: /* @__PURE__ */ new Date(paymentIntent.created * 1e3),
+		currency: paymentIntent.currency,
+		description: paymentIntent.description,
+		metadata: Object.keys(paymentIntent.metadata).length > 0 ? paymentIntent.metadata : void 0,
+		providerMethodId,
+		providerPaymentId: paymentIntent.id,
+		status: paymentIntent.status
+	};
+}
+function normalizeStripeInvoice(invoice) {
+	return {
+		currency: invoice.currency,
+		hostedUrl: invoice.hosted_invoice_url,
+		periodEndAt: toDate(invoice.period_end),
+		periodStartAt: toDate(invoice.period_start),
+		providerInvoiceId: invoice.id,
+		status: invoice.status,
+		totalAmount: invoice.total ?? 0
+	};
+}
+function normalizeStripeSubscription(subscription) {
+	const firstItem = subscription.items.data[0];
+	const providerPriceId = typeof firstItem?.price === "string" ? firstItem.price : firstItem?.price.id;
+	const periodStart = getEarliestPeriodStart(subscription);
+	const periodEnd = getLatestPeriodEnd(subscription);
+	const cancelAt = subscription.cancel_at;
+	return {
+		cancelAtPeriodEnd: subscription.cancel_at_period_end || cancelAt != null && cancelAt > 0,
+		canceledAt: toDate(subscription.canceled_at),
+		currentPeriodEndAt: toDate(periodEnd),
+		currentPeriodStartAt: toDate(periodStart),
+		endedAt: toDate(subscription.ended_at),
+		providerPriceId: providerPriceId ?? null,
+		providerSubscriptionId: subscription.id,
+		providerSubscriptionScheduleId: (typeof subscription.schedule === "string" ? subscription.schedule : subscription.schedule?.id) ?? null,
+		status: subscription.status
+	};
+}
+function normalizeStripeTestClock(clock) {
+	return {
+		frozenTime: /* @__PURE__ */ new Date(clock.frozen_time * 1e3),
+		id: clock.id,
+		name: clock.name ?? null,
+		status: clock.status
+	};
+}
+function assertStripeTestKey(options) {
+	if (!options.secretKey.startsWith("sk_test_")) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.PROVIDER_TEST_KEY_REQUIRED);
+}
+async function retrieveExpandedSubscription(client, providerSubscriptionId) {
+	return await client.subscriptions.retrieve(providerSubscriptionId, { expand: [
+		"items.data.price",
+		"latest_invoice.payment_intent",
+		"schedule"
+	] });
+}
+function normalizeRequiredAction(paymentIntent) {
+	const nextActionType = paymentIntent?.next_action?.type;
+	if (!nextActionType) return null;
+	return {
+		clientSecret: paymentIntent.client_secret ?? void 0,
+		paymentIntentId: paymentIntent.id,
+		type: nextActionType
+	};
+}
+function isPaymentMethodAttachedToCustomer(paymentMethod, stripeCustomerId) {
+	if (!stripeCustomerId) return false;
+	return getStripeCustomerId(paymentMethod.customer) === stripeCustomerId;
+}
+async function getCheckoutPaymentDetails(client, session) {
+	const stripeCustomerId = getStripeCustomerId(session.customer);
+	if (!stripeCustomerId) return {
+		paymentIntent: null,
+		paymentMethod: null
+	};
+	if (session.mode === "payment" || session.mode === "subscription") {
+		const paymentIntentId = typeof session.payment_intent === "string" ? session.payment_intent : session.payment_intent?.id;
+		if (paymentIntentId) {
+			const paymentIntent = await client.paymentIntents.retrieve(paymentIntentId, { expand: ["payment_method"] });
+			const paymentMethod = paymentIntent.payment_method;
+			if (paymentMethod && typeof paymentMethod !== "string") return {
+				paymentIntent,
+				paymentMethod: isPaymentMethodAttachedToCustomer(paymentMethod, stripeCustomerId) ? paymentMethod : null
+			};
+		}
+		if (session.mode === "subscription") {
+			const subscriptionId = typeof session.subscription === "string" ? session.subscription : session.subscription?.id;
+			if (subscriptionId) {
+				const paymentMethod = (await client.subscriptions.retrieve(subscriptionId, { expand: ["default_payment_method"] })).default_payment_method;
+				if (paymentMethod && typeof paymentMethod !== "string") return {
+					paymentIntent: null,
+					paymentMethod: isPaymentMethodAttachedToCustomer(paymentMethod, stripeCustomerId) ? paymentMethod : null
+				};
+			}
+		}
+		return {
+			paymentIntent: null,
+			paymentMethod: null
+		};
+	}
+	if (session.mode === "setup") {
+		const setupIntentId = typeof session.setup_intent === "string" ? session.setup_intent : session.setup_intent?.id;
+		if (!setupIntentId) return {
+			paymentIntent: null,
+			paymentMethod: null
+		};
+		const paymentMethod = (await client.setupIntents.retrieve(setupIntentId, { expand: ["payment_method"] })).payment_method;
+		if (!paymentMethod || typeof paymentMethod === "string") return {
+			paymentIntent: null,
+			paymentMethod: null
+		};
+		return {
+			paymentIntent: null,
+			paymentMethod: isPaymentMethodAttachedToCustomer(paymentMethod, stripeCustomerId) ? paymentMethod : null
+		};
+	}
+	return {
+		paymentIntent: null,
+		paymentMethod: null
+	};
+}
+async function createCheckoutCompletedEvents(client, event) {
+	if (event.type !== "checkout.session.completed") return [];
+	const session = event.data.object;
+	const stripeCustomerId = getStripeCustomerId(session.customer);
+	const providerCustomerId = session.client_reference_id ?? stripeCustomerId;
+	if (!providerCustomerId) return [];
+	const events = [];
+	const { paymentIntent, paymentMethod } = await getCheckoutPaymentDetails(client, session);
+	const providerSubscriptionId = typeof session.subscription === "string" ? session.subscription : session.subscription?.id ?? null;
+	const providerInvoiceId = typeof session.invoice === "string" ? session.invoice : session.invoice?.id ?? null;
+	const expandedSubscription = session.mode === "subscription" && providerSubscriptionId ? await retrieveExpandedSubscription(client, providerSubscriptionId) : null;
+	const expandedInvoice = providerInvoiceId != null ? await client.invoices.retrieve(providerInvoiceId, { expand: ["payment_intent"] }) : null;
+	if (paymentMethod) {
+		const normalizedPaymentMethod = {
+			...normalizeStripePaymentMethod(paymentMethod),
+			isDefault: session.mode === "subscription"
+		};
+		events.push({
+			actions: [{
+				data: {
+					paymentMethod: normalizedPaymentMethod,
+					providerCustomerId
+				},
+				type: "payment_method.upsert"
+			}],
+			name: "payment_method.attached",
+			payload: {
+				paymentMethod: normalizedPaymentMethod,
+				providerCustomerId
+			}
+		});
+	}
+	if (session.mode === "payment" && paymentIntent?.status === "succeeded") {
+		const normalizedPayment = normalizeStripePaymentIntent(paymentIntent);
+		events.push({
+			actions: [{
+				data: {
+					payment: normalizedPayment,
+					providerCustomerId
+				},
+				type: "payment.upsert"
+			}],
+			name: "payment.succeeded",
+			payload: {
+				payment: normalizedPayment,
+				providerCustomerId
+			}
+		});
+	}
+	const sessionMetadata = session.metadata ?? {};
+	events.push({
+		name: "checkout.completed",
+		payload: {
+			checkoutSessionId: session.id,
+			invoice: expandedInvoice ? normalizeStripeInvoice(expandedInvoice) : void 0,
+			metadata: Object.keys(sessionMetadata).length > 0 ? sessionMetadata : void 0,
+			mode: session.mode ?? void 0,
+			paymentStatus: session.payment_status,
+			providerCustomerId,
+			providerEventId: event.id,
+			providerInvoiceId: providerInvoiceId ?? void 0,
+			providerSubscriptionId: providerSubscriptionId ?? void 0,
+			status: session.status,
+			subscription: expandedSubscription ? normalizeStripeSubscription(expandedSubscription) : void 0
+		}
+	});
+	return events;
+}
+async function createSubscriptionEvents(event) {
+	if (event.type !== "customer.subscription.created" && event.type !== "customer.subscription.updated" && event.type !== "customer.subscription.deleted") return [];
+	const subscription = event.data.object;
+	const providerCustomerId = getStripeCustomerId(subscription.customer);
+	if (!providerCustomerId) return [];
+	if (event.type === "customer.subscription.deleted") return [{
+		actions: [{
+			data: {
+				providerCustomerId,
+				providerSubscriptionId: subscription.id
+			},
+			type: "subscription.delete"
+		}],
+		name: "subscription.deleted",
+		payload: {
+			providerCustomerId,
+			providerEventId: event.id,
+			providerSubscriptionId: subscription.id
+		}
+	}];
+	const normalizedSubscription = normalizeStripeSubscription(subscription);
+	return [{
+		actions: [{
+			data: {
+				providerCustomerId,
+				subscription: normalizedSubscription
+			},
+			type: "subscription.upsert"
+		}],
+		name: "subscription.updated",
+		payload: {
+			providerCustomerId,
+			providerEventId: event.id,
+			subscription: normalizedSubscription
+		}
+	}];
+}
+function createInvoiceEvents(event) {
+	if (event.type !== "invoice.created" && event.type !== "invoice.finalized" && event.type !== "invoice.paid" && event.type !== "invoice.payment_failed" && event.type !== "invoice.updated") return [];
+	const invoice = event.data.object;
+	const providerCustomerId = getStripeCustomerId(invoice.customer);
+	if (!providerCustomerId) return [];
+	const providerSubscriptionId = typeof invoice.subscription === "string" ? invoice.subscription : invoice.subscription?.id ?? null;
+	const normalizedInvoice = normalizeStripeInvoice(invoice);
+	return [{
+		actions: [{
+			data: {
+				invoice: normalizedInvoice,
+				providerCustomerId,
+				providerSubscriptionId
+			},
+			type: "invoice.upsert"
+		}],
+		name: "invoice.updated",
+		payload: {
+			invoice: normalizedInvoice,
+			providerCustomerId,
+			providerEventId: event.id,
+			providerSubscriptionId
+		}
+	}];
+}
+function createDetachedPaymentMethodEvents(event) {
+	if (event.type !== "payment_method.detached") return [];
+	const paymentMethod = event.data.object;
+	return [{
+		actions: [{
+			data: { providerMethodId: paymentMethod.id },
+			type: "payment_method.delete"
+		}],
+		name: "payment_method.detached",
+		payload: {
+			providerEventId: event.id,
+			providerMethodId: paymentMethod.id
+		}
+	}];
+}
+function createStripeProvider(client, options) {
+	const currency = options.currency ?? "usd";
+	return {
+		async upsertCustomer(data) {
+			let testClock;
+			if (data.createTestClock) {
+				assertStripeTestKey(options);
+				testClock = normalizeStripeTestClock(await client.testHelpers.testClocks.create({
+					frozen_time: Math.floor(Date.now() / 1e3),
+					name: data.id
+				}));
+			}
+			return { providerCustomer: {
+				id: (await client.customers.create({
+					email: data.email,
+					metadata: {
+						customerId: data.id,
+						...data.metadata
+					},
+					name: data.name,
+					test_clock: testClock?.id
+				})).id,
+				frozenTime: testClock?.frozenTime.toISOString(),
+				testClockId: testClock?.id
+			} };
+		},
+		async deleteCustomer(data) {
+			await client.customers.del(data.providerCustomerId);
+		},
+		async getTestClock(data) {
+			return normalizeStripeTestClock(await client.testHelpers.testClocks.retrieve(data.testClockId));
+		},
+		async advanceTestClock(data) {
+			assertStripeTestKey(options);
+			await client.testHelpers.testClocks.advance(data.testClockId, { frozen_time: Math.floor(data.frozenTime.getTime() / 1e3) });
+			for (let i = 0; i < 60; i++) {
+				const clock = await client.testHelpers.testClocks.retrieve(data.testClockId);
+				if (clock.status === "ready") return normalizeStripeTestClock(clock);
+				await new Promise((resolve) => setTimeout(resolve, 2e3));
+			}
+			throw new Error(`Test clock ${data.testClockId} did not reach 'ready' status`);
+		},
+		async attachPaymentMethod(data) {
+			const session = await client.checkout.sessions.create({
+				cancel_url: data.returnURL,
+				client_reference_id: data.providerCustomerId,
+				customer: data.providerCustomerId,
+				mode: "setup",
+				success_url: data.returnURL
+			});
+			if (!session.url) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.PROVIDER_SESSION_INVALID);
+			return { url: session.url };
+		},
+		async createSubscriptionCheckout(data) {
+			const sessionParams = {
+				cancel_url: data.cancelUrl ?? data.successUrl,
+				client_reference_id: data.providerCustomerId,
+				customer: data.providerCustomerId,
+				line_items: [{
+					price: data.providerPriceId,
+					quantity: 1
+				}],
+				metadata: data.metadata,
+				mode: "subscription",
+				success_url: data.successUrl
+			};
+			const session = await client.checkout.sessions.create(sessionParams);
+			if (!session.url) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.PROVIDER_SESSION_INVALID);
+			return {
+				paymentUrl: session.url,
+				providerCheckoutSessionId: session.id
+			};
+		},
+		async createSubscription(data) {
+			const createParams = {
+				customer: data.providerCustomerId,
+				items: [{ price: data.providerPriceId }],
+				payment_behavior: "default_incomplete",
+				expand: ["latest_invoice.payment_intent"]
+			};
+			const createdSubscription = await client.subscriptions.create(createParams);
+			const latestInvoice = createdSubscription.latest_invoice;
+			return {
+				invoice: latestInvoice && typeof latestInvoice !== "string" ? normalizeStripeInvoice(latestInvoice) : null,
+				paymentUrl: null,
+				requiredAction: normalizeRequiredAction((latestInvoice && typeof latestInvoice !== "string" ? latestInvoice.payment_intent : null) ?? null),
+				subscription: normalizeStripeSubscription(createdSubscription)
+			};
+		},
+		async updateSubscription(data) {
+			const currentItem = (await retrieveExpandedSubscription(client, data.providerSubscriptionId)).items.data[0];
+			if (!currentItem) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.PROVIDER_SUBSCRIPTION_MISSING_ITEMS);
+			const updatedSubscription = await client.subscriptions.update(data.providerSubscriptionId, {
+				items: [{
+					id: currentItem.id,
+					price: data.providerPriceId
+				}],
+				payment_behavior: "pending_if_incomplete",
+				proration_behavior: "always_invoice",
+				expand: ["latest_invoice.payment_intent"]
+			});
+			const latestInvoice = updatedSubscription.latest_invoice;
+			return {
+				invoice: latestInvoice && typeof latestInvoice !== "string" ? normalizeStripeInvoice(latestInvoice) : null,
+				paymentUrl: null,
+				requiredAction: normalizeRequiredAction((latestInvoice && typeof latestInvoice !== "string" ? latestInvoice.payment_intent : null) ?? null),
+				subscription: normalizeStripeSubscription(updatedSubscription)
+			};
+		},
+		async scheduleSubscriptionChange(data) {
+			if (!data.providerPriceId) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.PROVIDER_PRICE_REQUIRED);
+			const currentSub = await client.subscriptions.retrieve(data.providerSubscriptionId, { expand: ["items"] });
+			const periodEndSeconds = getLatestPeriodEnd(currentSub);
+			if (typeof periodEndSeconds !== "number") throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.PROVIDER_SUBSCRIPTION_MISSING_PERIOD);
+			const currentItems = currentSub.items.data.map((item) => ({
+				price: item.price.id,
+				quantity: 1
+			}));
+			let schedule;
+			if (data.providerSubscriptionScheduleId) schedule = await client.subscriptionSchedules.retrieve(data.providerSubscriptionScheduleId);
+			else {
+				const existingScheduleId = typeof currentSub.schedule === "string" ? currentSub.schedule : currentSub.schedule?.id ?? null;
+				schedule = existingScheduleId ? await client.subscriptionSchedules.retrieve(existingScheduleId) : await client.subscriptionSchedules.create({ from_subscription: data.providerSubscriptionId });
+			}
+			const scheduleId = schedule.id;
+			const currentPhaseStart = schedule.phases[0]?.start_date ?? Math.floor(Date.now() / 1e3);
+			await client.subscriptionSchedules.update(scheduleId, {
+				end_behavior: "release",
+				phases: [{
+					items: currentItems,
+					start_date: currentPhaseStart,
+					end_date: periodEndSeconds
+				}, {
+					items: [{
+						price: data.providerPriceId,
+						quantity: 1
+					}],
+					start_date: periodEndSeconds
+				}]
+			});
+			return {
+				paymentUrl: null,
+				requiredAction: null,
+				subscription: normalizeStripeSubscription(await retrieveExpandedSubscription(client, data.providerSubscriptionId))
+			};
+		},
+		async cancelSubscription(data) {
+			const currentSubscription = await client.subscriptions.retrieve(data.providerSubscriptionId);
+			let scheduleId = data.providerSubscriptionScheduleId ?? null;
+			if (!scheduleId) scheduleId = typeof currentSubscription.schedule === "string" ? currentSubscription.schedule : currentSubscription.schedule?.id ?? null;
+			if (scheduleId) {
+				const schedule = await client.subscriptionSchedules.retrieve(scheduleId);
+				if (schedule.status !== "released" && schedule.status !== "canceled") await client.subscriptionSchedules.release(scheduleId);
+			}
+			return {
+				paymentUrl: null,
+				requiredAction: null,
+				subscription: normalizeStripeSubscription(await client.subscriptions.update(data.providerSubscriptionId, { cancel_at_period_end: true }))
+			};
+		},
+		async listActiveSubscriptions(data) {
+			return (await client.subscriptions.list({
+				customer: data.providerCustomerId,
+				status: "active"
+			})).data.map((sub) => ({ providerSubscriptionId: sub.id }));
+		},
+		async resumeSubscription(data) {
+			let scheduleId = data.providerSubscriptionScheduleId ?? null;
+			if (!scheduleId) {
+				const sub = await client.subscriptions.retrieve(data.providerSubscriptionId);
+				scheduleId = typeof sub.schedule === "string" ? sub.schedule : sub.schedule?.id ?? null;
+			}
+			if (scheduleId) {
+				const schedule = await client.subscriptionSchedules.retrieve(scheduleId);
+				if (schedule.status !== "released" && schedule.status !== "canceled") await client.subscriptionSchedules.release(scheduleId);
+			}
+			return {
+				paymentUrl: null,
+				requiredAction: null,
+				subscription: normalizeStripeSubscription(await client.subscriptions.update(data.providerSubscriptionId, { cancel_at_period_end: false }))
+			};
+		},
+		async detachPaymentMethod(data) {
+			await client.paymentMethods.detach(data.providerMethodId);
+		},
+		async syncProduct(data) {
+			let providerProductId = data.existingProviderProductId;
+			if (!providerProductId) providerProductId = (await client.products.create({
+				metadata: { paykit_product_id: data.id },
+				name: data.name
+			})).id;
+			else await client.products.update(providerProductId, { name: data.name });
+			if (data.existingProviderPriceId) return {
+				providerPriceId: data.existingProviderPriceId,
+				providerProductId
+			};
+			const priceParams = {
+				currency,
+				product: providerProductId,
+				unit_amount: data.priceAmount
+			};
+			if (data.priceInterval) priceParams.recurring = { interval: data.priceInterval };
+			return {
+				providerPriceId: (await client.prices.create(priceParams)).id,
+				providerProductId
+			};
+		},
+		async createInvoice(data) {
+			const stripeInvoice = await client.invoices.create({
+				auto_advance: data.autoAdvance ?? true,
+				collection_method: "charge_automatically",
+				customer: data.providerCustomerId,
+				currency
+			});
+			if (data.lines.length > 0) await client.invoices.addLines(stripeInvoice.id, { lines: data.lines.map((line) => ({
+				amount: line.amount,
+				description: line.description
+			})) });
+			return normalizeStripeInvoice(await client.invoices.finalizeInvoice(stripeInvoice.id));
+		},
+		async handleWebhook(data) {
+			const signature = data.headers["stripe-signature"];
+			if (!signature) throw PayKitError.from("BAD_REQUEST", PAYKIT_ERROR_CODES.PROVIDER_SIGNATURE_MISSING);
+			const event = client.webhooks.constructEvent(data.body, signature, options.webhookSecret);
+			return [
+				...await createCheckoutCompletedEvents(client, event),
+				...await createSubscriptionEvents(event),
+				...createInvoiceEvents(event),
+				...createDetachedPaymentMethodEvents(event)
+			];
+		},
+		async createPortalSession(data) {
+			return { url: (await client.billingPortal.sessions.create({
+				customer: data.providerCustomerId,
+				return_url: data.returnUrl
+			})).url };
+		}
+	};
+}
+function createStripeRuntime(options) {
+	return createStripeProvider(new StripeSdk(options.secretKey), options);
+}
+//#endregion
+export { createStripeRuntime };

package/dist/subscription/subscription.api.js

@@ -0,0 +1,24 @@
+import { subscribeToPlan } from "./subscription.service.js";
+import { definePayKitMethod } from "../api/define-route.js";
+import { subscribeBodySchema } from "./subscription.types.js";
+//#region src/subscription/subscription.api.ts
+/** Applies a subscription change for the resolved customer. */
+const subscribe = definePayKitMethod({
+	input: subscribeBodySchema,
+	requireCustomer: true,
+	route: {
+		client: true,
+		method: "POST",
+		path: "/subscribe"
+	}
+}, async (ctx) => {
+	return subscribeToPlan(ctx.paykit, {
+		customerId: ctx.customer.id,
+		forceCheckout: ctx.input.forceCheckout,
+		planId: ctx.input.planId,
+		successUrl: ctx.input.successUrl,
+		cancelUrl: ctx.input.cancelUrl
+	});
+});
+//#endregion
+export { subscribe };