Try out neverthrow for error handling in the project setting flows

Author: myftija

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

@@ -215,97 +215,171 @@ export const action: ActionFunction = async ({ request, params }) => {
   }
 
   const projectSettingsService = new ProjectSettingsService();
-  const project = await projectSettingsService.verifyProjectMembership(
-    projectParam,
+  const membershipResultOrFail = await projectSettingsService.verifyProjectMembership(
     organizationSlug,
+    projectParam,
     userId
   );
 
-  if (!project) {
-    return json({ errors: { body: "project not found" } }, { status: 404 });
+  if (membershipResultOrFail.isErr()) {
+    return json({ errors: { body: membershipResultOrFail.error.type } }, { status: 404 });
   }
 
-  try {
-    switch (submission.value.action) {
-      case "rename": {
-        await projectSettingsService.renameProject(project.id, submission.value.projectName);
+  const { projectId, organizationId } = membershipResultOrFail.value;
 
-        return redirectWithSuccessMessage(
-          v3ProjectPath({ slug: organizationSlug }, { slug: projectParam }),
-          request,
-          `Project renamed to ${submission.value.projectName}`
-        );
-      }
-      case "delete": {
-        try {
-          await projectSettingsService.deleteProject(projectParam, userId);
-
-          return redirectWithSuccessMessage(
-            organizationPath({ slug: organizationSlug }),
-            request,
-            "Project deleted"
-          );
-        } catch (error: unknown) {
-          logger.error("Project could not be deleted", {
-            error: error instanceof Error ? error.message : JSON.stringify(error),
-          });
-          return redirectWithErrorMessage(
-            v3ProjectPath({ slug: organizationSlug }, { slug: projectParam }),
-            request,
-            `Project ${projectParam} could not be deleted`
-          );
+  switch (submission.value.action) {
+    case "rename": {
+      const resultOrFail = await projectSettingsService.renameProject(
+        projectId,
+        submission.value.projectName
+      );
+
+      if (resultOrFail.isErr()) {
+        switch (resultOrFail.error.type) {
+          case "other":
+          default: {
+            resultOrFail.error.type satisfies "other";
+
+            logger.error("Failed to rename project", {
+              error: resultOrFail.error,
+            });
+            return json({ errors: { body: "Failed to rename project" } }, { status: 400 });
+          }
         }
       }
-      case "disconnect-repo": {
-        await projectSettingsService.disconnectGitHubRepo(project.id);
 
-        return redirectBackWithSuccessMessage(
-          request,
-          "GitHub repository disconnected successfully"
-        );
+      return redirectWithSuccessMessage(
+        v3ProjectPath({ slug: organizationSlug }, { slug: projectParam }),
+        request,
+        `Project renamed to ${submission.value.projectName}`
+      );
+    }
+    case "delete": {
+      const resultOrFail = await projectSettingsService.deleteProject(projectParam, userId);
+
+      if (resultOrFail.isErr()) {
+        switch (resultOrFail.error.type) {
+          case "other":
+          default: {
+            resultOrFail.error.type satisfies "other";
+
+            logger.error("Failed to delete project", {
+              error: resultOrFail.error,
+            });
+            return redirectWithErrorMessage(
+              v3ProjectPath({ slug: organizationSlug }, { slug: projectParam }),
+              request,
+              `Project ${projectParam} could not be deleted`
+            );
+          }
+        }
       }
-      case "update-git-settings": {
-        const { productionBranch, stagingBranch, previewDeploymentsEnabled } = submission.value;
-
-        try {
-          await projectSettingsService.updateGitSettings(
-            project.id,
-            productionBranch,
-            stagingBranch,
-            previewDeploymentsEnabled
-          );
-
-          return redirectBackWithSuccessMessage(request, "Git settings updated successfully");
-        } catch (error: any) {
-          return redirectBackWithErrorMessage(request, error.message);
+
+      return redirectWithSuccessMessage(
+        organizationPath({ slug: organizationSlug }),
+        request,
+        "Project deleted"
+      );
+    }
+    case "disconnect-repo": {
+      const resultOrFail = await projectSettingsService.disconnectGitHubRepo(projectId);
+
+      if (resultOrFail.isErr()) {
+        switch (resultOrFail.error.type) {
+          case "other":
+          default: {
+            resultOrFail.error.type satisfies "other";
+
+            logger.error("Failed to disconnect GitHub repository", {
+              error: resultOrFail.error,
+            });
+            return redirectBackWithErrorMessage(request, "Failed to disconnect GitHub repository");
+          }
         }
       }
-      case "connect-repo": {
-        const { repositoryId, installationId } = submission.value;
-
-        try {
-          await projectSettingsService.connectGitHubRepo(
-            project.id,
-            project.organizationId,
-            repositoryId,
-            installationId
-          );
-
-          return json({
-            ...submission,
-            success: true,
-          });
-        } catch (error: any) {
-          return redirectBackWithErrorMessage(request, error.message);
+
+      return redirectBackWithSuccessMessage(request, "GitHub repository disconnected successfully");
+    }
+    case "update-git-settings": {
+      const { productionBranch, stagingBranch, previewDeploymentsEnabled } = submission.value;
+
+      const resultOrFail = await projectSettingsService.updateGitSettings(
+        projectId,
+        productionBranch,
+        stagingBranch,
+        previewDeploymentsEnabled
+      );
+
+      if (resultOrFail.isErr()) {
+        switch (resultOrFail.error.type) {
+          case "github_app_not_enabled": {
+            return redirectBackWithErrorMessage(request, "GitHub app is not enabled");
+          }
+          case "connected_gh_repository_not_found": {
+            return redirectBackWithErrorMessage(request, "Connected GitHub repository not found");
+          }
+          case "production_tracking_branch_not_found": {
+            return redirectBackWithErrorMessage(request, "Production tracking branch not found");
+          }
+          case "staging_tracking_branch_not_found": {
+            return redirectBackWithErrorMessage(request, "Staging tracking branch not found");
+          }
+          case "other":
+          default: {
+            resultOrFail.error.type satisfies "other";
+
+            logger.error("Failed to update Git settings", {
+              error: resultOrFail.error,
+            });
+            return redirectBackWithErrorMessage(request, "Failed to update Git settings");
+          }
         }
       }
-      default: {
-        submission.value satisfies never;
-        return redirectBackWithErrorMessage(request, "Failed to process request");
+
+      return redirectBackWithSuccessMessage(request, "Git settings updated successfully");
+    }
+    case "connect-repo": {
+      const { repositoryId, installationId } = submission.value;
+
+      const resultOrFail = await projectSettingsService.connectGitHubRepo(
+        projectId,
+        organizationId,
+        repositoryId,
+        installationId
+      );
+
+      if (resultOrFail.isErr()) {
+        switch (resultOrFail.error.type) {
+          case "gh_repository_not_found": {
+            return redirectBackWithErrorMessage(request, "GitHub repository not found");
+          }
+          case "project_already_has_connected_repository": {
+            return redirectBackWithErrorMessage(
+              request,
+              "Project already has a connected repository"
+            );
+          }
+          case "other":
+          default: {
+            resultOrFail.error.type satisfies "other";
+
+            logger.error("Failed to connect GitHub repository", {
+              error: resultOrFail.error,
+            });
+            return redirectBackWithErrorMessage(request, "Failed to connect GitHub repository");
+          }
+        }
       }
+
+      return json({
+        ...submission,
+        success: true,
+      });
+    }
+    default: {
+      submission.value satisfies never;
+      return redirectBackWithErrorMessage(request, "Failed to process request");
     }
-  } catch (error: any) {
-    return json({ errors: { body: error.message } }, { status: 400 });
   }
 };
 

apps/webapp/app/services/gitHub.server.ts

@@ -2,7 +2,7 @@ import { App, type Octokit } from "octokit";
 import { env } from "../env.server";
 import { prisma } from "~/db.server";
 import { logger } from "./logger.server";
-import { tryCatch } from "@trigger.dev/core/utils";
+import { errAsync, fromPromise, okAsync, type ResultAsync } from "neverthrow";
 
 export const githubApp =
   env.GITHUB_APP_ENABLED === "1"
@@ -138,43 +138,53 @@ async function fetchInstallationRepositories(octokit: Octokit, installationId: n
 /**
  * Checks if a branch exists in a GitHub repository
  */
-export async function checkGitHubBranchExists(
+export function checkGitHubBranchExists(
   installationId: number,
-  owner: string,
-  repo: string,
+  fullRepoName: string,
   branch: string
-): Promise<boolean> {
+): ResultAsync<boolean, { type: "other" | "github_app_not_enabled"; cause?: unknown }> {
   if (!githubApp) {
-    throw new Error("GitHub App is not enabled");
+    return errAsync({ type: "github_app_not_enabled" as const });
   }
 
   if (!branch || branch.trim() === "") {
-    return false;
-  }
-
-  const octokit = await githubApp.getInstallationOctokit(installationId);
-  const [error] = await tryCatch(
-    octokit.rest.repos.getBranch({
-      owner,
-      repo,
-      branch,
-    })
-  );
-
-  if (error && "status" in error && error.status === 404) {
-    return false;
+    return okAsync(false);
   }
 
-  if (error) {
-    logger.error("Error checking GitHub branch", {
-      installationId,
-      owner,
-      repo,
-      branch,
-      error: error.message,
+  const [owner, repo] = fullRepoName.split("/");
+
+  const getOctokit = () =>
+    fromPromise(githubApp.getInstallationOctokit(installationId), (error) => ({
+      type: "other" as const,
+      cause: error,
+    }));
+
+  const getBranch = (octokit: Octokit) =>
+    fromPromise(
+      octokit.rest.repos.getBranch({
+        owner,
+        repo,
+        branch,
+      }),
+      (error) => ({
+        type: "other" as const,
+        cause: error,
+      })
+    );
+
+  return getOctokit()
+    .andThen((octokit) => getBranch(octokit))
+    .map(() => true)
+    .orElse((error) => {
+      if (
+        error.cause &&
+        error.cause instanceof Error &&
+        "status" in error.cause &&
+        error.cause.status === 404
+      ) {
+        return okAsync(false);
+      }
+
+      return errAsync(error);
     });
-    throw error;
-  }
-
-  return true;
 }