fix(webapp): use EntitlementResult for production entitlement validation

Replace the invalid @trigger.dev/platform/v3 import so billing limit typecheck passes in CI.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: kathiekiwi

apps/webapp/app/components/billing/BillingAlertsSection.tsx

@@ -53,8 +53,7 @@ export const billingAlertsSchema = z.object({
     const values = typeof i === "string" ? [i] : Array.isArray(i) ? i : [];
     return values
       .filter((v) => v !== "")
-      .map((v) => Number(v))
-      .filter((n) => Number.isFinite(n));
+      .map((v) => Number(v));
   }, z.number().array().refine(thresholdValuesAreUnique, "Each alert must be unique")),
 });
 

apps/webapp/app/components/billing/OrgBanner.tsx

@@ -17,7 +17,7 @@ import { v3BillingLimitsPath, v3BillingPath, v3QueuesPath } from "~/utils/pathBu
 
 function getUpgradeResetDate(): Date {
   const nextMonth = new Date();
-  nextMonth.setUTCMonth(nextMonth.getMonth() + 1);
+  nextMonth.setUTCMonth(nextMonth.getUTCMonth() + 1);
   nextMonth.setUTCDate(1);
   nextMonth.setUTCHours(0, 0, 0, 0);
   return nextMonth;

apps/webapp/app/components/billing/billingAlertsFormat.ts

@@ -18,7 +18,7 @@ export type BillingLimitMode = "plan" | "custom" | "none";
 
 export function getBillingLimitMode(billingLimit: BillingLimitResult): BillingLimitMode {
   if (!billingLimit.isConfigured) {
-    return "plan";
+    return "none";
   }
   return billingLimit.mode;
 }

apps/webapp/app/components/billing/selectOrgBanner.ts

@@ -31,14 +31,16 @@ export function selectOrgBanner(input: {
     if (status === "grace") {
       return OrgBannerKind.LimitGrace;
     }
-  } else if (billingLimit && !billingLimit.isConfigured && showSelfServe) {
-    return OrgBannerKind.NoLimitConfigured;
   }
 
   if (hasExceededFreeTier) {
     return OrgBannerKind.Upgrade;
   }
 
+  if (billingLimit && !billingLimit.isConfigured && showSelfServe) {
+    return OrgBannerKind.NoLimitConfigured;
+  }
+
   if (showEnvironmentWarning) {
     return OrgBannerKind.EnvironmentWarning;
   }

apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.queues/route.tsx

@@ -183,24 +183,22 @@ export const action = async ({ request, params }: ActionFunctionArgs) => {
   }
 
   switch (action) {
-    case "environment-pause":
+    case "environment-pause": {
       const pauseService = new PauseEnvironmentService();
-      {
-        const result = await pauseService.call(environment, "paused");
-        if (!result.success) {
-          return redirectWithErrorMessage(redirectPath, request, result.error);
-        }
+      const result = await pauseService.call(environment, "paused");
+      if (!result.success) {
+        return redirectWithErrorMessage(redirectPath, request, result.error);
       }
       return redirectWithSuccessMessage(redirectPath, request, "Environment paused");
-    case "environment-resume":
+    }
+    case "environment-resume": {
       const resumeService = new PauseEnvironmentService();
-      {
-        const result = await resumeService.call(environment, "resumed");
-        if (!result.success) {
-          return redirectWithErrorMessage(redirectPath, request, result.error);
-        }
+      const result = await resumeService.call(environment, "resumed");
+      if (!result.success) {
+        return redirectWithErrorMessage(redirectPath, request, result.error);
       }
       return redirectWithSuccessMessage(redirectPath, request, "Environment resumed");
+    }
     case "queue-pause":
     case "queue-resume": {
       const friendlyId = formData.get("friendlyId");

apps/webapp/app/routes/_app.orgs.$organizationSlug.settings.billing-limits/route.tsx

@@ -3,8 +3,6 @@ import type { MetaFunction } from "@remix-run/react";
 import {
   json,
   redirect,
-  type ActionFunction,
-  type LoaderFunctionArgs,
 } from "@remix-run/server-runtime";
 import { tryCatch } from "@trigger.dev/core";
 import { typedjson, useTypedLoaderData } from "remix-typedjson";
@@ -43,6 +41,7 @@ import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/Page
 import { prisma } from "~/db.server";
 import { featuresForRequest } from "~/features.server";
 import { useScrollContainerToTop } from "~/hooks/useScrollContainerToTop";
+import { resolveOrgIdFromSlug } from "~/models/organization.server";
 import {
   commitSession,
   getSession,
@@ -59,6 +58,7 @@ import {
   setBillingAlert,
   setBillingLimit,
 } from "~/services/platform.v3.server";
+import { dashboardAction, dashboardLoader } from "~/services/routeBuilders/dashboardBuilder";
 import type { BillingLimitResult } from "~/services/billingLimit.schemas";
 import {
   getAlertsResetRequested,
@@ -77,15 +77,31 @@ import {
   v3BillingLimitsPath,
   v3BillingPath,
 } from "~/utils/pathBuilder";
-import { requireUserId } from "~/services/session.server";
+
+const billingLimitsAuthorization = {
+  action: "manage" as const,
+  resource: { type: "billing" as const },
+};
 
 export const meta: MetaFunction = () => {
   return [{ title: `Billing limits | Trigger.dev` }];
 };
 
-export async function loader({ params, request }: LoaderFunctionArgs) {
-  const userId = await requireUserId(request);
-  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+export const loader = dashboardLoader(
+  {
+    params: OrganizationParamsSchema,
+    context: async (params) => {
+      const organizationId = await resolveOrgIdFromSlug(params.organizationSlug);
+      return organizationId ? { organizationId } : {};
+    },
+    authorization: {
+      ...billingLimitsAuthorization,
+      message: "With your current role, you can't manage billing limits.",
+    },
+  },
+  async ({ params, request, user }) => {
+  const userId = user.id;
+  const { organizationSlug } = params;
 
   const { isManagedCloud } = featuresForRequest(request);
   if (!isManagedCloud) {
@@ -131,9 +147,9 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
   firstDayOfMonth.setUTCHours(0, 0, 0, 0);
 
   const firstDayOfNextMonth = new Date();
-  firstDayOfNextMonth.setUTCMonth(firstDayOfNextMonth.getUTCMonth() + 1);
   firstDayOfNextMonth.setUTCDate(1);
   firstDayOfNextMonth.setUTCHours(0, 0, 0, 0);
+  firstDayOfNextMonth.setUTCMonth(firstDayOfNextMonth.getUTCMonth() + 1);
 
   const [usage, queuedRunCount, billingLimitPauseEnvCount] = await Promise.all([
     getCachedUsage(organization.id, { from: firstDayOfMonth, to: firstDayOfNextMonth }),
@@ -166,7 +182,8 @@ export async function loader({ params, request }: LoaderFunctionArgs) {
     submittedResumeMode,
     suggestedNewLimitDollars,
   });
-}
+  }
+);
 
 type LoaderData = {
   billingLimit: BillingLimitResult;
@@ -182,9 +199,18 @@ type LoaderData = {
   suggestedNewLimitDollars: number;
 };
 
-export const action: ActionFunction = async ({ request, params }) => {
-  const userId = await requireUserId(request);
-  const { organizationSlug } = OrganizationParamsSchema.parse(params);
+export const action = dashboardAction(
+  {
+    params: OrganizationParamsSchema,
+    context: async (params) => {
+      const organizationId = await resolveOrgIdFromSlug(params.organizationSlug);
+      return organizationId ? { organizationId } : {};
+    },
+    authorization: billingLimitsAuthorization,
+  },
+  async ({ request, params, user }) => {
+  const userId = user.id;
+  const { organizationSlug } = params;
 
   const organization = await prisma.organization.findFirst({
     where: { slug: organizationSlug, members: { some: { userId } } },
@@ -476,7 +502,8 @@ export const action: ActionFunction = async ({ request, params }) => {
   }
 
   return json({ error: "Unknown form intent" }, { status: 400 });
-};
+  }
+);
 
 export default function Page() {
   const {

apps/webapp/app/routes/admin.api.v1.orgs.$organizationId.billing-limit.hit.ts

@@ -1,7 +1,8 @@
 import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
 import { z } from "zod";
 import { prisma } from "~/db.server";
-import { BillingLimitHitWebhookBodySchema } from "~/services/billingLimit.schemas";
+import { BillingLimitHitWebhookBodySchema, type BillingLimitHitWebhookBody } from "~/services/billingLimit.schemas";
+import { logger } from "~/services/logger.server";
 import { requireAdminApiRequest } from "~/services/personalAccessToken.server";
 import { bustBillingLimitCaches } from "~/services/platform.v3.server";
 import {
@@ -24,7 +25,17 @@ export async function action({ request, params }: ActionFunctionArgs) {
   }
 
   const { organizationId } = ParamsSchema.parse(params);
-  const body = BillingLimitHitWebhookBodySchema.parse(await request.json());
+
+  let body: BillingLimitHitWebhookBody;
+  try {
+    body = BillingLimitHitWebhookBodySchema.parse(await request.json());
+  } catch (error) {
+    logger.error("Invalid billing limit hit webhook payload", {
+      error,
+      organizationId,
+    });
+    return json({ error: "Invalid request body" }, { status: 400 });
+  }
 
   const organization = await prisma.organization.findFirst({
     where: { id: organizationId },

apps/webapp/app/runEngine/validators/validateProductionEntitlement.server.ts

@@ -1,10 +1,10 @@
-import type { ReportUsageResult } from "@trigger.dev/platform/v3";
+import type { EntitlementResult } from "~/services/billingLimit.schemas";
 import { OutOfEntitlementError } from "~/v3/outOfEntitlementError.server";
 import type { EntitlementValidationParams, EntitlementValidationResult } from "../types";
 
 export type GetEntitlementFn = (
   organizationId: string
-) => Promise<ReportUsageResult | undefined>;
+) => Promise<EntitlementResult | undefined>;
 
 export async function validateProductionEntitlement(
   params: EntitlementValidationParams,

apps/webapp/app/services/billingLimit.schemas.ts

@@ -15,13 +15,13 @@ export const BillingLimitStateSchema = z.discriminatedUnion("status", [
   }),
   z.object({
     status: z.literal("grace"),
-    hitAt: z.string(),
-    graceEndsAt: z.string(),
+    hitAt: z.string().datetime({ offset: true }),
+    graceEndsAt: z.string().datetime({ offset: true }),
   }),
   z.object({
     status: z.literal("rejected"),
-    hitAt: z.string(),
-    graceEndsAt: z.string(),
+    hitAt: z.string().datetime({ offset: true }),
+    graceEndsAt: z.string().datetime({ offset: true }),
   }),
 ]);
 
@@ -132,7 +132,7 @@ export type BillingLimitsActiveResult = z.infer<typeof BillingLimitsActiveResult
 export const BillingLimitPendingResolveOrgSchema = z.object({
   organizationId: z.string(),
   resumeMode: z.enum(["queue", "new_only"]),
-  resolvedAt: z.string(),
+  resolvedAt: z.string().datetime({ offset: true }),
 });
 
 export const BillingLimitsPendingResolvesResultSchema = z.object({
@@ -144,7 +144,7 @@ export type BillingLimitsPendingResolvesResult = z.infer<
 >;
 
 export const BillingLimitHitWebhookBodySchema = z.object({
-  hitAt: z.string(),
+  hitAt: z.string().datetime({ offset: true }),
   cancelInProgressRuns: z.boolean(),
   limitState: z.literal("grace"),
 });

apps/webapp/app/services/upsertBranch.server.ts

@@ -154,10 +154,7 @@ export class UpsertBranchService {
       });
 
       const alreadyExisted = branch.createdAt < now;
-
-      if (!alreadyExisted) {
-        await applyBillingLimitPauseAfterEnvCreate(branch);
-      }
+      await applyBillingLimitPauseAfterEnvCreate(branch);
 
       return {
         success: true as const,