@fragno-dev/stripe 0.0.2 → 0.1.1

package/dist/node/index.js

@@ -1,8 +1,8 @@
-import { createFragment, defineRoute, defineRoutes } from "@fragno-dev/core";
 import { createClientBuilder } from "@fragno-dev/core/client";
-import { defineFragmentWithDatabase } from "@fragno-dev/db/fragment";
 import Stripe from "stripe";
 import { column, idColumn, schema } from "@fragno-dev/db/schema";
+import { defineFragment, defineRoutes, instantiate } from "@fragno-dev/core";
+import { withDatabase } from "@fragno-dev/db";
 import { z } from "zod";
 import { FragnoApiError } from "@fragno-dev/core/api";
 
@@ -43,10 +43,108 @@ function stripeSubscriptionToInternalSubscription(stripeSubscription) {
 		trialEnd: toDate(stripeSubscription.trial_end),
 		cancelAtPeriodEnd: stripeSubscription.cancel_at_period_end ?? false,
 		cancelAt: toDate(stripeSubscription.cancel_at),
+		createdAt: toDate(stripeSubscription.created),
 		seats: firstItem.quantity ?? null
 	};
 }
 
+//#endregion
+//#region src/definition.ts
+const LOG_PREFIX = "[Stripe Fragment]";
+const defaultLogger = {
+	info: (...data) => console.info(LOG_PREFIX, ...data),
+	error: (...data) => console.error(LOG_PREFIX, ...data),
+	warn: (...data) => console.warn(LOG_PREFIX, ...data),
+	debug: (...data) => console.debug(LOG_PREFIX, ...data),
+	log: (...data) => console.log(LOG_PREFIX, ...data)
+};
+const asExternalSubscription = (subscription) => ({
+	...subscription,
+	id: subscription.id.externalId,
+	status: subscription.status
+});
+function createStripeServices(deps, db) {
+	const services = {
+		getStripeClient() {
+			return deps.stripe;
+		},
+		createSubscription: async (data) => {
+			return (await db.create("subscription", data)).externalId;
+		},
+		updateSubscription: async (id, data) => {
+			await db.update("subscription", id, (b) => b.set({
+				...data,
+				updatedAt: new Date()
+			}));
+		},
+		getSubscriptionByStripeId: async (stripeSubscriptionId) => {
+			const result = await db.findFirst("subscription", (b) => b.whereIndex("idx_stripe_subscription_id", (eb) => eb("stripeSubscriptionId", "=", stripeSubscriptionId)));
+			if (!result) return null;
+			return asExternalSubscription(result);
+		},
+		getSubscriptionsByStripeCustomerId: async (stripeCustomerId) => {
+			return (await db.find("subscription", (b) => b.whereIndex("idx_stripe_customer_id", (eb) => eb("stripeCustomerId", "=", stripeCustomerId)))).map(asExternalSubscription);
+		},
+		getSubscriptionById: async (id) => {
+			const result = await db.findFirst("subscription", (b) => b.whereIndex("primary", (eb) => eb("id", "=", id)));
+			if (!result) return null;
+			return asExternalSubscription(result);
+		},
+		getSubscriptionsByReferenceId: async (referenceId) => {
+			const result = await db.find("subscription", (b) => b.whereIndex("idx_reference_id", (eb) => eb("referenceId", "=", referenceId)));
+			if (result.length == 0) return [];
+			return result.map(asExternalSubscription);
+		},
+		deleteSubscription: async (id) => {
+			await db.delete("subscription", id);
+		},
+		deleteSubscriptionsByReferenceId: async (referenceId) => {
+			const uow = db.createUnitOfWork().find("subscription", (b) => b.whereIndex("idx_reference_id", (eb) => eb("referenceId", "=", referenceId)));
+			const [subscriptions] = await uow.executeRetrieve();
+			subscriptions.forEach((sub) => sub && uow.delete("subscription", sub.id));
+			return await uow.executeMutations();
+		},
+		getAllSubscriptions: async () => {
+			return (await db.find("subscription", (b) => b.whereIndex("primary"))).map(asExternalSubscription);
+		},
+		syncStripeSubscriptions: async (referenceId, stripeCustomerId) => {
+			const stripeSubscriptions = await deps.stripe.subscriptions.list({
+				customer: stripeCustomerId,
+				status: "all"
+			});
+			if (stripeSubscriptions.data.length === 0) {
+				await services.deleteSubscriptionsByReferenceId(referenceId);
+				return { success: true };
+			}
+			const uow = db.createUnitOfWork().find("subscription", (b) => b.whereIndex("idx_reference_id", (eb) => eb("referenceId", "=", referenceId)));
+			const [existingSubscriptions] = await uow.executeRetrieve();
+			for (const stripeSubscription of stripeSubscriptions.data) {
+				const existingSubscription = existingSubscriptions.find((sub) => sub.stripeSubscriptionId === stripeSubscription.id);
+				if (existingSubscription) uow.update("subscription", existingSubscription.id, (b) => b.set({
+					...stripeSubscriptionToInternalSubscription(stripeSubscription),
+					updatedAt: new Date()
+				}).check());
+				else uow.create("subscription", {
+					...stripeSubscriptionToInternalSubscription(stripeSubscription),
+					referenceId: referenceId ?? null,
+					updatedAt: new Date()
+				});
+			}
+			return uow.executeMutations();
+		}
+	};
+	return services;
+}
+const stripeFragmentDefinition = defineFragment("stripe").extend(withDatabase(stripeSchema)).withDependencies(({ config }) => {
+	const stripeClient = new Stripe(config.stripeSecretKey, config.stripeClientOptions ?? {});
+	return {
+		stripe: stripeClient,
+		log: config.logger ? config.logger : defaultLogger
+	};
+}).providesBaseService(({ deps }) => {
+	return { ...createStripeServices(deps, deps.db) };
+}).build();
+
 //#endregion
 //#region src/webhook/handlers.ts
 /**
@@ -161,7 +259,7 @@ async function customerSubscriptionUpdatedHandler({ event, services, deps }) {
 	const customerId = getId(stripeSubscription.customer);
 	let subscription = await services.getSubscriptionByStripeId(stripeSubscription.id);
 	if (!subscription) {
-		const customerSubs = await services.getSubscriptionByStripeCustomerId(customerId);
+		const customerSubs = await services.getSubscriptionsByStripeCustomerId(customerId);
 		if (customerSubs.length > 1) {
 			subscription = customerSubs.find((sub) => sub.status === "active" || sub.status === "trialing") ?? null;
 			if (!subscription) {
@@ -212,7 +310,7 @@ const eventToHandler = {
 
 //#endregion
 //#region src/routes/webhooks.ts
-const webhookRoutesFactory = defineRoutes().create(({ config, deps, services }) => {
+const webhookRoutesFactory = defineRoutes(stripeFragmentDefinition).create(({ config, deps, services, defineRoute }) => {
 	return [defineRoute({
 		method: "POST",
 		path: "/webhook",
@@ -295,9 +393,38 @@ const CustomerResponseSchema = z.object({
 	preferred_locales: z.array(z.string()).nullable().optional()
 });
 
+//#endregion
+//#region src/routes/errors.ts
+function isStripeError(error) {
+	return typeof error === "object" && error !== null && "type" in error && typeof error.type === "string" && "message" in error && typeof error.message === "string";
+}
+function stripeToApiError(error) {
+	if (isStripeError(error) && error.type === "StripeInvalidRequestError" && error.message.includes("there are no changes to confirm")) return new FragnoApiError({
+		message: "Trying to upgrade to same subscription plan",
+		code: "UPGRADE_HAS_NO_EFFECT"
+	}, 500);
+	if (isStripeError(error) && error.type === "StripeInvalidRequestError" && error.message.includes("is already set to be canceled at period end")) return new FragnoApiError({
+		message: "Subscription is already set to be canceled at period end",
+		code: "SUBSCRIPTION_ALREADY_CANCELED"
+	}, 500);
+	if (isStripeError(error) && error.type === "StripeInvalidRequestError" && error.message.includes("the subscription update feature in the portal configuration is disabled")) return new FragnoApiError({
+		message: "Subscription cannot be updated to this plan",
+		code: "SUBSCRIPTION_UPDATE_NOT_ALLOWED"
+	}, 500);
+	if (isStripeError(error) && error.type === "StripeInvalidRequestError" && error.message.includes("does not include `promotion_code`")) return new FragnoApiError({
+		message: "Cannot apply promotion code when updating subscription",
+		code: "SUBSCRIPTION_UPDATE_PROMO_CODE_NOT_ALLOWED"
+	}, 500);
+	if (isStripeError(error) && error.type === "StripeInvalidRequestError" && error.code == "promotion_code_customer_not_first_time") return new FragnoApiError({
+		message: "This promotion code cannot be redeemed because you have already used it before.",
+		code: "PROMOTION_CODE_CUSTOMER_NOT_FIRST_TIME"
+	}, 500);
+	return error;
+}
+
 //#endregion
 //#region src/routes/customers.ts
-const customersRoutesFactory = defineRoutes().create(({ deps, config }) => {
+const customersRoutesFactory = defineRoutes(stripeFragmentDefinition).create(({ deps, config, defineRoute }) => {
 	return [defineRoute({
 		method: "GET",
 		path: "/admin/customers",
@@ -325,6 +452,35 @@ const customersRoutesFactory = defineRoutes().create(({ deps, config }) => {
 				hasMore: customers.has_more
 			});
 		}
+	}), defineRoute({
+		method: "POST",
+		path: "/portal",
+		inputSchema: z.object({ returnUrl: z.url().describe("URL to redirect to after completing billing portal") }),
+		outputSchema: z.object({
+			url: z.url().describe("URL to redirect to after cancellation"),
+			redirect: z.boolean().describe("Whether to redirect to the URL")
+		}),
+		errorCodes: ["NO_STRIPE_CUSTOMER_FOR_ENTITY"],
+		handler: async (context, { json, error }) => {
+			const body = await context.input.valid();
+			const { stripeCustomerId } = await config.resolveEntityFromRequest(context);
+			if (!stripeCustomerId) return error({
+				message: "No stripe customer to create billing portal for",
+				code: "NO_STRIPE_CUSTOMER_FOR_ENTITY"
+			}, 400);
+			try {
+				const portalSession = await deps.stripe.billingPortal.sessions.create({
+					customer: stripeCustomerId,
+					return_url: body.returnUrl
+				});
+				return json({
+					url: portalSession.url,
+					redirect: true
+				});
+			} catch (err) {
+				throw stripeToApiError(err);
+			}
+		}
 	})];
 });
 
@@ -361,33 +517,14 @@ const SubscriptionUpgradeRequestSchema = z.object({
 	quantity: z.number().positive().describe("Number of seats"),
 	successUrl: z.url().describe("Redirect URL after successful checkout"),
 	cancelUrl: z.url().describe("Redirect URL if checkout is cancelled"),
-	returnUrl: z.string().optional().describe("Return URL for billing portal")
+	returnUrl: z.string().optional().describe("Return URL for billing portal"),
+	promotionCode: z.string().optional().describe("Promotion code to apply"),
+	subscriptionId: z.string().optional().describe("Subscription ID to upgrade, if none provided assume the active subscription of the user.")
 });
 
-//#endregion
-//#region src/routes/errors.ts
-function isStripeError(error) {
-	return typeof error === "object" && error !== null && "type" in error && typeof error.type === "string" && "message" in error && typeof error.message === "string";
-}
-function stripeToApiError(error) {
-	if (isStripeError(error) && error.type === "StripeInvalidRequestError" && error.message.includes("there are no changes to confirm")) return new FragnoApiError({
-		message: "Trying to upgrade to same subscription plan",
-		code: "UPGRADE_HAS_NO_EFFECT"
-	}, 500);
-	if (isStripeError(error) && error.type === "StripeInvalidRequestError" && error.message.includes("is already set to be canceled at period end")) return new FragnoApiError({
-		message: "Subscription is already set to be canceled at period end",
-		code: "SUBSCRIPTION_ALREADY_CANCELED"
-	}, 500);
-	if (isStripeError(error) && error.type === "StripeInvalidRequestError" && error.message.includes("the subscription update feature in the portal configuration is disabled")) return new FragnoApiError({
-		message: "Subscription cannot be updated to this plan",
-		code: "SUBSCRIPTION_UPDATE_NOT_ALLOWED"
-	}, 500);
-	return error;
-}
-
 //#endregion
 //#region src/routes/subscriptions.ts
-const subscriptionsRoutesFactory = defineRoutes().create(({ deps, services, config }) => {
+const subscriptionsRoutesFactory = defineRoutes(stripeFragmentDefinition).create(({ deps, services, config, defineRoute }) => {
 	return [
 		defineRoute({
 			method: "GET",
@@ -415,19 +552,30 @@ const subscriptionsRoutesFactory = defineRoutes().create(({ deps, services, conf
 				"SUBSCRIPTION_NOT_FOUND",
 				"CUSTOMER_SUBSCRIPTION_MISMATCH",
 				"UPGRADE_HAS_NO_EFFECT",
-				"SUBSCRIPTION_UPDATE_NOT_ALLOWED"
+				"SUBSCRIPTION_UPDATE_NOT_ALLOWED",
+				"SUBSCRIPTION_UPDATE_PROMO_CODE_NOT_ALLOWED",
+				"PROMOTION_CODE_CUSTOMER_NOT_FIRST_TIME",
+				"MULTIPLE_ACTIVE_SUBSCRIPTIONS",
+				"NO_ACTIVE_SUBSCRIPTIONS"
 			],
 			handler: async (context, { json, error }) => {
 				const body = await context.input.valid();
-				const user = await config.resolveEntityFromRequest(context);
-				let customerId = user.stripeCustomerId;
+				const entity = await config.resolveEntityFromRequest(context);
+				let customerId = entity.stripeCustomerId;
 				let existingSubscription = null;
-				if (user.subscriptionId) {
-					existingSubscription = await services.getSubscriptionById(user.subscriptionId);
-					if (!existingSubscription) return error({
-						message: "Could not retrieve existing subscription",
-						code: "SUBSCRIPTION_NOT_FOUND"
-					}, 404);
+				if (entity.stripeCustomerId) {
+					const existingSubscriptions = await services.getSubscriptionsByStripeCustomerId(entity.stripeCustomerId);
+					let activeSubscriptions = existingSubscriptions.filter((s) => s.status !== "canceled");
+					if (body.subscriptionId) activeSubscriptions = activeSubscriptions.filter((s) => s.id === body.subscriptionId);
+					if (activeSubscriptions.length > 1) return error({
+						message: "Multiple active subscriptions found for customer, please specify which subscription to upgrade",
+						code: "MULTIPLE_ACTIVE_SUBSCRIPTIONS"
+					}, 400);
+					if (activeSubscriptions.length === 0) return error({
+						message: "No active subscriptions found for customer",
+						code: "NO_ACTIVE_SUBSCRIPTIONS"
+					}, 400);
+					existingSubscription = activeSubscriptions[0];
 					if (customerId && existingSubscription.stripeCustomerId && existingSubscription.stripeCustomerId !== customerId) return error({
 						message: "Subsciption being updated does not belong to Stripe Customer that was provided",
 						code: "CUSTOMER_SUBSCRIPTION_MISMATCH"
@@ -436,33 +584,50 @@ const subscriptionsRoutesFactory = defineRoutes().create(({ deps, services, conf
 				}
 				if (!customerId) {
 					const existingLinkedCustomer = await deps.stripe.customers.search({
-						query: `metadata['referenceId']:'${user.referenceId}'`,
+						query: `metadata['referenceId']:'${entity.referenceId}'`,
 						limit: 1
 					});
 					if (existingLinkedCustomer.data.length === 1) customerId = existingLinkedCustomer.data[0].id;
 					else {
-						if (!user.customerEmail || !user.referenceId) return error({
-							message: "New Stripe Customer must be created, but customerEmail or referenceID has not been provide",
+						if (!entity.customerEmail || !entity.referenceId) return error({
+							message: "New Stripe Customer must be created, but customerEmail or referenceID has not been provided",
 							code: "MISSING_CUSTOMER_INFO"
 						});
 						const newCustomer = await deps.stripe.customers.create({
-							email: user.customerEmail,
+							email: entity.customerEmail,
 							metadata: {
-								referenceId: user.referenceId,
-								...user.stripeMetadata
+								referenceId: entity.referenceId,
+								...entity.stripeMetadata
 							}
 						});
 						customerId = newCustomer.id;
 					}
 					try {
-						await config.onStripeCustomerCreated(customerId, user.referenceId);
+						await config.onStripeCustomerCreated(customerId, entity.referenceId);
 					} catch (error$1) {
 						deps.log.error("onStripeCustomerCreated failed!", error$1);
 					}
 				}
+				let promotionCodeId = void 0;
+				if (body.promotionCode) {
+					const promotionCodes = await deps.stripe.promotionCodes.list({
+						code: body.promotionCode,
+						active: true,
+						limit: 1
+					});
+					if (promotionCodes.data.length > 0) promotionCodeId = promotionCodes.data[0].id;
+				}
 				if (existingSubscription?.status === "active" || existingSubscription?.status === "trialing") {
 					const stripeSubscription = await deps.stripe.subscriptions.retrieve(existingSubscription.stripeSubscriptionId);
 					try {
+						if (existingSubscription.cancelAt != null) {
+							deps.log.info("un-cancelling subscription", stripeSubscription.id);
+							await deps.stripe.subscriptions.update(stripeSubscription.id, { cancel_at_period_end: false });
+							return json({
+								url: body.returnUrl || body.successUrl,
+								redirect: true
+							});
+						}
 						const portalSession = await deps.stripe.billingPortal.sessions.create({
 							customer: customerId,
 							return_url: body.returnUrl || body.successUrl,
@@ -478,7 +643,8 @@ const subscriptionsRoutesFactory = defineRoutes().create(({ deps, services, conf
 										id: stripeSubscription.items.data[0]?.id,
 										quantity: body.quantity,
 										price: body.priceId
-									}]
+									}],
+									...promotionCodeId && { discounts: [{ promotion_code: promotionCodeId }] }
 								}
 							}
 						});
@@ -499,7 +665,8 @@ const subscriptionsRoutesFactory = defineRoutes().create(({ deps, services, conf
 						quantity: body.quantity
 					}],
 					mode: "subscription",
-					metadata: { referenceId: user.referenceId }
+					metadata: { referenceId: entity.referenceId },
+					...promotionCodeId && { discounts: [{ promotion_code: promotionCodeId }] }
 				});
 				return json({
 					url: checkoutSession.url,
@@ -511,7 +678,10 @@ const subscriptionsRoutesFactory = defineRoutes().create(({ deps, services, conf
 		defineRoute({
 			method: "POST",
 			path: "/subscription/cancel",
-			inputSchema: z.object({ returnUrl: z.url().describe("URL to redirect to after cancellation is complete") }),
+			inputSchema: z.object({
+				returnUrl: z.url().describe("URL to redirect to after cancellation is complete"),
+				subscriptionId: z.string().optional().describe("Which subscription to cancel, if there are multiple active subscriptions")
+			}),
 			outputSchema: z.object({
 				url: z.url().describe("URL to redirect to after cancellation"),
 				redirect: z.boolean().describe("Whether to redirect to the URL")
@@ -519,30 +689,30 @@ const subscriptionsRoutesFactory = defineRoutes().create(({ deps, services, conf
 			errorCodes: [
 				"SUBSCRIPTION_NOT_FOUND",
 				"NO_SUBSCRIPTION_TO_CANCEL",
-				"SUBSCRIPTION_ALREADY_CANCELED"
+				"SUBSCRIPTION_ALREADY_CANCELED",
+				"NO_STRIPE_CUSTOMER_LINKED",
+				"MULTIPLE_SUBSCRIPTIONS_FOUND"
 			],
 			handler: async (context, { json, error }) => {
 				const body = await context.input.valid();
-				const { subscriptionId } = await config.resolveEntityFromRequest(context);
-				if (!subscriptionId) return error({
-					message: "No subscription to cancel",
+				const { stripeCustomerId } = await config.resolveEntityFromRequest(context);
+				if (!stripeCustomerId) return error({
+					message: "No stripe customer linked to entity",
+					code: "NO_STRIPE_CUSTOMER_LINKED"
+				}, 400);
+				let activeSubscriptions = (await services.getSubscriptionsByStripeCustomerId(stripeCustomerId)).filter((s) => s.status === "active");
+				if (body.subscriptionId) activeSubscriptions = activeSubscriptions.filter((s) => s.id === body.subscriptionId);
+				if (activeSubscriptions.length === 0) return error({
+					message: "No active subscription to cancel",
 					code: "NO_SUBSCRIPTION_TO_CANCEL"
 				}, 404);
-				const subscription = await services.getSubscriptionById(subscriptionId);
-				if (!subscription) return error({
-					message: "Subscription not found",
-					code: "SUBSCRIPTION_NOT_FOUND"
-				}, 404);
-				if (subscription.status === "canceled") return error({
-					message: "Subscription is already canceled",
-					code: "SUBSCRIPTION_ALREADY_CANCELED"
+				if (activeSubscriptions.length > 1) return error({
+					message: "Multiple active subscriptions found",
+					code: "MULTIPLE_SUBSCRIPTIONS_FOUND"
 				}, 400);
+				const activeSubscription = activeSubscriptions[0];
 				try {
-					const activeSubscriptions = await deps.stripe.subscriptions.list({
-						customer: subscription.stripeCustomerId,
-						status: "active"
-					});
-					const stripeSubscription = activeSubscriptions.data.find((sub) => sub.id === subscription.stripeSubscriptionId);
+					const stripeSubscription = await deps.stripe.subscriptions.retrieve(activeSubscription.stripeSubscriptionId);
 					if (!stripeSubscription) return error({
 						message: "Active subscription not found in Stripe",
 						code: "SUBSCRIPTION_NOT_FOUND"
@@ -552,7 +722,7 @@ const subscriptionsRoutesFactory = defineRoutes().create(({ deps, services, conf
 						redirect: false
 					});
 					const portalSession = await deps.stripe.billingPortal.sessions.create({
-						customer: subscription.stripeCustomerId,
+						customer: activeSubscription.stripeCustomerId,
 						return_url: body.returnUrl,
 						flow_data: {
 							type: "subscription_cancel",
@@ -602,7 +772,7 @@ const ProductResponseSchema = z.object({
 
 //#endregion
 //#region src/routes/products.ts
-const productsRoutesFactory = defineRoutes().create(({ deps, config }) => {
+const productsRoutesFactory = defineRoutes(stripeFragmentDefinition).create(({ deps, config, defineRoute }) => {
 	return [defineRoute({
 		method: "GET",
 		path: "/admin/products",
@@ -672,7 +842,7 @@ const PriceResponseSchema = z.object({
 
 //#endregion
 //#region src/routes/prices.ts
-const pricesRoutesFactory = defineRoutes().create(({ deps, config }) => {
+const pricesRoutesFactory = defineRoutes(stripeFragmentDefinition).create(({ deps, config, defineRoute }) => {
 	return [defineRoute({
 		method: "GET",
 		path: "/admin/products/:productId/prices",
@@ -707,143 +877,24 @@ const pricesRoutesFactory = defineRoutes().create(({ deps, config }) => {
 
 //#endregion
 //#region src/index.ts
-const LOG_PREFIX = "[Stripe Fragment]";
-const defaultLogger = {
-	info: (...data) => console.info(LOG_PREFIX, ...data),
-	error: (...data) => console.error(LOG_PREFIX, ...data),
-	warn: (...data) => console.warn(LOG_PREFIX, ...data),
-	debug: (...data) => console.debug(LOG_PREFIX, ...data),
-	log: (...data) => console.log(LOG_PREFIX, ...data)
-};
-const stripeFragmentDefinition = defineFragmentWithDatabase("stripe").withDatabase(stripeSchema, "stripe").withDependencies(({ config }) => {
-	const stripeClient = new Stripe(config.stripeSecretKey, config.stripeClientOptions ?? {});
-	return {
-		stripe: stripeClient,
-		log: config.logger ? config.logger : defaultLogger
-	};
-}).providesService(({ deps, db, defineService }) => {
-	return defineService({ ...createStripeServices(deps, db) });
-});
-function createStripeServices(deps, db) {
-	const services = {
-		getStripeClient() {
-			return deps.stripe;
-		},
-		createSubscription: async (data) => {
-			return (await db.create("subscription", data)).externalId;
-		},
-		updateSubscription: async (id, data) => {
-			await db.update("subscription", id, (b) => b.set({
-				...data,
-				updatedAt: new Date()
-			}));
-		},
-		getSubscriptionByStripeId: async (stripeSubscriptionId) => {
-			const result = await db.findFirst("subscription", (b) => b.whereIndex("idx_stripe_subscription_id", (eb) => eb("stripeSubscriptionId", "=", stripeSubscriptionId)));
-			if (!result) return null;
-			return {
-				...result,
-				id: result.id.externalId,
-				status: result.status
-			};
-		},
-		getSubscriptionByStripeCustomerId: async (stripeCustomerId) => {
-			return (await db.find("subscription", (b) => b.whereIndex("idx_stripe_customer_id", (eb) => eb("stripeCustomerId", "=", stripeCustomerId)))).map((subscription) => ({
-				...subscription,
-				id: subscription.id.externalId,
-				status: subscription.status
-			}));
-		},
-		getSubscriptionById: async (id) => {
-			const result = await db.findFirst("subscription", (b) => b.whereIndex("primary", (eb) => eb("id", "=", id)));
-			if (!result) return null;
-			return {
-				...result,
-				id: result.id.externalId,
-				status: result.status
-			};
-		},
-		getSubscriptionByReferenceId: async (referenceId) => {
-			const result = await db.findFirst("subscription", (b) => b.whereIndex("idx_reference_id", (eb) => eb("referenceId", "=", referenceId)));
-			if (!result) return null;
-			return {
-				...result,
-				id: result.id.externalId,
-				status: result.status
-			};
-		},
-		deleteSubscription: async (id) => {
-			await db.delete("subscription", id);
-		},
-		deleteSubscriptionByReferenceId: async (referenceId) => {
-			const uow = db.createUnitOfWork().find("subscription", (b) => b.whereIndex("idx_reference_id", (eb) => eb("referenceId", "=", referenceId)));
-			const [subscriptions] = await uow.executeRetrieve();
-			const subscription = subscriptions[0];
-			if (subscription) {
-				uow.delete("subscription", subscription.id);
-				const success = await uow.executeMutations();
-				if (!success) throw new Error("Failed to deleted subscription, conflict on subscription resource");
-				return true;
-			}
-			return false;
-		},
-		getAllSubscriptions: async () => {
-			return (await db.find("subscription", (b) => b.whereIndex("primary"))).map((subscription) => ({
-				...subscription,
-				id: subscription.id.externalId,
-				status: subscription.status
-			}));
-		},
-		syncStripeSubscription: async (referenceId, stripeCustomerId) => {
-			const stripeSubscriptions = await deps.stripe.subscriptions.list({
-				customer: stripeCustomerId,
-				limit: 1,
-				status: "all"
-			});
-			if (stripeSubscriptions.data.length === 0) {
-				await services.deleteSubscriptionByReferenceId(referenceId);
-				return;
-			}
-			const stripeSubscription = stripeSubscriptions.data[0];
-			const existingSubscription = await db.findFirst("subscription", (b) => b.whereIndex("idx_stripe_subscription_id", (eb) => eb("stripeSubscriptionId", "=", stripeSubscription.id)));
-			if (existingSubscription) await db.update("subscription", existingSubscription.id, (b) => b.set({
-				...stripeSubscriptionToInternalSubscription(stripeSubscription),
-				updatedAt: new Date()
-			}));
-			else {
-				const subscriptionData = {
-					...stripeSubscriptionToInternalSubscription(stripeSubscription),
-					referenceId: referenceId ?? null
-				};
-				await services.createSubscription(subscriptionData);
-			}
-			return;
-		}
-	};
-	return services;
-}
+const routes = [
+	webhookRoutesFactory,
+	customersRoutesFactory,
+	subscriptionsRoutesFactory,
+	productsRoutesFactory,
+	pricesRoutesFactory
+];
 function createStripeFragment(config, fragnoConfig) {
-	return createFragment(stripeFragmentDefinition, config, [
-		webhookRoutesFactory,
-		customersRoutesFactory,
-		subscriptionsRoutesFactory,
-		productsRoutesFactory,
-		pricesRoutesFactory
-	], fragnoConfig);
+	return instantiate(stripeFragmentDefinition).withConfig(config).withRoutes(routes).withOptions(fragnoConfig).build();
 }
 function createStripeFragmentClients(fragnoConfig = {}) {
-	const builder = createClientBuilder(stripeFragmentDefinition, fragnoConfig, [
-		webhookRoutesFactory,
-		customersRoutesFactory,
-		subscriptionsRoutesFactory,
-		productsRoutesFactory,
-		pricesRoutesFactory
-	]);
+	const builder = createClientBuilder(stripeFragmentDefinition, fragnoConfig, routes);
 	return {
 		useCustomers: builder.createHook("/admin/customers"),
 		useProducts: builder.createHook("/admin/products"),
 		usePrices: builder.createHook("/admin/products/:productId/prices"),
 		useSubscription: builder.createHook("/admin/subscriptions"),
+		useBillingPortal: builder.createMutator("POST", "/portal"),
 		upgradeSubscription: builder.createMutator("POST", "/subscription/upgrade"),
 		cancelSubscription: builder.createMutator("POST", "/subscription/cancel")
 	};