Disable queues/org from admin API endpoint

Author: matt-aitken

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

@@ -30,8 +30,8 @@ export function UpgradePrompt() {
         <Icon icon={ExclamationCircleIcon} className="h-5 w-5 text-error" />
         <Paragraph variant="small" className="text-error">
           You have exceeded the monthly $
-          {(plan.v3Subscription?.plan?.limits.includedUsage ?? 500) / 100} free credits. No runs
-          will execute in Prod until{" "}
+          {(plan.v3Subscription?.plan?.limits.includedUsage ?? 500) / 100} free credits. Existing
+          runs will be queued and new runs won't be created until{" "}
           <DateTime date={nextMonth} includeTime={false} timeZone="utc" />, or you upgrade.
         </Paragraph>
       </div>

apps/webapp/app/presenters/v3/EnvironmentQueuePresenter.server.ts

@@ -8,6 +8,7 @@ export type Environment = {
   queued: number;
   concurrencyLimit: number;
   burstFactor: number;
+  runsEnabled: boolean;
 };
 
 export class EnvironmentQueuePresenter extends BasePresenter {
@@ -23,11 +24,25 @@ export class EnvironmentQueuePresenter extends BasePresenter {
     const running = (engineV1Executing ?? 0) + (engineV2Executing ?? 0);
     const queued = (engineV1Queued ?? 0) + (engineV2Queued ?? 0);
 
+    const organization = await this._replica.organization.findFirst({
+      where: {
+        id: environment.organizationId,
+      },
+      select: {
+        runsEnabled: true,
+      },
+    });
+
+    if (!organization) {
+      throw new Error("Organization not found");
+    }
+
     return {
       running,
       queued,
       concurrencyLimit: environment.maximumConcurrencyLimit,
       burstFactor: environment.concurrencyLimitBurstFactor.toNumber(),
+      runsEnabled: environment.type === "DEVELOPMENT" || organization.runsEnabled,
     };
   }
 }

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

@@ -285,7 +285,7 @@ export default function Page() {
                   >
                     View runs
                   </LinkButton>
-                  <EnvironmentPauseResumeButton env={env} />
+                  {environment.runsEnabled ? <EnvironmentPauseResumeButton env={env} /> : null}
                 </div>
               }
               valueClassName={env.paused ? "text-warning" : undefined}

apps/webapp/app/routes/admin.api.v1.orgs.$organizationId.runs.enable.ts

@@ -0,0 +1,97 @@
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import {
+  type RuntimeEnvironment,
+  type Organization,
+  type Project,
+  type RuntimeEnvironmentType,
+} from "@trigger.dev/database";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { createEnvironment } from "~/models/organization.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+import { updateEnvConcurrencyLimits } from "~/v3/runQueue.server";
+import { PauseEnvironmentService } from "~/v3/services/pauseEnvironment.server";
+
+const ParamsSchema = z.object({
+  organizationId: z.string(),
+});
+
+const BodySchema = z.object({
+  enable: z.boolean(),
+});
+
+/**
+ * It will enabled/disable runs
+ */
+export async function action({ request, params }: ActionFunctionArgs) {
+  // Next authenticate the request
+  const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
+
+  if (!authenticationResult) {
+    return json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  const user = await prisma.user.findUnique({
+    where: {
+      id: authenticationResult.userId,
+    },
+  });
+
+  if (!user) {
+    return json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  if (!user.admin) {
+    return json({ error: "You must be an admin to perform this action" }, { status: 403 });
+  }
+
+  const { organizationId } = ParamsSchema.parse(params);
+  const body = BodySchema.safeParse(await request.json());
+  if (!body.success) {
+    return json({ error: "Invalid request body", details: body.error }, { status: 400 });
+  }
+
+  const organization = await prisma.organization.update({
+    where: {
+      id: organizationId,
+    },
+    data: {
+      runsEnabled: body.data.enable,
+    },
+  });
+
+  if (!organization) {
+    return json({ error: "Organization not found" }, { status: 404 });
+  }
+
+  const environments = await prisma.runtimeEnvironment.findMany({
+    where: {
+      organizationId,
+      type: {
+        not: "DEVELOPMENT",
+      },
+    },
+    include: {
+      organization: true,
+      project: true,
+    },
+  });
+
+  const pauseEnvironmentService = new PauseEnvironmentService();
+
+  // Set the organization.runsEnabled flag to false
+  for (const environment of environments) {
+    if (body.data.enable) {
+      await pauseEnvironmentService.call({ ...environment, organization }, "resumed");
+    } else {
+      await pauseEnvironmentService.call({ ...environment, organization }, "paused");
+    }
+  }
+
+  return json({
+    success: true,
+    message: `${environments.length} environments updated to ${
+      body.data.enable ? "enabled" : "disabled"
+    }`,
+  });
+}