some fixes and tests

Author: carderne

apps/webapp/app/presenters/OrganizationsPresenter.server.ts

@@ -4,16 +4,12 @@ import { prisma } from "~/db.server";
 import { logger } from "~/services/logger.server";
 import { type UserFromSession } from "~/services/session.server";
 import { newOrganizationPath, newProjectPath } from "~/utils/pathBuilder";
-import {
-  SelectBestEnvironmentPresenter,
-  type MinimumEnvironment,
-} from "./SelectBestEnvironmentPresenter.server";
+import { SelectBestEnvironmentPresenter } from "./SelectBestEnvironmentPresenter.server";
 import { sortEnvironments } from "~/utils/environmentSort";
 import { defaultAvatar, parseAvatar } from "~/components/primitives/Avatar";
 import { env } from "~/env.server";
 import { flags } from "~/v3/featureFlags.server";
 import { validatePartialFeatureFlags } from "~/v3/featureFlags";
-import { devPresence } from "./v3/DevPresence.server";
 import { hydrateEnvsWithActivity } from "./v3/BranchesPresenter.server";
 
 export class OrganizationsPresenter {
@@ -85,6 +81,7 @@ export class OrganizationsPresenter {
             branchName: true,
             parentEnvironmentId: true,
             archivedAt: true,
+            updatedAt: true,
             orgMember: {
               select: {
                 userId: true,
@@ -104,8 +101,6 @@ export class OrganizationsPresenter {
       throw redirect(newProjectPath(organization));
     }
 
-    const recentDevBranchIds = await devPresence.getRecentBranchIds(user.id, fullProject.id);
-
     const environments = fullProject.
       environments.filter((env) => env.type !== "DEVELOPMENT" || env.orgMember?.userId === user.id);
 

apps/webapp/app/presenters/v3/BranchesPresenter.server.ts

@@ -1,4 +1,4 @@
-import { GitMeta, } from "@trigger.dev/core/v3";
+import { GitMeta } from "@trigger.dev/core/v3";
 import { DEFAULT_DEV_BRANCH } from "@trigger.dev/core/v3/utils/gitBranch";
 import { type RuntimeEnvironmentType } from "@trigger.dev/database";
 import { type z } from "zod";
@@ -10,13 +10,46 @@ import { getCurrentPlan, getPlans } from "~/services/platform.v3.server";
 import { checkBranchLimit } from "~/services/upsertBranch.server";
 import { devPresence } from "./DevPresence.server";
 import { sortEnvironments } from "~/utils/environmentSort";
-import { toBranchableEnvironmentType } from "~/utils/branchableEnvironment";
+import {
+  type BranchableEnvironmentType,
+  toBranchableEnvironmentType,
+} from "~/utils/branchableEnvironment";
 
 type Result = Awaited<ReturnType<BranchesPresenter["call"]>>;
 export type Branch = Result["branches"][number];
 
 const BRANCHES_PER_PAGE = 25;
 
+/**
+ * Prisma `where` fragment that scopes the branches list by branch name, keyed by
+ * environment type. Spread it into the query's `where` (it contributes either a
+ * `branchName` constraint or a top-level `OR`).
+ *
+ * The default DEV branch is the root dev env, stored with `branchName: null`, so
+ * for DEVELOPMENT we always include the null-branchName root (and still match it
+ * when searching — hence the top-level `OR`, since a scalar field filter can't
+ * express "matches search OR is null"). PREVIEW only ever lists real branches, so
+ * its root (null) is excluded. Passing no `search` yields the "all branches of
+ * this type" fragment.
+ */
+function branchNameFilter(
+  envType: BranchableEnvironmentType,
+  search?: string
+): Prisma.RuntimeEnvironmentWhereInput {
+  switch (envType) {
+    case "DEVELOPMENT":
+      return search
+        ? { OR: [{ branchName: { contains: search, mode: "insensitive" } }, { branchName: null }] }
+        : {};
+    case "PREVIEW":
+      return search
+        ? { branchName: { contains: search, mode: "insensitive" } }
+        : { branchName: { not: null } };
+    default:
+      throw new Error(`branchNameFilter: unsupported environment type "${envType}"`);
+  }
+}
+
 type Options = z.infer<typeof BranchesOptions>;
 
 export type GitMetaLinks = {
@@ -133,30 +166,26 @@ export class BranchesPresenter {
       };
     }
 
-    // The default DEV branch has no branchName (it's the root dev env, stored
-    // with branchName: null), so searching for it by name wouldn't display it.
-    // Hacky way around that: always include the null-branchName root env.
-    const branchNameWhere = envType === "DEVELOPMENT" ?
-      search
-        ? { OR: [{ contains: search, mode: "insensitive" as const }, { is: null }] }
-        : {} :
-      search
-        ? { contains: search, mode: "insensitive" as const }
-        : { not: null };
+    const branchNameWhere = branchNameFilter(envType, search);
     const orgMemberWhere = envType === "DEVELOPMENT" ? { orgMember: { userId } } : {};
 
-
     const visibleCount = await this.#prismaClient.runtimeEnvironment.count({
       where: {
         projectId: project.id,
         type: envType,
-        branchName: branchNameWhere,
+        ...branchNameWhere,
         ...orgMemberWhere,
         ...(showArchived ? {} : { archivedAt: null }),
       },
     });
 
-    const limits = await checkBranchLimit({ prisma: this.#prismaClient, organizationId: project.organizationId, projectId: project.id, userId, type: envType });
+    const limits = await checkBranchLimit({
+      prisma: this.#prismaClient,
+      organizationId: project.organizationId,
+      projectId: project.id,
+      userId,
+      type: envType,
+    });
 
     const [currentPlan, plans] = await Promise.all([
       getCurrentPlan(project.organizationId),
@@ -179,12 +208,13 @@ export class BranchesPresenter {
         type: true,
         archivedAt: true,
         createdAt: true,
+        updatedAt: true,
         git: true,
       },
       where: {
         projectId: project.id,
         type: envType,
-        branchName: branchNameWhere,
+        ...branchNameWhere,
         ...orgMemberWhere,
         ...(showArchived ? {} : { archivedAt: null }),
       },
@@ -195,17 +225,15 @@ export class BranchesPresenter {
       take: BRANCHES_PER_PAGE,
     });
 
-    const totalBranchesWhere = envType === "DEVELOPMENT" ? {} : { not: null };
     const totalBranches = await this.#prismaClient.runtimeEnvironment.count({
       where: {
         projectId: project.id,
         type: envType,
-        branchName: totalBranchesWhere,
+        ...branchNameFilter(envType),
         ...orgMemberWhere,
       },
     });
 
-
     const branchesFiltered = branches
       .filter((branch) => envType === "DEVELOPMENT" || branch.branchName !== null)
       .map((branch) => ({
@@ -234,8 +262,13 @@ export class BranchesPresenter {
   }
 }
 
-export async function hydrateEnvsWithActivity<T extends { type: RuntimeEnvironmentType; id: string }>
-  (userId: string, projectId: string, environments: T[]): Promise<Array<T & { lastActivity: Date | undefined; isConnected: boolean | undefined }>> {
+export async function hydrateEnvsWithActivity<
+  T extends { type: RuntimeEnvironmentType; id: string }
+>(
+  userId: string,
+  projectId: string,
+  environments: T[]
+): Promise<Array<T & { lastActivity: Date | undefined; isConnected: boolean | undefined }>> {
   const recentDevBranchIds = await devPresence.getRecentBranchIds(userId, projectId);
 
   // Resolve presence for all recently-active dev branches in a single MGET

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

@@ -63,12 +63,7 @@ import { logger } from "~/services/logger.server";
 import { requireUserId } from "~/services/session.server";
 import { UpsertBranchService } from "~/services/upsertBranch.server";
 import { cn } from "~/utils/cn";
-import {
-  branchesDevPath,
-  branchesPath,
-  docsPath,
-  ProjectParamSchema,
-} from "~/utils/pathBuilder";
+import { branchesDevPath, docsPath, ProjectParamSchema } from "~/utils/pathBuilder";
 import { ArchiveButton } from "../resources.branches.archive";
 import { IconArrowBearRight2 } from "@tabler/icons-react";
 
@@ -110,7 +105,7 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
 
     return typedjson(result);
   } catch (error) {
-    logger.error("Error loading preview branches page", { error });
+    logger.error("Error loading dev branches page", { error });
     throw new Response(undefined, {
       status: 400,
       statusText: "Something went wrong, if this problem persists please contact support.",
@@ -146,7 +141,7 @@ export async function action({ request }: ActionFunctionArgs) {
     }
 
     return redirectWithSuccessMessage(
-      `${branchesPath(result.organization, result.project, result.branch)}?dialogClosed=true`,
+      `${branchesDevPath(result.organization, result.project, result.branch)}?dialogClosed=true`,
       request,
       `Branch "${result.branch.branchName}" created`
     );

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

@@ -320,26 +320,26 @@ function getApiKeyResult(apiKey: string): {
   const type = isPublicApiKey(apiKey)
     ? "PUBLIC"
     : isSecretApiKey(apiKey)
-      ? "PRIVATE"
-      : isPublicJWT(apiKey)
-        ? "PUBLIC_JWT"
-        : "PRIVATE"; // Fallback to private key
+    ? "PRIVATE"
+    : isPublicJWT(apiKey)
+    ? "PUBLIC_JWT"
+    : "PRIVATE"; // Fallback to private key
   return { apiKey, type };
 }
 
 export type AuthenticationResult =
   | {
-    type: "personalAccessToken";
-    result: PersonalAccessTokenAuthenticationResult;
-  }
+      type: "personalAccessToken";
+      result: PersonalAccessTokenAuthenticationResult;
+    }
   | {
-    type: "organizationAccessToken";
-    result: OrganizationAccessTokenAuthenticationResult;
-  }
+      type: "organizationAccessToken";
+      result: OrganizationAccessTokenAuthenticationResult;
+    }
   | {
-    type: "apiKey";
-    result: ApiAuthenticationResult;
-  };
+      type: "apiKey";
+      result: ApiAuthenticationResult;
+    };
 
 type AuthenticationMethod = "personalAccessToken" | "organizationAccessToken" | "apiKey";
 
@@ -356,11 +356,11 @@ type FilteredAuthenticationResult<
   T extends AllowedAuthenticationMethods = AllowedAuthenticationMethods
 > =
   | (T["personalAccessToken"] extends true
-    ? Extract<AuthenticationResult, { type: "personalAccessToken" }>
-    : never)
+      ? Extract<AuthenticationResult, { type: "personalAccessToken" }>
+      : never)
   | (T["organizationAccessToken"] extends true
-    ? Extract<AuthenticationResult, { type: "organizationAccessToken" }>
-    : never)
+      ? Extract<AuthenticationResult, { type: "organizationAccessToken" }>
+      : never)
   | (T["apiKey"] extends true ? Extract<AuthenticationResult, { type: "apiKey" }> : never);
 
 /**
@@ -523,10 +523,10 @@ export async function authenticatedEnvironmentForAuthentication(
             slug: slug,
             ...(slug === "dev"
               ? {
-                orgMember: {
-                  userId: user.id,
-                },
-              }
+                  orgMember: {
+                    userId: user.id,
+                  },
+                }
               : {}),
           },
           include: authIncludeBase,

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

@@ -15,7 +15,6 @@ import { type z } from "zod";
 import invariant from "tiny-invariant";
 import { type CreateBranchOptions } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route";
 
-
 type CreateBranchOptions = z.infer<typeof CreateBranchOptions>;
 
 export class UpsertBranchService {
@@ -35,8 +34,6 @@ export class UpsertBranchService {
       | { type: "orgId"; organizationId: string },
     { projectId, env, branchName, git }: CreateBranchOptions
   ) {
-
-
     const parentEnvType = toBranchableEnvironmentType(env);
     // Dev branch creation is always user-scoped (org tokens are rejected upstream),
     // so we can disambiguate the per-member dev root by userId.
@@ -67,12 +64,12 @@ export class UpsertBranchService {
           organization:
             orgFilter.type === "userMembership"
               ? {
-                members: {
-                  some: {
-                    userId: orgFilter.userId,
+                  members: {
+                    some: {
+                      userId: orgFilter.userId,
+                    },
                   },
-                },
-              }
+                }
               : { id: orgFilter.organizationId },
         },
         include: {
@@ -94,7 +91,6 @@ export class UpsertBranchService {
 
       // Dev environments are scoped per org member, so a dev branch must inherit
       // its parent's orgMemberId. Preview parents have no orgMember (orgMemberId is null).
-
       if (!parentEnvironment) {
         invariant(env === "preview", "No default dev runtime environment setup");
         return {
@@ -110,15 +106,25 @@ export class UpsertBranchService {
         };
       }
 
-
-
-      const limits = await checkBranchLimit(
-        { prisma: this.#prismaClient, organizationId: parentEnvironment.organization.id, projectId: parentEnvironment.project.id, type: parentEnvType, userId, newBranchName: sanitizedBranchName });
+      const limits = await checkBranchLimit({
+        prisma: this.#prismaClient,
+        organizationId: parentEnvironment.organization.id,
+        projectId: parentEnvironment.project.id,
+        type: parentEnvType,
+        userId,
+        newBranchName: sanitizedBranchName,
+      });
 
       if (limits.isAtLimit) {
+        // DEVELOPMENT has no upgrade path, so only PREVIEW mentions upgrading.
+        const remediation =
+          parentEnvType === "PREVIEW"
+            ? "Use the CLI to view your existing branches and archive any you no longer need, or upgrade to get more."
+            : "Use the CLI to view your existing branches and archive any you no longer need.";
+
         return {
           success: false as const,
-          error: `You've used all ${limits.used} of ${limits.limit} branches for your plan. Upgrade to get more branches or archive some.`,
+          error: `You've used all ${limits.used} of ${limits.limit} branches for your plan. ${remediation}`,
         };
       }
 
@@ -128,7 +134,6 @@ export class UpsertBranchService {
       const shortcode = branchSlug;
 
       const now = new Date();
-
       const branch = await this.#prismaClient.runtimeEnvironment.upsert({
         where: {
           projectId_shortcode: {
@@ -184,10 +189,21 @@ export class UpsertBranchService {
   }
 }
 
-export async function checkBranchLimit(
-  { prisma, organizationId, projectId, userId, type, newBranchName }:
-    { prisma: PrismaClientOrTransaction; organizationId: string; projectId: string; userId?: string; type: BranchableEnvironmentType; newBranchName?: string; }) {
-
+export async function checkBranchLimit({
+  prisma,
+  organizationId,
+  projectId,
+  userId,
+  type,
+  newBranchName,
+}: {
+  prisma: PrismaClientOrTransaction;
+  organizationId: string;
+  projectId: string;
+  userId?: string;
+  type: BranchableEnvironmentType;
+  newBranchName?: string;
+}) {
   let orgMemberWhere = {};
   if (type === "DEVELOPMENT") {
     invariant(userId, "Cannot use org access for dev server");