Expose an api endpoint to cancel deployments

Author: myftija

apps/webapp/app/routes/api.v1.deployments.$deploymentId.cancel.ts

@@ -0,0 +1,70 @@
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { CancelDeploymentRequestBody } from "@trigger.dev/core/v3";
+import { z } from "zod";
+import { authenticateRequest } from "~/services/apiAuth.server";
+import { logger } from "~/services/logger.server";
+import { DeploymentService } from "~/v3/services/deployment.server";
+
+const ParamsSchema = z.object({
+  deploymentId: z.string(),
+});
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method.toUpperCase() !== "POST") {
+    return json({ error: "Method Not Allowed" }, { status: 405 });
+  }
+
+  const parsedParams = ParamsSchema.safeParse(params);
+
+  if (!parsedParams.success) {
+    return json({ error: "Invalid params" }, { status: 400 });
+  }
+
+  const authenticationResult = await authenticateRequest(request, {
+    apiKey: true,
+    organizationAccessToken: false,
+    personalAccessToken: false,
+  });
+
+  if (!authenticationResult || !authenticationResult.result.ok) {
+    logger.info("Invalid or missing api key", { url: request.url });
+    return json({ error: "Invalid or Missing API key" }, { status: 401 });
+  }
+
+  const { environment: authenticatedEnv } = authenticationResult.result;
+  const { deploymentId } = parsedParams.data;
+
+  const rawBody = await request.json();
+  const body = CancelDeploymentRequestBody.safeParse(rawBody);
+
+  if (!body.success) {
+    return json({ error: "Invalid request body", issues: body.error.issues }, { status: 400 });
+  }
+
+  const deploymentService = new DeploymentService();
+
+  return await deploymentService
+    .cancelDeployment(authenticatedEnv, deploymentId, {
+      canceledReason: body.data.reason,
+    })
+    .match(
+      () => {
+        return new Response(null, { status: 204 });
+      },
+      (error) => {
+        switch (error.type) {
+          case "deployment_not_found":
+            return json({ error: "Deployment not found" }, { status: 404 });
+          case "deployment_cannot_be_cancelled":
+            return json(
+              { error: "Deployment is already in a final state and cannot be canceled" },
+              { status: 409 }
+            );
+          case "other":
+          default:
+            error.type satisfies "other";
+            return json({ error: "Internal server error" }, { status: 500 });
+        }
+      }
+    );
+}

apps/webapp/app/v3/services/deployment.server.ts

@@ -1,11 +1,12 @@
 import { type AuthenticatedEnvironment } from "~/services/apiAuth.server";
 import { BaseService } from "./baseService.server";
 import { errAsync, fromPromise, okAsync } from "neverthrow";
-import { type WorkerDeploymentStatus, type WorkerDeployment } from "@trigger.dev/database";
-import { type ExternalBuildData, logger, type GitMeta } from "@trigger.dev/core/v3";
+import { type WorkerDeployment } from "@trigger.dev/database";
+import { logger, type GitMeta } from "@trigger.dev/core/v3";
 import { TimeoutDeploymentService } from "./timeoutDeployment.server";
 import { env } from "~/env.server";
 import { createRemoteImageBuild } from "../remoteImageBuilder.server";
+import { FINAL_DEPLOYMENT_STATUSES } from "./failDeployment.server";
 
 export class DeploymentService extends BaseService {
   /**
@@ -143,4 +144,79 @@ export class DeploymentService extends BaseService {
       .andThen(extendTimeout)
       .map(() => undefined);
   }
+
+  /**
+   * Cancels a deployment that is not yet in a final state.
+   *
+   * Only acts when the current status is not final. Not idempotent.
+   *
+   * @param authenticatedEnv The environment which the deployment belongs to.
+   * @param friendlyId The friendly deployment ID.
+   * @param data Cancelation reason.
+   */
+  public cancelDeployment(
+    authenticatedEnv: AuthenticatedEnvironment,
+    friendlyId: string,
+    data: Partial<Pick<WorkerDeployment, "canceledReason">>
+  ) {
+    const getDeployment = () =>
+      fromPromise(
+        this._prisma.workerDeployment.findFirst({
+          where: {
+            friendlyId,
+            environmentId: authenticatedEnv.id,
+          },
+          select: {
+            status: true,
+            id: true,
+          },
+        }),
+        (error) => ({
+          type: "other" as const,
+          cause: error,
+        })
+      ).andThen((deployment) => {
+        if (!deployment) {
+          return errAsync({ type: "deployment_not_found" as const });
+        }
+        return okAsync(deployment);
+      });
+
+    const validateDeployment = (deployment: Pick<WorkerDeployment, "id" | "status">) => {
+      if (FINAL_DEPLOYMENT_STATUSES.includes(deployment.status)) {
+        logger.warn("Attempted cancelling deployment in a final state", {
+          deployment,
+        });
+        return errAsync({ type: "deployment_cannot_be_cancelled" as const });
+      }
+
+      return okAsync(deployment);
+    };
+
+    const cancelDeployment = (deployment: Pick<WorkerDeployment, "id">) =>
+      fromPromise(
+        this._prisma.workerDeployment.updateMany({
+          where: {
+            id: deployment.id,
+            status: {
+              notIn: FINAL_DEPLOYMENT_STATUSES, // status could've changed in the meantime, we're not locking the row
+            },
+          },
+          data: {
+            status: "CANCELED",
+            canceledAt: new Date(),
+            canceledReason: data.canceledReason,
+          },
+        }),
+        (error) => ({
+          type: "other" as const,
+          cause: error,
+        })
+      );
+
+    return getDeployment()
+      .andThen(validateDeployment)
+      .andThen(cancelDeployment)
+      .map(() => undefined);
+  }
 }

apps/webapp/app/v3/services/failDeployment.server.ts

@@ -1,11 +1,11 @@
 import { PerformDeploymentAlertsService } from "./alerts/performDeploymentAlerts.server";
 import { BaseService } from "./baseService.server";
 import { logger } from "~/services/logger.server";
-import { WorkerDeploymentStatus } from "@trigger.dev/database";
-import { FailDeploymentRequestBody } from "@trigger.dev/core/v3/schemas";
-import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { type WorkerDeploymentStatus } from "@trigger.dev/database";
+import { type FailDeploymentRequestBody } from "@trigger.dev/core/v3/schemas";
+import { type AuthenticatedEnvironment } from "~/services/apiAuth.server";
 
-const FINAL_DEPLOYMENT_STATUSES: WorkerDeploymentStatus[] = [
+export const FINAL_DEPLOYMENT_STATUSES: WorkerDeploymentStatus[] = [
   "CANCELED",
   "DEPLOYED",
   "FAILED",

packages/core/src/v3/schemas/api.ts

@@ -385,6 +385,12 @@ export const ProgressDeploymentRequestBody = z.object({
 
 export type ProgressDeploymentRequestBody = z.infer<typeof ProgressDeploymentRequestBody>;
 
+export const CancelDeploymentRequestBody = z.object({
+  reason: z.string().max(200, "Reason must be less than 200 characters").optional(),
+});
+
+export type CancelDeploymentRequestBody = z.infer<typeof CancelDeploymentRequestBody>;
+
 export const ExternalBuildData = z.object({
   buildId: z.string(),
   buildToken: z.string(),