import { useEffect } from "react"; import { ActionFunction, LoaderFunctionArgs, redirect, useLoaderData } from "react-router"; import { useActionData } from "react-router"; import { getUserInfo, validateCSRFToken } from "~/utils/session.server"; import { getUser } from "~/utils/db/users.db.server"; import { getTranslations } from "~/locale/i18next.server"; import { getTenantIdFromUrl } from "~/utils/services/.server/urlService"; import { getOrPersistTenantSubscription, getTenantSubscription } from "~/utils/db/tenantSubscriptions.db.server"; import { getTenant } from "~/utils/db/tenants.db.server"; import { cancelTenantSubscription, getPlanFeaturesUsage } from "~/utils/services/.server/subscriptionService"; import { PlanFeatureUsageDto } from "~/application/dtos/subscriptions/PlanFeatureUsageDto"; import { verifyUserHasPermission } from "~/utils/helpers/.server/PermissionsService"; import { serverTimingHeaders } from "~/modules/metrics/utils/defaultHeaders"; import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker"; import EditPageLayout from "~/components/ui/layouts/EditPageLayout"; import SubscriptionSettings from "~/modules/users/components/SubscriptionSettings"; import toast from "react-hot-toast"; import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper"; import { useAppData } from "~/utils/data/useAppData"; import { v2MetaFunction } from "~/utils/compat/v2MetaFunction"; import { tenantHasModule } from "~/utils/connector/tenantConnector.server"; import { BILLING_MODULE_KEY } from "~/utils/services/.server/billingStatusService"; import { appTenantPlanRequiredPath } from "~/utils/app/AppTenantStatusPaths"; import { CustomerBillingInvoiceError, listCustomerBillingInvoices } from "~/services/billing/customer-invoices.server"; import type { CustomerBillingInvoiceDto } from "~/application/dtos/billing/CustomerBillingInvoiceDto"; import { getAllSubscriptionProducts } from "~/utils/db/subscriptionProducts.db.server"; import { getCurrenciesAndPeriods } from "~/utils/helpers/PricingHelper"; import type { SubscriptionProductDto } from "~/application/dtos/subscriptions/SubscriptionProductDto"; import { createSelfServiceCheckout, SelfServiceCheckoutError } from "~/services/billing/self-service-checkout.server"; export { serverTimingHeaders as headers }; type LoaderData = { title: string; myFeatures: PlanFeatureUsageDto[]; myInvoices: CustomerBillingInvoiceDto[]; availablePlans: SubscriptionProductDto[]; currenciesAndPeriod: ReturnType; canViewInvoices: boolean; canManageSubscription: boolean; invoiceErrorKey: string | null; }; async function canViewSubscriptionInvoices(request: Request, tenantId: string): Promise { try { await verifyUserHasPermission(request, "app.settings.subscription.invoices.view", tenantId); return true; } catch (error) { if (error instanceof Response && (error.status === 403 || error.status === 404)) { return false; } throw error; } } async function canManageSubscription(request: Request, tenantId: string): Promise { try { await verifyUserHasPermission(request, "app.settings.subscription.update", tenantId); return true; } catch (error) { if (error instanceof Response && (error.status === 403 || error.status === 404)) { return false; } throw error; } } export const loader = async ({ request, params }: LoaderFunctionArgs) => { const { time, getServerTimingHeader } = await createMetrics({ request, params }, "app.$tenant.settings.subscription"); let { t } = await getTranslations(request); const tenantId = await time(getTenantIdFromUrl(params), "getTenantIdFromUrl"); await time(verifyUserHasPermission(request, "app.settings.subscription.view", tenantId), "verifyUserHasPermission"); const userInfoPromise = time(getUserInfo(request), "getUserInfo"); const userPromise = userInfoPromise.then((userInfo) => time(getUser(userInfo.userId), "getUser")); const tenantPromise = time(getTenant(tenantId), "getTenant"); const [user, tenant] = await Promise.all([userPromise, tenantPromise]); const userInfo = await userInfoPromise; const hasBillingModule = await tenantHasModule({ tenantId, userId: userInfo.userId, moduleKey: BILLING_MODULE_KEY }); if (!hasBillingModule) { throw redirect(appTenantPlanRequiredPath(params)); } if (!user) { return badRequest({ error: t("shared.invalidUser") }); } if (!tenant) { return badRequest({ error: t("settings.subscription.errors.invalidTenant", { tenantId }) }); } const tenantSubscription = await time(getOrPersistTenantSubscription(tenantId), "getOrPersistTenantSubscription"); const [canViewInvoices, canUpdateSubscription, availablePlans] = await Promise.all([ time(canViewSubscriptionInvoices(request, tenantId), "verifyInvoicePermission"), time(canManageSubscription(request, tenantId), "verifySubscriptionUpdatePermission"), time(getAllSubscriptionProducts(true), "subscription[getPublicProducts]"), ]); const [myFeatures, invoiceResult] = await Promise.all([ time(getPlanFeaturesUsage(tenantId, tenantSubscription), "subscription[getPlanFeaturesUsage]"), canViewInvoices ? time( listCustomerBillingInvoices({ tenantId, tenantSlug: tenant.slug }) .then((invoices) => ({ invoices, errorKey: null })) .catch((error) => ({ invoices: [], errorKey: error instanceof CustomerBillingInvoiceError ? error.i18nKey : "settings.subscription.errors.INVOICE_LIST_UNAVAILABLE", })), "billing[listCustomerInvoices]" ) : Promise.resolve({ invoices: [], errorKey: null }), ]); const data: LoaderData = { title: `${t("app.navbar.subscription")} | ${process.env.APP_NAME}`, myFeatures, myInvoices: invoiceResult.invoices, availablePlans: availablePlans as SubscriptionProductDto[], currenciesAndPeriod: getCurrenciesAndPeriods(availablePlans.flatMap((plan) => plan.prices)), canViewInvoices, canManageSubscription: canUpdateSubscription, invoiceErrorKey: invoiceResult.errorKey, }; return Response.json(data, { headers: getServerTimingHeader() }); }; type ActionData = { error?: string; success?: string; }; const badRequest = (data: ActionData) => Response.json(data, { status: 400 }); export const action: ActionFunction = async ({ request, params }) => { const { t } = await getTranslations(request); const tenantId = await getTenantIdFromUrl(params); await verifyUserHasPermission(request, "app.settings.subscription.update", tenantId); const userInfo = await getUserInfo(request); const tenantSubscription = await getTenantSubscription(tenantId); await validateCSRFToken(request); const form = await request.formData(); const action = form.get("action")?.toString(); if (!tenantSubscription) { return badRequest({ error: t("settings.subscription.errors.invalidSubscription"), }); } else if (action === "cancel") { await verifyUserHasPermission(request, "app.settings.subscription.delete", tenantId); const tenantSubscriptionProductId = form.get("tenant-subscription-product-id")?.toString() ?? ""; try { await cancelTenantSubscription(tenantSubscriptionProductId, { t, tenantId, userId: userInfo.userId }); return Response.json({ success: t("settings.subscription.success.cancelled") }); } catch (error) { // eslint-disable-next-line no-console console.error(error); return Response.json({ error: t("shared.unexpectedError") }, { status: 400 }); } } else if (action === "subscribe") { const tenant = await getTenant(tenantId); const user = await getUser(userInfo.userId); if (!tenant) { return badRequest({ error: t("settings.subscription.errors.invalidTenant", { tenantId }) }); } if (!user) { return badRequest({ error: t("shared.invalidUser") }); } const tenantSlugContext = form.get("tenant-slug-context")?.toString(); if (tenantSlugContext && tenantSlugContext !== tenant.slug) { return badRequest({ error: t("settings.subscription.checkout.invalid") }); } try { const checkout = await createSelfServiceCheckout({ request, tenantId, tenantSlug: tenant.slug, tenantName: tenant.name, userId: user.id, userEmail: user.email, userName: `${user.firstName ?? ""} ${user.lastName ?? ""}`.trim() || user.email, productId: form.get("product-id")?.toString() ?? "", billingPeriod: Number(form.get("billing-period")?.toString()), currency: form.get("currency")?.toString() ?? "", quantity: Number(form.get("quantity")?.toString() ?? "1"), }); return redirect(checkout.checkoutUrl); } catch (error) { if (error instanceof Response) { throw error; } if (error instanceof SelfServiceCheckoutError) { return Response.json({ error: t(error.i18nKey) }, { status: 400 }); } // eslint-disable-next-line no-console console.error(error); return Response.json({ error: t("shared.unexpectedError") }, { status: 400 }); } } }; export const meta: v2MetaFunction = ({ data }) => (data && "title" in data ? [{ title: data.title }] : []); export default function SubscriptionRoute() { const data = useLoaderData(); const actionData = useActionData(); const appData = useAppData(); useEffect(() => { if (actionData?.error) { toast.error(actionData.error); } else if (actionData?.success) { toast.success(actionData.success); } }, [actionData]); return ( ); }