wip3

Author: carderne

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

@@ -135,7 +135,7 @@ export class BranchesPresenter {
     });
 
     // Limits
-    const limits = await checkBranchLimit(this.#prismaClient, project.organizationId, project.id);
+    const limits = await checkBranchLimit({ prisma: this.#prismaClient, organizationId: project.organizationId, projectId: project.id });
 
     const [currentPlan, plans] = await Promise.all([
       getCurrentPlan(project.organizationId),

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

@@ -67,7 +67,7 @@ import { BranchesPresenter } from "~/presenters/v3/BranchesPresenter.server";
 import { logger } from "~/services/logger.server";
 import { getCurrentPlan, getSelfServePurchaseBlockReason } from "~/services/platform.v3.server";
 import { requireUserId } from "~/services/session.server";
-import { UpsertBranchService } from "~/services/upsertBranch.server";
+import { UpsertBranchService, CreateBranchOptions } from "~/services/upsertBranch.server";
 import { cn } from "~/utils/cn";
 import {
   branchesPath,
@@ -114,14 +114,6 @@ export const loader = async ({ request, params }: LoaderFunctionArgs) => {
   }
 };
 
-export const CreateBranchOptions = z.object({
-  parentEnvironmentId: z.string(),
-  branchName: z.string().min(1),
-  git: GitMeta.optional(),
-});
-
-export type CreateBranchOptions = z.infer<typeof CreateBranchOptions>;
-
 export const schema = CreateBranchOptions.and(
   z.object({
     failurePath: z.string(),

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

@@ -1,5 +1,6 @@
 import { json, type LoaderFunctionArgs, type ActionFunctionArgs } from "@remix-run/server-runtime";
 import { tryCatch, UpsertBranchRequestBody } from "@trigger.dev/core/v3";
+import invariant from "tiny-invariant";
 import { z } from "zod";
 import { prisma } from "~/db.server";
 import { authenticateRequest } from "~/services/apiAuth.server";
@@ -47,12 +48,12 @@ export async function action({ request, params }: ActionFunctionArgs) {
         authenticationResult.type === "organizationAccessToken"
           ? { id: authenticationResult.result.organizationId }
           : {
-              members: {
-                some: {
-                  userId: authenticationResult.result.userId,
-                },
+            members: {
+              some: {
+                userId: authenticationResult.result.userId,
               },
             },
+          },
     },
   });
   if (!project) {
@@ -69,33 +70,31 @@ export async function action({ request, params }: ActionFunctionArgs) {
     return json({ error: parsed.error.message }, { status: 400 });
   }
 
-  const previewEnvironment = await prisma.runtimeEnvironment.findFirst({
-    select: {
-      id: true,
-    },
-    where: {
-      projectId: project.id,
-      slug: "preview",
-    },
-  });
+  const { branch, env, git } = parsed.data;
 
-  if (!previewEnvironment) {
+  if (env === "development" && authenticationResult.type === "organizationAccessToken") {
     return json(
-      { error: "You don't have preview branches setup. Go to the dashboard to enable them." },
+      { error: "Cannot create dev branches with organization access tokens." },
       { status: 400 }
     );
   }
 
-  const { branch, env, git } = parsed.data;
+  if (env === "development" && branch === "default") {
+    return json(
+      { error: "Cannot create dev branch with name 'default'." },
+      { status: 400 }
+    );
+  }
 
   const service = new UpsertBranchService();
   const result = await service.call(
     authenticationResult.type === "organizationAccessToken"
       ? { type: "orgId", organizationId: authenticationResult.result.organizationId }
       : { type: "userMembership", userId: authenticationResult.result.userId },
     {
+      env,
       branchName: branch,
-      parentEnvironmentId: previewEnvironment.id,
+      projectId: project.id,
       git,
     }
   );

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

@@ -2,10 +2,21 @@ import { type PrismaClient, type PrismaClientOrTransaction } from "@trigger.dev/
 import slug from "slug";
 import { prisma } from "~/db.server";
 import { createApiKeyForEnv, createPkApiKeyForEnv } from "~/models/api-key.server";
-import { type CreateBranchOptions } from "~/routes/_app.orgs.$organizationSlug.projects.$projectParam.env.$envParam.branches/route";
 import { isValidGitBranchName, sanitizeBranchName } from "@trigger.dev/core/v3/utils/gitBranch";
 import { logger } from "./logger.server";
 import { getCurrentPlan, getLimit } from "./platform.v3.server";
+import { GitMeta } from "@trigger.dev/core/v3";
+import { z } from "zod";
+import invariant from "tiny-invariant";
+
+export const CreateBranchOptions = z.object({
+  projectId: z.string(),
+  env: z.enum(["preview", "development"]),
+  branchName: z.string().min(1),
+  git: GitMeta.optional(),
+});
+
+type CreateBranchOptions = z.infer<typeof CreateBranchOptions>;
 
 export class UpsertBranchService {
   #prismaClient: PrismaClient;
@@ -22,8 +33,12 @@ export class UpsertBranchService {
     orgFilter:
       | { type: "userMembership"; userId: string }
       | { type: "orgId"; organizationId: string },
-    { parentEnvironmentId, branchName, git }: CreateBranchOptions
+    { projectId, env, branchName, git }: CreateBranchOptions
   ) {
+
+
+    const parentEnvSlug = env === "preview" ? "preview" : "dev";
+
     const sanitizedBranchName = sanitizeBranchName(branchName);
     if (!sanitizedBranchName) {
       return {
@@ -42,16 +57,17 @@ export class UpsertBranchService {
     try {
       const parentEnvironment = await this.#prismaClient.runtimeEnvironment.findFirst({
         where: {
-          id: parentEnvironmentId,
+          projectId,
+          slug: parentEnvSlug,
           organization:
             orgFilter.type === "userMembership"
               ? {
-                  members: {
-                    some: {
-                      userId: orgFilter.userId,
-                    },
+                members: {
+                  some: {
+                    userId: orgFilter.userId,
                   },
-                }
+                },
+              }
               : { id: orgFilter.organizationId },
         },
         include: {
@@ -72,6 +88,7 @@ export class UpsertBranchService {
       });
 
       if (!parentEnvironment) {
+        invariant(env === "preview", "No default dev runtime environment setup");
         return {
           success: false as const,
           error: "You don't have preview branches setup. Go to the dashboard to enable them.",
@@ -81,16 +98,12 @@ export class UpsertBranchService {
       if (!parentEnvironment.isBranchableEnvironment) {
         return {
           success: false as const,
-          error: "Your preview environment is not branchable",
+          error: `Your ${env} environment is not branchable`,
         };
       }
 
       const limits = await checkBranchLimit(
-        this.#prismaClient,
-        parentEnvironment.organization.id,
-        parentEnvironment.project.id,
-        sanitizedBranchName
-      );
+        { prisma: this.#prismaClient, organizationId: parentEnvironment.organization.id, projectId: parentEnvironment.project.id, newBranchName: sanitizedBranchName });
 
       if (limits.isAtLimit) {
         return {
@@ -159,11 +172,11 @@ export class UpsertBranchService {
 }
 
 export async function checkBranchLimit(
-  prisma: PrismaClientOrTransaction,
-  organizationId: string,
-  projectId: string,
-  newBranchName?: string
-) {
+  { prisma, organizationId, projectId, env, newBranchName }:
+    { prisma: PrismaClientOrTransaction; organizationId: string; projectId: string; env: "preview" | "development"; newBranchName?: string; }) {
+
+  
+
   const usedEnvs = await prisma.runtimeEnvironment.findMany({
     where: {
       projectId,
@@ -177,7 +190,9 @@ export async function checkBranchLimit(
   const count = newBranchName
     ? usedEnvs.filter((env) => env.branchName !== newBranchName).length
     : usedEnvs.length;
-  const baseLimit = await getLimit(organizationId, "branches", 100_000_000);
+
+  const limitName = env === "preview" ? "branches" : "branchesDev";
+  const baseLimit = await getLimit(organizationId, limitName, 100_000_000);
   const currentPlan = await getCurrentPlan(organizationId);
   const purchasedBranches = currentPlan?.v3Subscription?.addOns?.branches?.purchased ?? 0;
   const limit = baseLimit + purchasedBranches;

package.json

@@ -90,6 +90,7 @@
       "@remix-run/router@1.23.2": "patches/@remix-run__router@1.23.2.patch"
     },
     "overrides": {
+      "@trigger.dev/platform": "link:../cloud/packages/platform",
       "typescript": "5.5.4",
       "@types/node": "20.14.14",
       "express@^4>body-parser": "1.20.3",

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

@@ -27,12 +27,13 @@ import { installMcpServer } from "./install-mcp.js";
 import { tryCatch } from "@trigger.dev/core/utils";
 import { VERSION } from "@trigger.dev/core";
 import { initiateSkillsInstallWizard } from "./skills.js";
+import { getDevBranch } from "@trigger.dev/core/v3";
 
 const DevCommandOptions = CommonCommandOptions.extend({
   debugOtel: z.boolean().default(false),
   config: z.string().optional(),
   projectRef: z.string().optional(),
-  branch: z.string().optional().default("branch"),
+  branch: z.string().optional(),
   skipUpdateCheck: z.boolean().default(false),
   skipPlatformNotifications: z.boolean().default(false),
   envFile: z.string().optional(),
@@ -61,7 +62,6 @@ export function configureDevCommand(program: Command) {
       .option(
         "-b, --branch <branch>",
         "The dev branch to use. If not provided, we'll use the default branch."
-        "default",
       )
       .option(
         "--env-file <env file>",
@@ -203,10 +203,12 @@ async function startDev(options: StartDevOptions) {
       logger.loggerLevel = options.logLevel;
     }
 
+    const apiClient = new CliApiClient(options.login.auth.apiUrl, options.login.auth.accessToken);
+
     const notificationPromise = options.skipPlatformNotifications
       ? undefined
       : fetchPlatformNotification({
-        apiClient: new CliApiClient(options.login.auth.apiUrl, options.login.auth.accessToken),
+        apiClient,
         projectRef: options.projectRef,
       });
 
@@ -251,6 +253,12 @@ async function startDev(options: StartDevOptions) {
 
     logger.debug("Initial config", watcher.config);
 
+    const branch = getDevBranch({ specified: options.branch });
+
+    if (branch !== "default") {
+      apiClient.upsertBranch(watcher.config.project, { branch, env: "development" });
+    }
+
     // eslint-disable-next-line no-inner-declarations
     async function bootDevSession(configParam: ResolvedConfig) {
       const projectClient = await getProjectClient({