Archiving branch via the CLI working

Author: matt-aitken

apps/webapp/app/routes/api.v1.projects.$projectRef.branches.archive.ts

@@ -0,0 +1,85 @@
+import { type ActionFunctionArgs, json } from "@remix-run/server-runtime";
+import { tryCatch } from "@trigger.dev/core";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { ArchiveBranchService } from "~/services/archiveBranch.server";
+import { logger } from "~/services/logger.server";
+import { authenticateApiRequestWithPersonalAccessToken } from "~/services/personalAccessToken.server";
+
+const ParamsSchema = z.object({
+  projectRef: z.string(),
+});
+
+const BodySchema = z.object({
+  branch: z.string(),
+});
+
+export async function action({ request, params }: ActionFunctionArgs) {
+  if (request.method !== "POST") {
+    return json({ error: "Method not allowed" }, { status: 405 });
+  }
+
+  logger.info("Archive branch", { url: request.url, params });
+
+  const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
+  if (!authenticationResult) {
+    return json({ error: "Invalid or Missing Access Token" }, { status: 401 });
+  }
+
+  const parsedParams = ParamsSchema.safeParse(params);
+
+  if (!parsedParams.success) {
+    return json({ error: "Invalid Params" }, { status: 400 });
+  }
+
+  const { projectRef } = parsedParams.data;
+
+  const [error, body] = await tryCatch(request.json());
+  if (error) {
+    return json({ error: error.message }, { status: 400 });
+  }
+
+  const parsed = BodySchema.safeParse(body);
+  if (!parsed.success) {
+    return json({ error: parsed.error.message }, { status: 400 });
+  }
+
+  const environment = await prisma.runtimeEnvironment.findFirst({
+    select: {
+      id: true,
+      archivedAt: true,
+    },
+    where: {
+      organization: {
+        members: {
+          some: {
+            userId: authenticationResult.userId,
+          },
+        },
+      },
+      project: {
+        externalRef: projectRef,
+      },
+      branchName: parsed.data.branch,
+    },
+  });
+
+  if (!environment) {
+    return json({ error: "Branch not found" }, { status: 404 });
+  }
+
+  if (environment.archivedAt) {
+    return json({ error: "Branch already archived" }, { status: 400 });
+  }
+
+  const service = new ArchiveBranchService();
+  const result = await service.call(authenticationResult.userId, {
+    environmentId: environment.id,
+  });
+
+  if (result.success) {
+    return json(result);
+  } else {
+    return json(result, { status: 400 });
+  }
+}

apps/webapp/app/routes/api.v1.projects.$projectRef.branches.ts

@@ -13,7 +13,11 @@ const ParamsSchema = z.object({
 type ParamsSchema = z.infer<typeof ParamsSchema>;
 
 export async function action({ request, params }: ActionFunctionArgs) {
-  logger.info("projects get env", { url: request.url });
+  if (request.method !== "POST") {
+    return json({ error: "Method not allowed" }, { status: 405 });
+  }
+
+  logger.info("project upsert branch", { url: request.url });
 
   const authenticationResult = await authenticateApiRequestWithPersonalAccessToken(request);
   if (!authenticationResult) {

packages/cli-v3/src/apiClient.ts

@@ -182,17 +182,18 @@ export class CliApiClient {
     );
   }
 
-  async archiveBranch(branch: string) {
+  async archiveBranch(projectRef: string, branch: string) {
     if (!this.accessToken) {
       throw new Error("archiveBranch: No access token");
     }
 
     return wrapZodFetch(
-      z.object({ success: z.boolean() }),
-      `${this.apiURL}/api/v1/branches/${branch}/archive`,
+      z.object({ branch: z.object({ id: z.string() }) }),
+      `${this.apiURL}/api/v1/projects/${projectRef}/branches/archive`,
       {
         method: "POST",
         headers: this.getHeaders(),
+        body: JSON.stringify({ branch }),
       }
     );
   }

packages/cli-v3/src/cli/index.ts

@@ -14,6 +14,7 @@ import { configureWorkersCommand } from "../commands/workers/index.js";
 import { configureSwitchProfilesCommand } from "../commands/switch.js";
 import { configureTriggerTaskCommand } from "../commands/trigger.js";
 import { configurePromoteCommand } from "../commands/promote.js";
+import { configurePreviewCommand } from "../commands/preview.js";
 
 export const program = new Command();
 
@@ -32,6 +33,7 @@ configureLogoutCommand(program);
 configureListProfilesCommand(program);
 configureSwitchProfilesCommand(program);
 configureUpdateCommand(program);
+configurePreviewCommand(program);
 // configureWorkersCommand(program);
 // configureTriggerTaskCommand(program);
 

packages/cli-v3/src/commands/preview.ts

@@ -1,63 +1,45 @@
-import { intro, log, outro } from "@clack/prompts";
-import { getBranch, prepareDeploymentError } from "@trigger.dev/core/v3";
-import { InitializeDeploymentResponseBody } from "@trigger.dev/core/v3/schemas";
-import { Command, Option as CommandOption } from "commander";
+import { intro } from "@clack/prompts";
+import { getBranch } from "@trigger.dev/core/v3";
+import { Command } from "commander";
 import { resolve } from "node:path";
-import { x } from "tinyexec";
 import { z } from "zod";
-import { isCI } from "std-env";
-import { CliApiClient } from "../apiClient.js";
-import { buildWorker } from "../build/buildWorker.js";
-import { resolveAlwaysExternal } from "../build/externals.js";
 import {
   CommonCommandOptions,
   commonOptions,
   handleTelemetry,
-  SkipLoggingError,
   wrapCommandAction,
 } from "../cli/common.js";
 import { loadConfig } from "../config.js";
-import { buildImage } from "../deploy/buildImage.js";
-import {
-  checkLogsForErrors,
-  checkLogsForWarnings,
-  printErrors,
-  printWarnings,
-  saveLogs,
-} from "../deploy/logs.js";
-import { chalkError, cliLink, isLinksSupported, prettyError } from "../utilities/cliOutput.js";
-import { loadDotEnvVars } from "../utilities/dotEnv.js";
+import { createGitMeta } from "../utilities/gitMeta.js";
 import { printStandloneInitialBanner } from "../utilities/initialBanner.js";
 import { logger } from "../utilities/logger.js";
-import { getProjectClient, upsertBranch } from "../utilities/session.js";
-import { getTmpDir } from "../utilities/tempDirectories.js";
+import { getProjectClient } from "../utilities/session.js";
 import { spinner } from "../utilities/windows.js";
+import { verifyDirectory } from "./deploy.js";
 import { login } from "./login.js";
 import { updateTriggerPackages } from "./update.js";
-import { setGithubActionsOutputAndEnvVars } from "../utilities/githubActions.js";
-import { isDirectory } from "../utilities/fileSystem.js";
-import { createGitMeta } from "../utilities/gitMeta.js";
-import { verifyDirectory } from "./deploy.js";
+import { CliApiClient } from "../apiClient.js";
 
 const PreviewCommandOptions = CommonCommandOptions.extend({
   branch: z.string().optional(),
   config: z.string().optional(),
   projectRef: z.string().optional(),
   skipUpdateCheck: z.boolean().default(false),
-  envFile: z.string().optional(),
 });
 
 type PreviewCommandOptions = z.infer<typeof PreviewCommandOptions>;
 
-export function configureDeployCommand(program: Command) {
-  return commonOptions(
-    program
-      .command("preview archive")
+export function configurePreviewCommand(program: Command) {
+  const preview = program.command("preview").description("Modify preview branches");
+
+  commonOptions(
+    preview
+      .command("archive")
       .description("Archive a preview branch")
       .argument("[path]", "The path to the project", ".")
       .option(
         "-b, --branch <branch>",
-        "The preview branch to deploy to when passing --env preview. If not provided, we'll detect your local git branch."
+        "The preview branch to archive. If not provided, we'll detect your local git branch."
       )
       .option("--skip-update-check", "Skip checking for @trigger.dev package updates")
       .option("-c, --config <config file>", "The name of the config file, found at [path]")
@@ -137,23 +119,17 @@ async function _previewArchiveCommand(dir: string, options: PreviewCommandOption
     );
   }
 
-  const projectClient = await getProjectClient({
-    accessToken: authorization.auth.accessToken,
-    apiUrl: authorization.auth.apiUrl,
-    projectRef: resolvedConfig.project,
-    env: "preview",
-    branch,
-    profile: options.profile,
-  });
-
-  if (!projectClient) {
-    throw new Error("Failed to get project client");
-  }
+  const apiClient = new CliApiClient(authorization.auth.apiUrl, authorization.auth.accessToken);
 
   const $buildSpinner = spinner();
   $buildSpinner.start(`Archiving "${branch}"`);
 
-  const result = await projectClient.client.archiveBranch(branch);
+  const result = await apiClient.archiveBranch(resolvedConfig.project, branch);
 
-  $buildSpinner.stop(`Successfully archived ${branch}`);
+  if (result.success) {
+    $buildSpinner.stop(`Successfully archived "${branch}"`);
+  } else {
+    $buildSpinner.stop(`Failed to archive "${branch}".`);
+    logger.error(result.error);
+  }
 }