@faire-auth/stripe 1.0.0

package/overrides.d.ts

@@ -0,0 +1,32 @@
+import type {
+	AuthRouteConfig,
+	JSONRenderRespond,
+	// LiteralStringUnion,
+} from "@faire-auth/core/types";
+import type { AuthContext } from "faire-auth";
+
+declare module "hono" {
+	export interface ContextRenderer extends JSONRenderRespond {}
+	export interface ContextVariableMap {
+		/**
+		 * Gets set early before hitting route handler
+		 */
+		// path: LiteralStringUnion<Configs["path"]>;
+		/**
+		 * Gets set at route handler for intraroute consistency
+		 */
+		config?: AuthRouteConfig;
+		/**
+		 * Gets set by initContext middleware
+		 */
+		context: AuthContext;
+		/**
+		 * Gets set in endpoint Route Apps
+		 */
+		isServer?: true;
+		/**
+		 * Gets set by initContext middleware
+		 */
+		// api: DefaultAPI;
+	}
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@faire-auth/stripe",
+  "author": "Bereket Engida",
+  "version": "1.0.0",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "stripe",
+    "auth",
+    "stripe"
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/igoforth/faire-auth.git",
+    "directory": "packages/stripe"
+  },
+  "description": "Stripe plugin for Faire Auth",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "dev-source": "./src/index.ts",
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./client": {
+      "dev-source": "./src/client.ts",
+      "import": {
+        "types": "./dist/client.d.mts",
+        "default": "./dist/client.mjs"
+      },
+      "require": {
+        "types": "./dist/client.d.cts",
+        "default": "./dist/client.cjs"
+      }
+    }
+  },
+  "dependencies": {
+    "zod": "4.1.4"
+  },
+  "peerDependencies": {
+    "stripe": "^18 || ^19",
+    "hono": ">=4.3.6",
+    "@faire-auth/core": "1.0.0",
+    "faire-auth": "1.0.0"
+  },
+  "devDependencies": {
+    "stripe": "^18.5.0",
+    "tsdown": "^0.16.0",
+    "publint": "^0.3.15",
+    "@faire-auth/core": "1.0.0",
+    "faire-auth": "1.0.0"
+  },
+  "scripts": {
+    "test": "vitest",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --project tsconfig.json"
+  }
+}

package/src/client.ts

@@ -0,0 +1,35 @@
+import type { FaireAuthClientPlugin } from "faire-auth";
+import type { stripe } from "./index";
+
+export const stripeClient = <
+	O extends {
+		subscription: boolean;
+	},
+>(
+	options?: O,
+) => {
+	return {
+		id: "stripe-client",
+		$InferServerPlugin: {} as ReturnType<
+			typeof stripe<
+				O["subscription"] extends true
+					? {
+							stripeClient: any;
+							stripeWebhookSecret: string;
+							subscription: {
+								enabled: true;
+								plans: [];
+							};
+						}
+					: {
+							stripeClient: any;
+							stripeWebhookSecret: string;
+						}
+			>
+		>,
+		pathMethods: {
+			"/subscription/restore": "POST",
+			"/subscription/billing-portal": "POST",
+		},
+	} satisfies FaireAuthClientPlugin;
+};

package/src/hooks.ts

@@ -0,0 +1,265 @@
+import type { Context } from "@faire-auth/core/types";
+import { logger, type ContextVars } from "faire-auth";
+import type Stripe from "stripe";
+import type { InputSubscription, StripeOptions, Subscription } from "./types";
+import { getPlanByPriceInfo } from "./utils";
+
+export async function onCheckoutSessionCompleted(
+	ctx: Context<ContextVars>,
+	options: StripeOptions,
+	event: Stripe.Event,
+) {
+	try {
+		const client = options.stripeClient;
+		const checkoutSession = event.data.object as Stripe.Checkout.Session;
+		if (checkoutSession.mode === "setup" || !options.subscription?.enabled) {
+			return;
+		}
+		const subscription = await client.subscriptions.retrieve(
+			checkoutSession.subscription as string,
+		);
+		const priceId = subscription.items.data[0]?.price.id;
+		const priceLookupKey = subscription.items.data[0]?.price.lookup_key || null;
+		const plan = await getPlanByPriceInfo(
+			options,
+			priceId as string,
+			priceLookupKey,
+		);
+		if (plan) {
+			const referenceId =
+				checkoutSession?.client_reference_id ||
+				checkoutSession?.metadata?.referenceId;
+			const subscriptionId = checkoutSession?.metadata?.subscriptionId;
+			const seats = subscription.items.data[0]!.quantity;
+			if (referenceId && subscriptionId) {
+				const trial =
+					subscription.trial_start && subscription.trial_end
+						? {
+								trialStart: new Date(subscription.trial_start * 1000),
+								trialEnd: new Date(subscription.trial_end * 1000),
+							}
+						: {};
+
+				let dbSubscription = await ctx
+					.get("context")
+					.adapter.update<InputSubscription>({
+						model: "subscription",
+						update: {
+							plan: plan.name.toLowerCase(),
+							status: subscription.status,
+							updatedAt: new Date(),
+							periodStart: new Date(
+								subscription.items.data[0]!.current_period_start * 1000,
+							),
+							periodEnd: new Date(
+								subscription.items.data[0]!.current_period_end * 1000,
+							),
+							stripeSubscriptionId: checkoutSession.subscription as string,
+							seats,
+							...trial,
+						},
+						where: [
+							{
+								field: "id",
+								value: subscriptionId,
+							},
+						],
+					});
+
+				if (trial.trialStart && plan.freeTrial?.onTrialStart) {
+					await plan.freeTrial.onTrialStart(dbSubscription as Subscription);
+				}
+
+				if (!dbSubscription) {
+					dbSubscription = await ctx
+						.get("context")
+						.adapter.findOne<Subscription>({
+							model: "subscription",
+							where: [
+								{
+									field: "id",
+									value: subscriptionId,
+								},
+							],
+						});
+				}
+				await options.subscription?.onSubscriptionComplete?.(
+					{
+						event,
+						subscription: dbSubscription as Subscription,
+						stripeSubscription: subscription,
+						plan,
+					},
+					ctx,
+				);
+				return;
+			}
+		}
+	} catch (e: any) {
+		logger.error(`Stripe webhook failed. Error: ${e.message}`);
+	}
+}
+
+export async function onSubscriptionUpdated(
+	ctx: Context<ContextVars>,
+	options: StripeOptions,
+	event: Stripe.Event,
+) {
+	try {
+		if (!options.subscription?.enabled) {
+			return;
+		}
+		const subscriptionUpdated = event.data.object as Stripe.Subscription;
+		const priceId = subscriptionUpdated.items.data[0]!.price.id;
+		const priceLookupKey =
+			subscriptionUpdated.items.data[0]!.price.lookup_key || null;
+		const plan = await getPlanByPriceInfo(options, priceId, priceLookupKey);
+
+		const subscriptionId = subscriptionUpdated.metadata?.subscriptionId;
+		const customerId = subscriptionUpdated.customer?.toString();
+		let subscription = await ctx.get("context").adapter.findOne<Subscription>({
+			model: "subscription",
+			where: subscriptionId
+				? [{ field: "id", value: subscriptionId }]
+				: [{ field: "stripeSubscriptionId", value: subscriptionUpdated.id }],
+		});
+		if (!subscription) {
+			const subs = await ctx.get("context").adapter.findMany<Subscription>({
+				model: "subscription",
+				where: [{ field: "stripeCustomerId", value: customerId }],
+			});
+			if (subs.length > 1) {
+				const activeSub = subs.find(
+					(sub: Subscription) =>
+						sub.status === "active" || sub.status === "trialing",
+				);
+				if (!activeSub) {
+					logger.warn(
+						`Stripe webhook error: Multiple subscriptions found for customerId: ${customerId} and no active subscription is found`,
+					);
+					return;
+				}
+				subscription = activeSub;
+			} else {
+				subscription = subs[0]!;
+			}
+		}
+
+		const seats = subscriptionUpdated.items.data[0]!.quantity;
+		await ctx.get("context").adapter.update({
+			model: "subscription",
+			update: {
+				...(plan
+					? {
+							plan: plan.name.toLowerCase(),
+							limits: plan.limits,
+						}
+					: {}),
+				updatedAt: new Date(),
+				status: subscriptionUpdated.status,
+				periodStart: new Date(
+					subscriptionUpdated.items.data[0]!.current_period_start * 1000,
+				),
+				periodEnd: new Date(
+					subscriptionUpdated.items.data[0]!.current_period_end * 1000,
+				),
+				cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
+				seats,
+				stripeSubscriptionId: subscriptionUpdated.id,
+			},
+			where: [
+				{
+					field: "id",
+					value: subscription.id,
+				},
+			],
+		});
+		const subscriptionCanceled =
+			subscriptionUpdated.status === "active" &&
+			subscriptionUpdated.cancel_at_period_end &&
+			!subscription.cancelAtPeriodEnd; //if this is true, it means the subscription was canceled before the event was triggered
+		if (subscriptionCanceled) {
+			await options.subscription.onSubscriptionCancel?.({
+				subscription,
+				...(subscriptionUpdated.cancellation_details !== undefined && {
+					cancellationDetails: subscriptionUpdated.cancellation_details,
+				}),
+				stripeSubscription: subscriptionUpdated,
+				event,
+			});
+		}
+		await options.subscription.onSubscriptionUpdate?.({
+			event,
+			subscription,
+		});
+		if (plan) {
+			if (
+				subscriptionUpdated.status === "active" &&
+				subscription.status === "trialing" &&
+				plan.freeTrial?.onTrialEnd
+			) {
+				await plan.freeTrial.onTrialEnd({ subscription }, ctx);
+			}
+			if (
+				subscriptionUpdated.status === "incomplete_expired" &&
+				subscription.status === "trialing" &&
+				plan.freeTrial?.onTrialExpired
+			) {
+				await plan.freeTrial.onTrialExpired(subscription, ctx);
+			}
+		}
+	} catch (error: any) {
+		logger.error(`Stripe webhook failed. Error: ${error}`);
+	}
+}
+
+export async function onSubscriptionDeleted(
+	ctx: Context<ContextVars>,
+	options: StripeOptions,
+	event: Stripe.Event,
+) {
+	if (!options.subscription?.enabled) {
+		return;
+	}
+	try {
+		const subscriptionDeleted = event.data.object as Stripe.Subscription;
+		const subscriptionId = subscriptionDeleted.id;
+		const subscription = await ctx
+			.get("context")
+			.adapter.findOne<Subscription>({
+				model: "subscription",
+				where: [
+					{
+						field: "stripeSubscriptionId",
+						value: subscriptionId,
+					},
+				],
+			});
+		if (subscription) {
+			await ctx.get("context").adapter.update({
+				model: "subscription",
+				where: [
+					{
+						field: "id",
+						value: subscription.id,
+					},
+				],
+				update: {
+					status: "canceled",
+					updatedAt: new Date(),
+				},
+			});
+			await options.subscription.onSubscriptionDeleted?.({
+				event,
+				stripeSubscription: subscriptionDeleted,
+				subscription,
+			});
+		} else {
+			logger.warn(
+				`Stripe webhook error: Subscription not found for subscriptionId: ${subscriptionId}`,
+			);
+		}
+	} catch (error: any) {
+		logger.error(`Stripe webhook failed. Error: ${error}`);
+	}
+}