Introduce neverthrow for error handling

myftija · myftija · commit 9a27e59fbdfa · 2025-09-05T15:45:20.000+02:00
diff --git a/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings/route.tsx b/apps/webapp/app/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.settings/route.tsx
@@ -42,7 +42,6 @@ import { NavBar, PageAccessories, PageTitle } from "~/components/primitives/Page
 import { Paragraph } from "~/components/primitives/Paragraph";
 import * as Property from "~/components/primitives/PropertyTable";
 import { SpinnerWhite } from "~/components/primitives/Spinner";
-import { prisma } from "~/db.server";
 import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
 import {
@@ -53,7 +52,6 @@ import {
   getSession,
   commitSession,
 } from "~/models/message.server";
-import { findProjectBySlug } from "~/models/project.server";
 import { ProjectSettingsService } from "~/services/projectSettings.server";
 import { logger } from "~/services/logger.server";
 import { requireUserId } from "~/services/session.server";
@@ -64,17 +62,16 @@ import {
   EnvironmentParamSchema,
   v3ProjectSettingsPath,
 } from "~/utils/pathBuilder";
-import React, { useEffect, useState } from "react";
+import { useEffect, useState } from "react";
 import { Select, SelectItem } from "~/components/primitives/Select";
 import { Switch } from "~/components/primitives/Switch";
-import { BranchTrackingConfigSchema, type BranchTrackingConfig } from "~/v3/github";
+import { type BranchTrackingConfig } from "~/v3/github";
 import {
   EnvironmentIcon,
   environmentFullTitle,
   environmentTextClassName,
 } from "~/components/environments/EnvironmentLabel";
 import { GitBranchIcon } from "lucide-react";
-import { env } from "~/env.server";
 import { useEnvironment } from "~/hooks/useEnvironment";
 import { DateTime } from "~/components/primitives/DateTime";
 import { TextLink } from "~/components/primitives/TextLink";
@@ -94,12 +91,37 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   const { projectParam, organizationSlug } = EnvironmentParamSchema.parse(params);
 
   const projectSettingsPresenter = new ProjectSettingsPresenter();
-  const { gitHubApp } = await projectSettingsPresenter.getProjectSettings(
+  const resultOrFail = await projectSettingsPresenter.getProjectSettings(
     organizationSlug,
     projectParam,
     userId
   );
 
+  if (resultOrFail.isErr()) {
+    switch (resultOrFail.error.type) {
+      case "project_not_found": {
+        throw new Response(undefined, {
+          status: 404,
+          statusText: "Project not found",
+        });
+      }
+      case "other":
+      default: {
+        resultOrFail.error.type satisfies "other";
+
+        logger.error("Failed loading project settings", {
+          error: resultOrFail.error,
+        });
+        throw new Response(undefined, {
+          status: 400,
+          statusText: "Something went wrong, please try again!",
+        });
+      }
+    }
+  }
+
+  const { gitHubApp } = resultOrFail.value;
+
   const session = await getSession(request.headers.get("Cookie"));
   const openGitHubRepoConnectionModal = session.get("gitHubAppInstalled") === true;
   const headers = new Headers({
@@ -278,7 +300,8 @@ export const action: ActionFunction = async ({ request, params }) => {
         }
       }
       default: {
-        return submission.value satisfies never;
+        submission.value satisfies never;
+        return redirectBackWithErrorMessage(request, "Failed to process request");
       }
     }
   } catch (error: any) {
diff --git a/apps/webapp/app/services/projectSettingsPresenter.server.ts b/apps/webapp/app/services/projectSettingsPresenter.server.ts
@@ -1,11 +1,9 @@
 import { type PrismaClient } from "@trigger.dev/database";
 import { prisma } from "~/db.server";
-import { DeleteProjectService } from "~/services/deleteProject.server";
-import { BranchTrackingConfigSchema, type BranchTrackingConfig } from "~/v3/github";
-import { checkGitHubBranchExists } from "~/services/gitHub.server";
-import { tryCatch } from "@trigger.dev/core/utils";
+import { BranchTrackingConfigSchema } from "~/v3/github";
 import { env } from "~/env.server";
 import { findProjectBySlug } from "~/models/project.server";
+import { err, fromPromise, ok, okAsync } from "neverthrow";
 
 export class ProjectSettingsPresenter {
   #prismaClient: PrismaClient;
@@ -14,101 +12,133 @@ export class ProjectSettingsPresenter {
     this.#prismaClient = prismaClient;
   }
 
-  async getProjectSettings(organizationSlug: string, projectSlug: string, userId: string) {
+  getProjectSettings(organizationSlug: string, projectSlug: string, userId: string) {
     const githubAppEnabled = env.GITHUB_APP_ENABLED === "1";
 
     if (!githubAppEnabled) {
-      return {
+      return okAsync({
         gitHubApp: {
           enabled: false,
           connectedRepository: undefined,
           installations: undefined,
         },
-      };
+      });
     }
 
-    const project = await findProjectBySlug(organizationSlug, projectSlug, userId);
-    if (!project) {
-      throw new Error("Project not found");
-    }
-    const connectedGithubRepository = await prisma.connectedGithubRepository.findFirst({
-      where: {
-        projectId: project.id,
-      },
-      select: {
-        branchTracking: true,
-        previewDeploymentsEnabled: true,
-        createdAt: true,
-        repository: {
+    const getProject = () =>
+      fromPromise(findProjectBySlug(organizationSlug, projectSlug, userId), (error) => ({
+        type: "other" as const,
+        cause: error,
+      })).andThen((project) => {
+        if (!project) {
+          return err({ type: "project_not_found" as const });
+        }
+        return ok(project);
+      });
+
+    const findConnectedGithubRepository = (projectId: string) =>
+      fromPromise(
+        this.#prismaClient.connectedGithubRepository.findFirst({
+          where: {
+            projectId,
+          },
           select: {
-            id: true,
-            name: true,
-            fullName: true,
-            htmlUrl: true,
-            private: true,
+            branchTracking: true,
+            previewDeploymentsEnabled: true,
+            createdAt: true,
+            repository: {
+              select: {
+                id: true,
+                name: true,
+                fullName: true,
+                htmlUrl: true,
+                private: true,
+              },
+            },
           },
-        },
-      },
-    });
+        }),
+        (error) => ({
+          type: "other" as const,
+          cause: error,
+        })
+      ).map((connectedGithubRepository) => {
+        if (!connectedGithubRepository) {
+          return undefined;
+        }
 
-    if (connectedGithubRepository) {
-      const branchTrackingOrFailure = BranchTrackingConfigSchema.safeParse(
-        connectedGithubRepository.branchTracking
-      );
+        const branchTrackingOrFailure = BranchTrackingConfigSchema.safeParse(
+          connectedGithubRepository.branchTracking
+        );
+        return {
+          ...connectedGithubRepository,
+          branchTracking: branchTrackingOrFailure.success
+            ? branchTrackingOrFailure.data
+            : undefined,
+        };
+      });
 
-      return {
-        gitHubApp: {
-          enabled: true,
-          connectedRepository: {
-            ...connectedGithubRepository,
-            branchTracking: branchTrackingOrFailure.success
-              ? branchTrackingOrFailure.data
-              : undefined,
+    const listGithubAppInstallations = (organizationId: string) =>
+      fromPromise(
+        this.#prismaClient.githubAppInstallation.findMany({
+          where: {
+            organizationId,
+            deletedAt: null,
+            suspendedAt: null,
           },
-          // skip loading installations if there is a connected repository
-          // a project can have only a single connected repository
-          installations: undefined,
-        },
-      };
-    }
-
-    const githubAppInstallations = await prisma.githubAppInstallation.findMany({
-      where: {
-        organizationId: project.organizationId,
-        deletedAt: null,
-        suspendedAt: null,
-      },
-      select: {
-        id: true,
-        accountHandle: true,
-        targetType: true,
-        appInstallationId: true,
-        repositories: {
           select: {
             id: true,
-            name: true,
-            fullName: true,
-            htmlUrl: true,
-            private: true,
+            accountHandle: true,
+            targetType: true,
+            appInstallationId: true,
+            repositories: {
+              select: {
+                id: true,
+                name: true,
+                fullName: true,
+                htmlUrl: true,
+                private: true,
+              },
+              // Most installations will only have a couple of repos so loading them here should be fine.
+              // However, there might be outlier organizations so it's best to expose the installation repos
+              // via a resource endpoint and filter on user input.
+              take: 200,
+            },
           },
-          // Most installations will only have a couple of repos so loading them here should be fine.
-          // However, there might be outlier organizations so it's best to expose the installation repos
-          // via a resource endpoint and filter on user input.
-          take: 200,
-        },
-      },
-      take: 20,
-      orderBy: {
-        createdAt: "desc",
-      },
-    });
+          take: 20,
+          orderBy: {
+            createdAt: "desc",
+          },
+        }),
+        (error) => ({
+          type: "other" as const,
+          cause: error,
+        })
+      );
+
+    return getProject().andThen((project) =>
+      findConnectedGithubRepository(project.id).andThen((connectedGithubRepository) => {
+        if (connectedGithubRepository) {
+          return okAsync({
+            gitHubApp: {
+              enabled: true,
+              connectedRepository: connectedGithubRepository,
+              // skip loading installations if there is a connected repository
+              // a project can have only a single connected repository
+              installations: undefined,
+            },
+          });
+        }
 
-    return {
-      gitHubApp: {
-        enabled: true,
-        connectedRepository: undefined,
-        installations: githubAppInstallations,
-      },
-    };
+        return listGithubAppInstallations(project.organizationId).map((githubAppInstallations) => {
+          return {
+            gitHubApp: {
+              enabled: true,
+              connectedRepository: undefined,
+              installations: githubAppInstallations,
+            },
+          };
+        });
+      })
+    );
   }
 }
diff --git a/apps/webapp/package.json b/apps/webapp/package.json
@@ -159,6 +159,7 @@
     "match-sorter": "^6.3.4",
     "morgan": "^1.10.0",
     "nanoid": "3.3.8",
+    "neverthrow": "^8.2.0",
     "non.geist": "^1.0.2",
     "octokit": "^3.2.1",
     "ohash": "^1.1.3",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
