refactor: consolidate template creation logic into ComputeTemplateCreationService.handleDeployTemplate

nicktrn · nicktrn · commit 4cbbadb83631 · 2026-03-27T01:19:56.000Z
diff --git a/apps/webapp/app/v3/services/computeTemplateCreation.server.ts b/apps/webapp/app/v3/services/computeTemplateCreation.server.ts
@@ -3,6 +3,9 @@ import { env } from "~/env.server";
 import { logger } from "~/services/logger.server";
 import type { PrismaClientOrTransaction } from "~/db.server";
 import { FEATURE_FLAG, makeFlag } from "~/v3/featureFlags.server";
+import type { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { ServiceValidationError } from "./baseService.server";
+import { FailDeploymentService } from "./failDeployment.server";
 
 type TemplateCreationMode = "required" | "shadow" | "skip";
 
@@ -19,6 +22,80 @@ export class ComputeTemplateCreationService {
     }
   }
 
+  /**
+   * Handle template creation for a deployment. Call this before setting DEPLOYED.
+   *
+   * - Required mode: creates template synchronously, fails deployment on error
+   * - Shadow mode: fires background template creation (returns immediately)
+   * - Skip: no-op
+   *
+   * Throws ServiceValidationError if required mode fails (caller should stop finalize).
+   */
+  async handleDeployTemplate(options: {
+    projectId: string;
+    imageReference: string;
+    deploymentFriendlyId: string;
+    authenticatedEnv: AuthenticatedEnvironment;
+    prisma: PrismaClientOrTransaction;
+    writer?: WritableStreamDefaultWriter;
+  }): Promise<void> {
+    const mode = await this.resolveMode(options.projectId, options.prisma);
+
+    if (mode === "skip") {
+      return;
+    }
+
+    if (mode === "shadow") {
+      this.createTemplate(options.imageReference, { background: true }).catch((error) => {
+        logger.error("Shadow compute template creation failed", {
+          id: options.deploymentFriendlyId,
+          imageReference: options.imageReference,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      });
+      return;
+    }
+
+    // Required mode
+    if (options.writer) {
+      await options.writer.write(
+        `event: log\ndata: ${JSON.stringify({ message: "Building compute template..." })}\n\n`
+      );
+    }
+
+    logger.info("Creating compute template (required mode)", {
+      id: options.deploymentFriendlyId,
+      imageReference: options.imageReference,
+    });
+
+    const result = await this.createTemplate(options.imageReference);
+
+    if (!result.success) {
+      logger.error("Compute template creation failed", {
+        id: options.deploymentFriendlyId,
+        imageReference: options.imageReference,
+        error: result.error,
+      });
+
+      const failService = new FailDeploymentService();
+      await failService.call(options.authenticatedEnv, options.deploymentFriendlyId, {
+        error: {
+          name: "TemplateCreationFailed",
+          message: `Failed to create compute template: ${result.error}`,
+        },
+      });
+
+      throw new ServiceValidationError(
+        `Compute template creation failed: ${result.error}`
+      );
+    }
+
+    logger.info("Compute template created", {
+      id: options.deploymentFriendlyId,
+      imageReference: options.imageReference,
+    });
+  }
+
   async resolveMode(
     projectId: string,
     prisma: PrismaClientOrTransaction
diff --git a/apps/webapp/app/v3/services/finalizeDeployment.server.ts b/apps/webapp/app/v3/services/finalizeDeployment.server.ts
@@ -12,7 +12,6 @@ import { TimeoutDeploymentService } from "./timeoutDeployment.server";
 import { DeploymentService } from "./deployment.server";
 import { engine } from "../runEngine.server";
 import { tryCatch } from "@trigger.dev/core";
-import { ComputeTemplateCreationService } from "./computeTemplateCreation.server";
 
 export class FinalizeDeploymentService extends BaseService {
   public async call(
@@ -66,47 +65,6 @@ export class FinalizeDeploymentService extends BaseService {
 
     const imageDigest = validatedImageDigest(body.imageDigest);
 
-    // Compute template creation (before setting DEPLOYED)
-    const templateService = new ComputeTemplateCreationService();
-    const templateMode = await templateService.resolveMode(
-      authenticatedEnv.projectId,
-      this._prisma
-    );
-
-    if (templateMode === "required" && deployment.imageReference) {
-      logger.info("Creating compute template (required mode)", {
-        id,
-        imageReference: deployment.imageReference,
-      });
-
-      const templateResult = await templateService.createTemplate(deployment.imageReference);
-
-      if (!templateResult.success) {
-        logger.error("Compute template creation failed", {
-          id,
-          imageReference: deployment.imageReference,
-          error: templateResult.error,
-        });
-
-        const failService = new FailDeploymentService();
-        await failService.call(authenticatedEnv, deployment.friendlyId, {
-          error: {
-            name: "TemplateCreationFailed",
-            message: `Failed to create compute template: ${templateResult.error}`,
-          },
-        });
-
-        throw new ServiceValidationError(
-          `Compute template creation failed: ${templateResult.error}`
-        );
-      }
-
-      logger.info("Compute template created", {
-        id,
-        imageReference: deployment.imageReference,
-      });
-    }
-
     // Link the deployment with the background worker
     const finalizedDeployment = await this._prisma.workerDeployment.update({
       where: {
@@ -189,17 +147,6 @@ export class FinalizeDeploymentService extends BaseService {
 
     await PerformDeploymentAlertsService.enqueue(deployment.id);
 
-    // Shadow mode: fire-and-forget template creation after deploy is finalized
-    if (templateMode === "shadow" && deployment.imageReference) {
-      templateService.createTemplate(deployment.imageReference, { background: true }).catch((error) => {
-        logger.error("Shadow compute template creation failed", {
-          id,
-          imageReference: deployment.imageReference,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      });
-    }
-
     return finalizedDeployment;
   }
 }
diff --git a/apps/webapp/app/v3/services/finalizeDeploymentV2.server.ts b/apps/webapp/app/v3/services/finalizeDeploymentV2.server.ts
@@ -11,7 +11,6 @@ import { mkdtemp, writeFile } from "node:fs/promises";
 import { env } from "~/env.server";
 import { depot as execDepot } from "@depot/cli";
 import { FinalizeDeploymentService } from "./finalizeDeployment.server";
-import { FailDeploymentService } from "./failDeployment.server";
 import { remoteBuildsEnabled } from "../remoteImageBuilder.server";
 import { getEcrAuthToken, isEcrRegistry } from "../getDeploymentImageRef.server";
 import { tryCatch } from "@trigger.dev/core";
@@ -25,12 +24,6 @@ export class FinalizeDeploymentV2Service extends BaseService {
     body: FinalizeDeploymentRequestBody,
     writer?: WritableStreamDefaultWriter
   ) {
-    // If remote builds are not enabled, lets just use the v1 finalize deployment service
-    if (!remoteBuildsEnabled()) {
-      const finalizeService = new FinalizeDeploymentService();
-      return finalizeService.call(authenticatedEnv, id, body);
-    }
-
     const deployment = await this._prisma.workerDeployment.findFirst({
       where: {
         friendlyId: id,
@@ -64,7 +57,6 @@ export class FinalizeDeploymentV2Service extends BaseService {
 
     if (deployment.status === "DEPLOYED") {
       logger.debug("Worker deployment is already deployed", { id });
-
       return deployment;
     }
 
@@ -74,32 +66,17 @@ export class FinalizeDeploymentV2Service extends BaseService {
     }
 
     const finalizeService = new FinalizeDeploymentService();
-    const templateService = new ComputeTemplateCreationService();
-
-    if (body.skipPushToRegistry) {
-      logger.debug("Skipping push to registry during deployment finalization", {
-        deployment,
-      });
 
-      let templateMode: "required" | "shadow" | "skip" = "skip";
-      if (deployment.imageReference) {
-        templateMode = await this.#handleTemplateCreation({
-          templateService,
-          projectId: deployment.worker.project.id,
-          imageReference: deployment.imageReference,
-          deploymentFriendlyId: id,
-          authenticatedEnv,
-          writer,
+    // If remote builds are not enabled, skip image push and go straight to template + finalize
+    if (!remoteBuildsEnabled() || body.skipPushToRegistry) {
+      if (body.skipPushToRegistry) {
+        logger.debug("Skipping push to registry during deployment finalization", {
+          deployment,
         });
       }
 
-      const result = await finalizeService.call(authenticatedEnv, id, body);
-
-      if (templateMode === "shadow" && deployment.imageReference) {
-        this.#fireShadowTemplateCreation(templateService, deployment.imageReference, id);
-      }
-
-      return result;
+      await this.#createTemplateIfNeeded(deployment, id, authenticatedEnv, writer);
+      return finalizeService.call(authenticatedEnv, id, body);
     }
 
     const externalBuildData = deployment.externalBuildData
@@ -165,88 +142,28 @@ export class FinalizeDeploymentV2Service extends BaseService {
       pushedImage: pushResult.image,
     });
 
-    const templateMode = await this.#handleTemplateCreation({
-      templateService,
-      projectId: deployment.worker.project.id,
-      imageReference: deployment.imageReference,
-      deploymentFriendlyId: id,
-      authenticatedEnv,
-      writer,
-    });
-
-    const finalizedDeployment = await finalizeService.call(authenticatedEnv, id, body);
-
-    // Shadow mode: fire-and-forget template creation after deploy is finalized
-    if (templateMode === "shadow") {
-      this.#fireShadowTemplateCreation(templateService, deployment.imageReference, id);
-    }
-
-    return finalizedDeployment;
+    await this.#createTemplateIfNeeded(deployment, id, authenticatedEnv, writer);
+    return finalizeService.call(authenticatedEnv, id, body);
   }
 
-  async #handleTemplateCreation(options: {
-    templateService: ComputeTemplateCreationService;
-    projectId: string;
-    imageReference: string;
-    deploymentFriendlyId: string;
-    authenticatedEnv: AuthenticatedEnvironment;
-    writer?: WritableStreamDefaultWriter;
-  }): Promise<"required" | "shadow" | "skip"> {
-    const { templateService, projectId, imageReference, deploymentFriendlyId, authenticatedEnv, writer } = options;
-
-    const mode = await templateService.resolveMode(projectId, this._prisma);
-
-    if (mode !== "required") {
-      return mode;
-    }
-
-    if (writer) {
-      await writer.write(
-        `event: log\ndata: ${JSON.stringify({ message: "Building compute template..." })}\n\n`
-      );
-    }
-
-    const templateResult = await templateService.createTemplate(imageReference);
-
-    if (!templateResult.success) {
-      logger.error("Compute template creation failed", {
-        id: deploymentFriendlyId,
-        imageReference,
-        error: templateResult.error,
-      });
-
-      const failService = new FailDeploymentService();
-      await failService.call(authenticatedEnv, deploymentFriendlyId, {
-        error: {
-          name: "TemplateCreationFailed",
-          message: `Failed to create compute template: ${templateResult.error}`,
-        },
-      });
-
-      throw new ServiceValidationError(
-        `Compute template creation failed: ${templateResult.error}`
-      );
+  async #createTemplateIfNeeded(
+    deployment: { imageReference: string | null; worker: { project: { id: string } } | null },
+    deploymentFriendlyId: string,
+    authenticatedEnv: AuthenticatedEnvironment,
+    writer?: WritableStreamDefaultWriter
+  ): Promise<void> {
+    if (!deployment.imageReference || !deployment.worker) {
+      return;
     }
 
-    logger.debug("Compute template created", {
-      id: deploymentFriendlyId,
-      imageReference,
-    });
-
-    return mode;
-  }
-
-  #fireShadowTemplateCreation(
-    templateService: ComputeTemplateCreationService,
-    imageReference: string,
-    deploymentFriendlyId: string
-  ) {
-    templateService.createTemplate(imageReference, { background: true }).catch((error) => {
-      logger.error("Shadow compute template creation failed", {
-        id: deploymentFriendlyId,
-        imageReference,
-        error: error instanceof Error ? error.message : String(error),
-      });
+    const templateService = new ComputeTemplateCreationService();
+    await templateService.handleDeployTemplate({
+      projectId: deployment.worker.project.id,
+      imageReference: deployment.imageReference,
+      deploymentFriendlyId,
+      authenticatedEnv,
+      prisma: this._prisma,
+      writer,
     });
   }
 }
