convex 1.34.0 → 1.35.0

package/src/cli/deploymentCreate.test.ts

@@ -11,9 +11,20 @@ import { PlatformProjectDetails } from "@convex-dev/platform/managementApi";
 import {
   getDeploymentSelection,
   getProjectDetails,
+  deploymentNameFromSelection,
 } from "./lib/deploymentSelection.js";
-import { selectDeployment } from "./deploymentSelect.js";
+import { saveSelectedDeployment } from "./deploymentSelect.js";
 import { deploymentCreate, resolveRegionDetails } from "./deploymentCreate.js";
+import { ensureBackendBinaryDownloaded } from "./lib/localDeployment/download.js";
+import {
+  loadProjectLocalConfig,
+  saveDeploymentConfig,
+} from "./lib/localDeployment/filePaths.js";
+import {
+  chooseLocalBackendPorts,
+  LOCAL_BACKEND_INSTANCE_SECRET,
+} from "./lib/localDeployment/utils.js";
+import { bigBrainStart } from "./lib/localDeployment/bigBrain.js";
 
 vi.mock("@sentry/node", () => ({
   captureException: vi.fn(),
@@ -31,10 +42,29 @@ vi.mock("./lib/deploymentSelection.js", () => ({
   initializeBigBrainAuth: vi.fn(),
   getDeploymentSelection: vi.fn(),
   getProjectDetails: vi.fn(),
+  deploymentNameFromSelection: vi.fn().mockReturnValue(null),
 }));
 
 vi.mock("./deploymentSelect.js", () => ({
-  selectDeployment: vi.fn(),
+  saveSelectedDeployment: vi.fn(),
+}));
+
+vi.mock("./lib/localDeployment/download.js", () => ({
+  ensureBackendBinaryDownloaded: vi.fn(),
+}));
+
+vi.mock("./lib/localDeployment/filePaths.js", () => ({
+  loadProjectLocalConfig: vi.fn(),
+  saveDeploymentConfig: vi.fn(),
+}));
+
+vi.mock("./lib/localDeployment/utils.js", () => ({
+  chooseLocalBackendPorts: vi.fn(),
+  LOCAL_BACKEND_INSTANCE_SECRET: "MockSecret123",
+}));
+
+vi.mock("./lib/localDeployment/bigBrain.js", () => ({
+  bigBrainStart: vi.fn(),
 }));
 
 const mockRegions = [
@@ -107,7 +137,9 @@ describe("non-interactive create flow", () => {
   beforeEach(() => {
     vi.mocked(getDeploymentSelection).mockReset();
     vi.mocked(getProjectDetails).mockReset();
-    vi.mocked(selectDeployment).mockReset();
+    vi.mocked(saveSelectedDeployment).mockReset();
+    vi.mocked(deploymentNameFromSelection).mockReset();
+    vi.mocked(deploymentNameFromSelection).mockReturnValue(null);
   });
 
   describe("validation errors", () => {
@@ -128,6 +160,165 @@ describe("non-interactive create flow", () => {
         expect.stringContaining("--type is required"),
       );
     });
+
+    test("creates a local deployment: downloads binary, chooses ports, registers with Big Brain, saves config", async () => {
+      vi.mocked(getDeploymentSelection).mockResolvedValue({
+        kind: "existingDeployment",
+        deploymentToActOn: {
+          url: "https://joyful-capybara-123.convex.cloud",
+          adminKey: "admin-key",
+          deploymentFields: {
+            deploymentName: "joyful-capybara-123",
+            deploymentType: "dev",
+            teamSlug: "my-team",
+            projectSlug: "my-project",
+          },
+          source: "deployKey" as const,
+        },
+      });
+      vi.mocked(getProjectDetails).mockResolvedValue(fakeProject);
+      vi.mocked(loadProjectLocalConfig).mockReturnValue(null);
+      vi.mocked(ensureBackendBinaryDownloaded).mockResolvedValue({
+        binaryPath: "/path",
+        version: "1.0.0",
+      });
+      vi.mocked(chooseLocalBackendPorts).mockResolvedValue({
+        cloudPort: 3210,
+        sitePort: 3211,
+      });
+      vi.mocked(bigBrainStart).mockResolvedValue({
+        deploymentName: "local-test-123",
+        adminKey: "test-key",
+      });
+
+      await deploymentCreate.parseAsync(["local"], { from: "user" });
+
+      expect(saveDeploymentConfig).toHaveBeenCalledWith(
+        expect.anything(),
+        "local",
+        "local-test-123",
+        {
+          backendVersion: "1.0.0",
+          ports: { cloud: 3210, site: 3211 },
+          adminKey: "test-key",
+          instanceSecret: LOCAL_BACKEND_INSTANCE_SECRET,
+        },
+      );
+      expect(mockPlatformPost).not.toHaveBeenCalled();
+    });
+
+    test("creates a local deployment with --select and selects it", async () => {
+      vi.mocked(getDeploymentSelection).mockResolvedValue({
+        kind: "existingDeployment",
+        deploymentToActOn: {
+          url: "https://joyful-capybara-123.convex.cloud",
+          adminKey: "admin-key",
+          deploymentFields: {
+            deploymentName: "joyful-capybara-123",
+            deploymentType: "dev",
+            teamSlug: "my-team",
+            projectSlug: "my-project",
+          },
+          source: "deployKey" as const,
+        },
+      });
+      vi.mocked(getProjectDetails).mockResolvedValue(fakeProject);
+      vi.mocked(loadProjectLocalConfig).mockReturnValue(null);
+      vi.mocked(ensureBackendBinaryDownloaded).mockResolvedValue({
+        binaryPath: "/path",
+        version: "1.0.0",
+      });
+      vi.mocked(chooseLocalBackendPorts).mockResolvedValue({
+        cloudPort: 3210,
+        sitePort: 3211,
+      });
+      vi.mocked(bigBrainStart).mockResolvedValue({
+        deploymentName: "local-test-123",
+        adminKey: "test-key",
+      });
+
+      await deploymentCreate.parseAsync(["local", "--select"], {
+        from: "user",
+      });
+
+      expect(saveSelectedDeployment).toHaveBeenCalledWith(
+        expect.anything(),
+        "local",
+        {
+          kind: "deploymentWithinProject",
+          targetProject: {
+            kind: "deploymentName",
+            deploymentName: "local-test-123",
+            deploymentType: "local",
+          },
+          selectionWithinProject: {
+            kind: "deploymentSelector",
+            selector: "local",
+          },
+        },
+        null,
+      );
+    });
+
+    test("crashes when creating a local deployment with --type", async () => {
+      await expect(
+        deploymentCreate.parseAsync(["local", "--type", "dev"], {
+          from: "user",
+        }),
+      ).rejects.toThrow();
+      expect(process.stderr.write).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "--type cannot be used when creating a local deployment",
+        ),
+      );
+      expect(mockPlatformPost).not.toHaveBeenCalled();
+    });
+
+    test("errors when local deployment already exists", async () => {
+      vi.mocked(getDeploymentSelection).mockResolvedValue({
+        kind: "existingDeployment",
+        deploymentToActOn: {
+          url: "https://joyful-capybara-123.convex.cloud",
+          adminKey: "admin-key",
+          deploymentFields: {
+            deploymentName: "joyful-capybara-123",
+            deploymentType: "dev",
+            teamSlug: "my-team",
+            projectSlug: "my-project",
+          },
+          source: "deployKey" as const,
+        },
+      });
+      vi.mocked(loadProjectLocalConfig).mockReturnValue({
+        deploymentName: "existing-local-123",
+        config: {} as any,
+      });
+
+      await expect(
+        deploymentCreate.parseAsync(["local"], { from: "user" }),
+      ).rejects.toThrow();
+      expect(process.stderr.write).toHaveBeenCalledWith(
+        expect.stringContaining("A local deployment already exists"),
+      );
+    });
+
+    test.each(["region", "default", "expiration"] as const)(
+      "rejects --%s with local",
+      async (flag) => {
+        const args = ["local", `--${flag}`];
+        if (flag === "region") args.push("us");
+        if (flag === "expiration") args.push("none");
+
+        await expect(
+          deploymentCreate.parseAsync(args, { from: "user" }),
+        ).rejects.toThrow();
+        expect(process.stderr.write).toHaveBeenCalledWith(
+          expect.stringContaining(
+            `--${flag} cannot be used when creating a local deployment`,
+          ),
+        );
+      },
+    );
   });
 
   describe("with project configured", () => {
@@ -285,7 +476,7 @@ describe("non-interactive create flow", () => {
       );
     });
 
-    test("creates a deployment with --select calls selectDeployment", async () => {
+    test("creates a deployment with --select calls saveSelectedDeployment", async () => {
       setupPlatformForCreate({
         reference: "dev/my-deployment",
       });
@@ -295,9 +486,22 @@ describe("non-interactive create flow", () => {
         { from: "user" },
       );
 
-      expect(selectDeployment).toHaveBeenCalledWith(
+      expect(saveSelectedDeployment).toHaveBeenCalledWith(
         expect.anything(),
         "dev/my-deployment",
+        {
+          kind: "deploymentWithinProject",
+          targetProject: {
+            kind: "teamAndProjectSlugs",
+            teamSlug: "my-team",
+            projectSlug: "my-project",
+          },
+          selectionWithinProject: {
+            kind: "deploymentSelector",
+            selector: "dev/my-deployment",
+          },
+        },
+        null,
       );
     });
   });
@@ -321,7 +525,6 @@ describe("non-interactive create flow", () => {
         teamSlug: "other-team",
         projectSlug: "other-project",
       });
-      expect(getDeploymentSelection).not.toHaveBeenCalled();
       expect(mockPlatformPost).toHaveBeenCalledWith(
         "/projects/{project_id}/create_deployment",
         expect.objectContaining({
@@ -333,6 +536,83 @@ describe("non-interactive create flow", () => {
     });
   });
 
+  describe("--expiration flag", () => {
+    beforeEach(() => {
+      vi.mocked(getDeploymentSelection).mockResolvedValue({
+        kind: "existingDeployment",
+        deploymentToActOn: {
+          url: "https://joyful-capybara-123.convex.cloud",
+          adminKey: "admin-key",
+          deploymentFields: {
+            deploymentName: "joyful-capybara-123",
+            deploymentType: "dev",
+            teamSlug: "my-team",
+            projectSlug: "my-project",
+          },
+          source: "deployKey" as const,
+        },
+      });
+      vi.mocked(getProjectDetails).mockResolvedValue(fakeProject);
+    });
+
+    test("--expiration none sends expiresAt: null", async () => {
+      setupPlatformForCreate();
+
+      await deploymentCreate.parseAsync(
+        ["my-deployment", "--type", "dev", "--expiration", "none"],
+        { from: "user" },
+      );
+
+      expect(mockPlatformPost).toHaveBeenCalledWith(
+        "/projects/{project_id}/create_deployment",
+        expect.objectContaining({
+          body: expect.objectContaining({
+            expiresAt: null,
+          }),
+        }),
+      );
+    });
+
+    test("--expiration with timestamp sends correct ms value", async () => {
+      setupPlatformForCreate();
+
+      // Use a timestamp far enough in the future to pass validation
+      const futureMs = Date.now() + 2 * 60 * 60 * 1000; // 2 hours from now
+      const futureSec = Math.floor(futureMs / 1000);
+
+      await deploymentCreate.parseAsync(
+        [
+          "my-deployment",
+          "--type",
+          "dev",
+          "--expiration",
+          futureSec.toString(),
+        ],
+        { from: "user" },
+      );
+
+      expect(mockPlatformPost).toHaveBeenCalledWith(
+        "/projects/{project_id}/create_deployment",
+        expect.objectContaining({
+          body: expect.objectContaining({
+            expiresAt: futureSec * 1000,
+          }),
+        }),
+      );
+    });
+
+    test("no --expiration flag does not include expiresAt in body", async () => {
+      setupPlatformForCreate();
+
+      await deploymentCreate.parseAsync(["my-deployment", "--type", "dev"], {
+        from: "user",
+      });
+
+      const call = mockPlatformPost.mock.calls[0];
+      expect(call[1].body).not.toHaveProperty("expiresAt");
+    });
+  });
+
   describe("without project configured", () => {
     beforeEach(() => {
       vi.mocked(getDeploymentSelection).mockResolvedValue({
@@ -367,6 +647,22 @@ describe("non-interactive create flow", () => {
       });
       expect(mockPlatformPost).toHaveBeenCalled();
     });
+
+    test("hint includes full team:project:ref when no project configured in current directory", async () => {
+      vi.mocked(getProjectDetails).mockResolvedValue(fakeProject);
+      setupPlatformForCreate();
+
+      await deploymentCreate.parseAsync(
+        ["my-team:my-project:my-deployment", "--type", "dev"],
+        { from: "user" },
+      );
+
+      expect(process.stderr.write).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "npx convex deployment select my-team:my-project:dev/my-deployment",
+        ),
+      );
+    });
   });
 });
 
@@ -375,8 +671,10 @@ describe("interactive create flow", () => {
     process.stdin.isTTY = true;
     vi.mocked(getDeploymentSelection).mockReset();
     vi.mocked(getProjectDetails).mockReset();
-    vi.mocked(selectDeployment).mockReset();
+    vi.mocked(saveSelectedDeployment).mockReset();
     vi.mocked(selectRegion).mockReset();
+    vi.mocked(deploymentNameFromSelection).mockReset();
+    vi.mocked(deploymentNameFromSelection).mockReturnValue(null);
 
     // Default: project configured via deployment selection
     vi.mocked(getDeploymentSelection).mockResolvedValue({
@@ -447,7 +745,7 @@ describe("interactive create flow", () => {
 
       // Ref prompt (input)
       await screen.next();
-      expect(screen.getScreen()).toContain("Deployment ref?");
+      expect(screen.getScreen()).toContain("How to name this deployment?");
       screen.type("my-feature");
       screen.keypress("enter");
 
@@ -476,7 +774,7 @@ describe("interactive create flow", () => {
 
     // Ref prompt (input)
     await screen.next();
-    expect(screen.getScreen()).toContain("Deployment ref?");
+    expect(screen.getScreen()).toContain("How to name this deployment?");
     screen.type("my-feature");
     screen.keypress("enter");
 
@@ -526,14 +824,16 @@ describe("interactive create flow", () => {
 
     // Ref prompt — enter invalid ref "dev"
     await screen.next();
-    expect(screen.getScreen()).toContain("Deployment ref?");
+    expect(screen.getScreen()).toContain("How to name this deployment?");
     screen.type("dev");
     screen.keypress("enter");
 
-    // Re-prompted for ref after error
+    // Inline validation error, then edit input
     await screen.next();
-    expect(screen.getScreen()).toContain("Deployment ref?");
-    screen.type("my-feature");
+    expect(screen.getScreen()).toContain(
+      '"dev" is not a valid deployment reference.',
+    );
+    screen.type("/my-feature");
     screen.keypress("enter");
 
     await promise;
@@ -542,13 +842,48 @@ describe("interactive create flow", () => {
       "/projects/{project_id}/create_deployment",
       expect.objectContaining({
         body: expect.objectContaining({
-          reference: "my-feature",
+          reference: "dev/my-feature",
           isDefault: null,
         }),
       }),
     );
   });
 
+  test("interactive ref prompt rejects 'local' as a deployment reference", async () => {
+    setupDefaultRoutes();
+
+    const promise = deploymentCreate.parseAsync(["--type", "dev"], {
+      from: "user",
+    });
+
+    // Ref prompt — enter "local"
+    await screen.next();
+    expect(screen.getScreen()).toContain("How to name this deployment?");
+    screen.type("local");
+    screen.keypress("enter");
+
+    // Inline validation error
+    await screen.next();
+    expect(screen.getScreen()).toContain(
+      '"local" is not a valid deployment reference',
+    );
+
+    // Fix the input
+    screen.type("ization-improvements");
+    screen.keypress("enter");
+
+    await promise;
+
+    expect(mockPlatformPost).toHaveBeenCalledWith(
+      "/projects/{project_id}/create_deployment",
+      expect.objectContaining({
+        body: expect.objectContaining({
+          reference: "localization-improvements",
+        }),
+      }),
+    );
+  });
+
   test("--region invalid crashes", async () => {
     setupDefaultRoutes();