feat(webapp): admin route to request template builds for deployments

Add an admin route to request compute template builds for existing deployments.

Mono-RevId: adae12bcc253c0e7a19eee851da1638977b74052

Author: 1stvamp

apps/webapp/app/routes/admin.api.v1.deployments.template-builds.ts

@@ -0,0 +1,45 @@
+import type { ActionFunctionArgs } from "@remix-run/server-runtime";
+import { json } from "@remix-run/server-runtime";
+import { tryCatch } from "@trigger.dev/core/v3";
+import { z } from "zod";
+import { logger } from "~/services/logger.server";
+import { requireAdminApiRequest } from "~/services/personalAccessToken.server";
+import { TemplatePrebuildService } from "~/v3/services/templatePrebuild.server";
+
+const BodySchema = z.object({
+  // Deployment ids or friendly ids.
+  deploymentIds: z.array(z.string().min(1)).min(1).max(50),
+  force: z.boolean().default(false),
+});
+
+export async function action({ request }: ActionFunctionArgs) {
+  await requireAdminApiRequest(request);
+
+  if (request.method.toUpperCase() !== "POST") {
+    return json({ error: "Method Not Allowed" }, { status: 405 });
+  }
+
+  const [bodyError, body] = await tryCatch(request.json());
+  if (bodyError) {
+    return json({ error: bodyError.message }, { status: 400 });
+  }
+
+  const parsedBody = BodySchema.safeParse(body);
+  if (!parsedBody.success) {
+    return json({ error: parsedBody.error.message }, { status: 400 });
+  }
+
+  const deploymentIds = [...new Set(parsedBody.data.deploymentIds)];
+  const results = await new TemplatePrebuildService().requestBuilds({
+    deploymentIds,
+    force: parsedBody.data.force,
+  });
+
+  logger.info("Admin template builds requested", {
+    count: deploymentIds.length,
+    force: parsedBody.data.force,
+    results,
+  });
+
+  return json({ results });
+}

apps/webapp/app/v3/services/templatePrebuild.server.test.ts

@@ -95,7 +95,12 @@ async function createProject(
 async function createDeployment(
   prisma: any,
   project: { id: string; organizationId: string },
-  options: { status?: "DEPLOYING" | "DEPLOYED"; imageReference?: string; templateKey?: string } = {}
+  options: {
+    status?: "DEPLOYING" | "DEPLOYED";
+    imageReference?: string;
+    templateKey?: string;
+    deployedAt?: Date;
+  } = {}
 ) {
   const id = randomUUID();
   const environment = await prisma.runtimeEnvironment.create({
@@ -120,6 +125,7 @@ async function createDeployment(
       status: options.status ?? "DEPLOYING",
       imageReference: options.imageReference ?? IMAGE,
       templateKey: options.templateKey,
+      deployedAt: options.deployedAt,
     },
   });
 }
@@ -667,3 +673,119 @@ describe("prebuild", () => {
     ).resolves.toEqual({ mode: "skip" });
   });
 });
+
+describe("requestBuilds", () => {
+  const PINNED = `${IMAGE}@${DIGEST}`;
+
+  postgresTest(
+    "builds deployments by id or friendly id and reports each outcome",
+    async ({ prisma }) => {
+      const server = await builder(reply(200, { template_id: TEMPLATE_KEY }));
+      try {
+        const project = await createProject(prisma);
+        const byId = await createDeployment(prisma, project, {
+          status: "DEPLOYED",
+          imageReference: PINNED,
+        });
+        const old = await createDeployment(prisma, project, {
+          status: "DEPLOYED",
+          imageReference: PINNED,
+          deployedAt: new Date("2025-01-01T00:00:00Z"),
+        });
+        const keyed = await createDeployment(prisma, project, {
+          status: "DEPLOYED",
+          imageReference: PINNED,
+          templateKey: "b".repeat(64),
+        });
+        const unpinned = await createDeployment(prisma, project, { status: "DEPLOYED" });
+        const service = new TemplatePrebuildService(prisma, config({ url: server.url }));
+
+        const results = await service.requestBuilds({
+          deploymentIds: [byId.id, old.friendlyId, keyed.id, unpinned.id, "deployment_missing"],
+        });
+
+        expect(results).toEqual([
+          { deploymentId: byId.id, friendlyId: byId.friendlyId, outcome: "built" },
+          { deploymentId: old.friendlyId, friendlyId: old.friendlyId, outcome: "built" },
+          {
+            deploymentId: keyed.id,
+            friendlyId: keyed.friendlyId,
+            outcome: "skipped",
+            reason: "has_key",
+          },
+          {
+            deploymentId: unpinned.id,
+            friendlyId: unpinned.friendlyId,
+            outcome: "skipped",
+            reason: "no_pinned_image",
+          },
+          { deploymentId: "deployment_missing", outcome: "not_found" },
+        ]);
+        expect(server.requests).toHaveLength(2);
+        expect(JSON.parse(server.requests[0].body).image).toBe(PINNED);
+        expect(await storedTemplateKey(prisma, byId.id)).toBe(TEMPLATE_KEY);
+        expect(await storedTemplateKey(prisma, old.id)).toBe(TEMPLATE_KEY);
+        expect(await storedTemplateKey(prisma, keyed.id)).toBe("b".repeat(64));
+      } finally {
+        await server.close();
+      }
+    }
+  );
+
+  postgresTest("force rebuilds a deployment that has a key", async ({ prisma }) => {
+    const server = await builder(reply(200, { template_id: TEMPLATE_KEY }));
+    try {
+      const project = await createProject(prisma);
+      const keyed = await createDeployment(prisma, project, {
+        status: "DEPLOYED",
+        imageReference: PINNED,
+        templateKey: "b".repeat(64),
+      });
+      const service = new TemplatePrebuildService(prisma, config({ url: server.url }));
+
+      const [result] = await service.requestBuilds({ deploymentIds: [keyed.id], force: true });
+
+      expect(result).toMatchObject({ outcome: "built" });
+      expect(await storedTemplateKey(prisma, keyed.id)).toBe(TEMPLATE_KEY);
+    } finally {
+      await server.close();
+    }
+  });
+
+  postgresTest("reports a 429 from the builder as rate_limited", async ({ prisma }) => {
+    const server = await builder(reply(429, { error: "slow down" }));
+    try {
+      const project = await createProject(prisma);
+      const row = await createDeployment(prisma, project, {
+        status: "DEPLOYED",
+        imageReference: PINNED,
+      });
+      const service = new TemplatePrebuildService(prisma, config({ url: server.url }));
+
+      const [result] = await service.requestBuilds({ deploymentIds: [row.id] });
+
+      expect(result).toMatchObject({ outcome: "rate_limited" });
+      expect(await storedTemplateKey(prisma, row.id)).toBeNull();
+    } finally {
+      await server.close();
+    }
+  });
+
+  postgresTest("skips every deployment when no builder is configured", async ({ prisma }) => {
+    const project = await createProject(prisma);
+    const row = await createDeployment(prisma, project, {
+      status: "DEPLOYED",
+      imageReference: PINNED,
+    });
+    const service = new TemplatePrebuildService(prisma, config({ url: undefined }));
+
+    await expect(service.requestBuilds({ deploymentIds: [row.id] })).resolves.toEqual([
+      {
+        deploymentId: row.id,
+        friendlyId: row.friendlyId,
+        outcome: "skipped",
+        reason: "no_builder",
+      },
+    ]);
+  });
+});

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

@@ -26,7 +26,25 @@ export type TemplatePrebuildReason =
   | "rollout"
   | "none";
 
-export type TemplateBuildOutcome = "built" | "already_there" | "failed" | "timeout";
+export type TemplateBuildOutcome =
+  | "built"
+  | "already_there"
+  | "failed"
+  | "timeout"
+  | "rate_limited";
+
+type TemplateBuildRequestSkip = "no_builder" | "has_key" | "no_pinned_image";
+
+export type TemplateBuildRequestResult = {
+  deploymentId: string;
+  friendlyId?: string;
+} & (
+  | { outcome: TemplateBuildOutcome }
+  | { outcome: "skipped"; reason: TemplateBuildRequestSkip }
+  | { outcome: "not_found" }
+);
+
+const BUILD_REQUEST_CONCURRENCY = 10;
 
 export type TemplateBuilderConfig = {
   url?: string;
@@ -257,6 +275,59 @@ export class TemplatePrebuildService {
     return "none";
   }
 
+  /**
+   * Requests a shadow build for each deployment, by id or friendly id, whatever its age. A
+   * deployment that has a key is skipped unless `force` is set. The store guard still applies.
+   */
+  async requestBuilds({
+    deploymentIds,
+    force = false,
+  }: {
+    deploymentIds: string[];
+    force?: boolean;
+  }): Promise<TemplateBuildRequestResult[]> {
+    const results: TemplateBuildRequestResult[] = [];
+    for (let i = 0; i < deploymentIds.length; i += BUILD_REQUEST_CONCURRENCY) {
+      const batch = deploymentIds.slice(i, i + BUILD_REQUEST_CONCURRENCY);
+      results.push(
+        ...(await Promise.all(batch.map((deploymentId) => this.requestBuild(deploymentId, force))))
+      );
+    }
+    return results;
+  }
+
+  private async requestBuild(
+    deploymentId: string,
+    force: boolean
+  ): Promise<TemplateBuildRequestResult> {
+    const deployment = await this.prisma.workerDeployment.findFirst({
+      where: { OR: [{ id: deploymentId }, { friendlyId: deploymentId }] },
+      select: { id: true, friendlyId: true, imageReference: true, templateKey: true },
+    });
+    if (!deployment) {
+      return { deploymentId, outcome: "not_found" };
+    }
+    const base = { deploymentId, friendlyId: deployment.friendlyId };
+    if (!this.config.url) {
+      return { ...base, outcome: "skipped", reason: "no_builder" };
+    }
+    if (deployment.templateKey && !force) {
+      return { ...base, outcome: "skipped", reason: "has_key" };
+    }
+    // Finalisation stores the image pinned by digest; without one there is nothing to build.
+    const image = deployment.imageReference
+      ? pinnedImageReference(deployment.imageReference, undefined)
+      : undefined;
+    if (!image) {
+      return { ...base, outcome: "skipped", reason: "no_pinned_image" };
+    }
+    const outcome = await this.build(image, "shadow", {
+      id: deployment.id,
+      friendlyId: deployment.friendlyId,
+    });
+    return { ...base, outcome };
+  }
+
   /**
    * Call the builder once and store the template key on success. Resolves with
    * the outcome; never rejects.
@@ -303,7 +374,7 @@ export class TemplatePrebuildService {
           this.config.timeoutMs - (performance.now() - startedAt)
         );
       } else {
-        outcome = "failed";
+        outcome = response.status === 429 ? "rate_limited" : "failed";
         logger.error("Template prebuild failed", {
           ...log,
           status: response.status,