convex 1.44.0 → 1.45.0

package/src/cli/lib/deployment.test.ts

@@ -1,85 +0,0 @@
-import { test, expect } from "vitest";
-import { changesToEnvVarFile, changesToGitIgnore } from "./deployment.js";
-
-const DEPLOYMENT = {
-  team: "snoops",
-  project: "earth",
-  deploymentName: "tall-bar",
-};
-
-test("env var changes", () => {
-  expect(changesToEnvVarFile(null, "prod", DEPLOYMENT)).toEqual(
-    "# Deployment used by `npx convex dev`\n" +
-      "CONVEX_DEPLOYMENT=prod:tall-bar # team: snoops, project: earth\n",
-  );
-
-  expect(changesToEnvVarFile("CONVEX_DEPLOYMENT=", "prod", DEPLOYMENT)).toEqual(
-    "CONVEX_DEPLOYMENT=prod:tall-bar # team: snoops, project: earth",
-  );
-
-  expect(
-    changesToEnvVarFile("CONVEX_DEPLOYMENT=foo", "prod", DEPLOYMENT),
-  ).toEqual("CONVEX_DEPLOYMENT=prod:tall-bar # team: snoops, project: earth");
-
-  expect(changesToEnvVarFile("RAD_DEPLOYMENT=foo", "prod", DEPLOYMENT)).toEqual(
-    "RAD_DEPLOYMENT=foo\n" +
-      "\n" +
-      "# Deployment used by `npx convex dev`\n" +
-      "CONVEX_DEPLOYMENT=prod:tall-bar # team: snoops, project: earth\n",
-  );
-
-  expect(
-    changesToEnvVarFile(
-      "RAD_DEPLOYMENT=foo\n" + "CONVEX_DEPLOYMENT=foo",
-      "prod",
-      DEPLOYMENT,
-    ),
-  ).toEqual(
-    "RAD_DEPLOYMENT=foo\n" +
-      "CONVEX_DEPLOYMENT=prod:tall-bar # team: snoops, project: earth",
-  );
-
-  expect(
-    changesToEnvVarFile(
-      "CONVEX_DEPLOYMENT=\n" + "RAD_DEPLOYMENT=foo",
-      "prod",
-      DEPLOYMENT,
-    ),
-  ).toEqual(
-    "CONVEX_DEPLOYMENT=prod:tall-bar # team: snoops, project: earth\n" +
-      "RAD_DEPLOYMENT=foo",
-  );
-});
-
-test("git ignore changes", () => {
-  // Handle additions
-  expect(changesToGitIgnore(null)).toEqual(".env.local\n");
-  expect(changesToGitIgnore("")).toEqual("\n.env.local\n");
-  expect(changesToGitIgnore(".env")).toEqual(".env\n.env.local\n");
-  expect(changesToGitIgnore("# .env.local")).toEqual(
-    "# .env.local\n.env.local\n",
-  );
-
-  // Handle existing
-  expect(changesToGitIgnore(".env.local")).toEqual(null);
-  expect(changesToGitIgnore(".env.*")).toEqual(null);
-  expect(changesToGitIgnore(".env*")).toEqual(null);
-
-  expect(changesToGitIgnore(".env*.local")).toEqual(null);
-  expect(changesToGitIgnore("*.local")).toEqual(null);
-  expect(changesToGitIgnore("# convex env\n.env.local")).toEqual(null);
-
-  // Handle Windows
-  expect(changesToGitIgnore(".env.local\r")).toEqual(null);
-  expect(changesToGitIgnore("foo\r\n.env.local")).toEqual(null);
-  expect(changesToGitIgnore("foo\r\n.env.local\r\n")).toEqual(null);
-  expect(changesToGitIgnore("foo\r\n.env.local\r\nbar")).toEqual(null);
-
-  // Handle trailing whitespace
-  expect(changesToGitIgnore(" .env.local ")).toEqual(null);
-
-  // Add .env.local (even if it's negated) to guide the user to solve the problem
-  expect(changesToGitIgnore("!.env.local")).toEqual(
-    "!.env.local\n.env.local\n",
-  );
-});

package/src/cli/lib/deploymentSelector.test.ts

@@ -1,107 +0,0 @@
-import { describe, test, expect } from "vitest";
-import { parseDeploymentSelector } from "./deploymentSelector.js";
-
-describe("parseDeploymentSelector", () => {
-  test('"dev"', () => {
-    expect(parseDeploymentSelector("dev")).toEqual({
-      kind: "inCurrentProject",
-      selector: { kind: "dev" },
-    });
-  });
-
-  test('"prod"', () => {
-    expect(parseDeploymentSelector("prod")).toEqual({
-      kind: "inCurrentProject",
-      selector: { kind: "prod" },
-    });
-  });
-
-  test('"local"', () => {
-    expect(parseDeploymentSelector("local")).toEqual({
-      kind: "inCurrentProject",
-      selector: { kind: "local" },
-    });
-  });
-
-  test('"myproject:local"', () => {
-    expect(parseDeploymentSelector("myproject:local")).toEqual({
-      kind: "inProject",
-      projectSlug: "myproject",
-      selector: { kind: "local" },
-    });
-  });
-
-  test('"myteam:myproject:local"', () => {
-    expect(parseDeploymentSelector("myteam:myproject:local")).toEqual({
-      kind: "inTeamProject",
-      teamSlug: "myteam",
-      projectSlug: "myproject",
-      selector: { kind: "local" },
-    });
-  });
-
-  test('"tall-forest-123"', () => {
-    expect(parseDeploymentSelector("tall-forest-123")).toEqual({
-      kind: "deploymentName",
-      deploymentName: "tall-forest-123",
-    });
-  });
-
-  test("reference", () => {
-    expect(parseDeploymentSelector("dev/vercel")).toEqual({
-      kind: "inCurrentProject",
-      selector: { kind: "reference", reference: "dev/vercel" },
-    });
-  });
-
-  test('"myproject:dev"', () => {
-    expect(parseDeploymentSelector("myproject:dev")).toEqual({
-      kind: "inProject",
-      projectSlug: "myproject",
-      selector: { kind: "dev" },
-    });
-  });
-
-  test('"myproject:prod"', () => {
-    expect(parseDeploymentSelector("myproject:prod")).toEqual({
-      kind: "inProject",
-      projectSlug: "myproject",
-      selector: { kind: "prod" },
-    });
-  });
-
-  test('"myproject:preview-name"', () => {
-    expect(parseDeploymentSelector("myproject:preview-name")).toEqual({
-      kind: "inProject",
-      projectSlug: "myproject",
-      selector: { kind: "reference", reference: "preview-name" },
-    });
-  });
-
-  test('"myteam:myproject:dev"', () => {
-    expect(parseDeploymentSelector("myteam:myproject:dev")).toEqual({
-      kind: "inTeamProject",
-      teamSlug: "myteam",
-      projectSlug: "myproject",
-      selector: { kind: "dev" },
-    });
-  });
-
-  test('"myteam:myproject:prod"', () => {
-    expect(parseDeploymentSelector("myteam:myproject:prod")).toEqual({
-      kind: "inTeamProject",
-      teamSlug: "myteam",
-      projectSlug: "myproject",
-      selector: { kind: "prod" },
-    });
-  });
-
-  test('"myteam:myproject:preview-name"', () => {
-    expect(parseDeploymentSelector("myteam:myproject:preview-name")).toEqual({
-      kind: "inTeamProject",
-      teamSlug: "myteam",
-      projectSlug: "myproject",
-      selector: { kind: "reference", reference: "preview-name" },
-    });
-  });
-});

package/src/cli/lib/env.test.ts

@@ -1,60 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import type { Context } from "../../bundler/context.js";
-import { envList, type EnvVar, type EnvVarBackend } from "./env.js";
-
-const logMocks = vi.hoisted(() => ({
-  logFailure: vi.fn(),
-  logFinishedStep: vi.fn(),
-  logMessage: vi.fn(),
-  logOutput: vi.fn(),
-}));
-
-vi.mock("../../bundler/log.js", () => ({
-  logFailure: logMocks.logFailure,
-  logFinishedStep: logMocks.logFinishedStep,
-  logMessage: logMocks.logMessage,
-  logOutput: logMocks.logOutput,
-}));
-
-function fakeBackend(envs: EnvVar[]): EnvVarBackend {
-  return {
-    get() {
-      return Promise.resolve(null);
-    },
-    list() {
-      return Promise.resolve(envs);
-    },
-    update() {
-      return Promise.reject(new Error("Unexpected update"));
-    },
-    notice: "",
-  };
-}
-
-describe("envList", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test("prints only names without values or warnings when namesOnly is true", async () => {
-    await envList(
-      {} as Context,
-      fakeBackend([
-        { name: "PLAIN", value: "plain-value" },
-        { name: "DANGEROUS", value: "secret'value#fragment" },
-      ]),
-      { namesOnly: true },
-    );
-
-    expect(logMocks.logOutput.mock.calls).toEqual([["PLAIN"], ["DANGEROUS"]]);
-    expect(logMocks.logMessage).not.toHaveBeenCalled();
-
-    const emitted = [
-      ...logMocks.logOutput.mock.calls.flat(),
-      ...logMocks.logMessage.mock.calls.flat(),
-    ].join("\n");
-    expect(emitted).not.toContain("plain-value");
-    expect(emitted).not.toContain("secret'value#fragment");
-    expect(emitted).not.toContain("Warning (");
-  });
-});

package/src/cli/lib/expiration.test.ts

@@ -1,159 +0,0 @@
-import { describe, test, expect } from "vitest";
-import {
-  parseExpiration,
-  resolveExpiration,
-  validateExpiration,
-} from "./expiration.js";
-
-describe("parseExpiration", () => {
-  test('"none" returns kind "none"', () => {
-    expect(parseExpiration("none")).toEqual({ kind: "none" });
-  });
-
-  test("Unix seconds (< 1e12) converts to ms", () => {
-    const result = parseExpiration("1711828382");
-    expect(result).toEqual({ kind: "absolute", timestampMs: 1711828382000 });
-  });
-
-  test("Unix milliseconds (>= 1e12) used as-is", () => {
-    const result = parseExpiration("1711828382000");
-    expect(result).toEqual({ kind: "absolute", timestampMs: 1711828382000 });
-  });
-
-  test("UTC datetime", () => {
-    const result = parseExpiration("2026-03-30T18:53:02Z");
-    expect(result).toEqual({
-      kind: "absolute",
-      timestampMs: new Date("2026-03-30T18:53:02Z").getTime(),
-    });
-  });
-
-  test("rejects datetime without Z suffix", () => {
-    const result = parseExpiration("2026-03-30T18:53:02");
-    expect(result.kind).toBe("error");
-  });
-
-  test("rejects datetime with timezone offset", () => {
-    const result = parseExpiration("2026-03-30T18:53:02+01:00");
-    expect(result.kind).toBe("error");
-  });
-
-  test("rejects bare date without time", () => {
-    const result = parseExpiration("2026-03-30");
-    expect(result.kind).toBe("error");
-  });
-
-  test('relative: "in 1 hour"', () => {
-    expect(parseExpiration("in 1 hour")).toEqual({
-      kind: "relative",
-      amount: 1,
-      unit: "hour",
-    });
-  });
-
-  test('relative: "in 3 hours"', () => {
-    expect(parseExpiration("in 3 hours")).toEqual({
-      kind: "relative",
-      amount: 3,
-      unit: "hour",
-    });
-  });
-
-  test('relative: "in 7 days"', () => {
-    expect(parseExpiration("in 7 days")).toEqual({
-      kind: "relative",
-      amount: 7,
-      unit: "day",
-    });
-  });
-
-  test('relative: "in 45 minutes"', () => {
-    expect(parseExpiration("in 45 minutes")).toEqual({
-      kind: "relative",
-      amount: 45,
-      unit: "minute",
-    });
-  });
-
-  test("invalid input returns error", () => {
-    const result = parseExpiration("yesterday");
-    expect(result).toEqual({
-      kind: "error",
-      message: expect.stringContaining("Invalid expiration format"),
-    });
-  });
-
-  test("empty string returns error", () => {
-    const result = parseExpiration("");
-    expect(result).toEqual({
-      kind: "error",
-      message: expect.stringContaining("Invalid expiration format"),
-    });
-  });
-});
-
-describe("resolveExpiration", () => {
-  const now = 1700000000000;
-
-  test('"none" resolves to null', () => {
-    expect(resolveExpiration({ kind: "none" }, now)).toBeNull();
-  });
-
-  test("absolute resolves to timestampMs", () => {
-    expect(
-      resolveExpiration({ kind: "absolute", timestampMs: 1711828382000 }, now),
-    ).toBe(1711828382000);
-  });
-
-  test("relative hours", () => {
-    expect(
-      resolveExpiration({ kind: "relative", amount: 3, unit: "hour" }, now),
-    ).toBe(now + 3 * 60 * 60 * 1000);
-  });
-
-  test("relative days", () => {
-    expect(
-      resolveExpiration({ kind: "relative", amount: 7, unit: "day" }, now),
-    ).toBe(now + 7 * 24 * 60 * 60 * 1000);
-  });
-
-  test("relative minutes", () => {
-    expect(
-      resolveExpiration({ kind: "relative", amount: 45, unit: "minute" }, now),
-    ).toBe(now + 45 * 60 * 1000);
-  });
-});
-
-describe("validateExpiration", () => {
-  const now = 1700000000000;
-
-  test("past timestamp returns error", () => {
-    const result = validateExpiration(now - 1000, now);
-    expect(result).toEqual({
-      kind: "error",
-      message: expect.stringContaining("in the future"),
-    });
-  });
-
-  test("less than 30 minutes from now returns error", () => {
-    const result = validateExpiration(now + 10 * 60 * 1000, now);
-    expect(result).toEqual({
-      kind: "error",
-      message: expect.stringContaining("at least 30 minutes"),
-    });
-  });
-
-  test("more than 1 year from now returns error", () => {
-    const overOneYear = now + 366 * 24 * 60 * 60 * 1000;
-    const result = validateExpiration(overOneYear, now);
-    expect(result).toEqual({
-      kind: "error",
-      message: expect.stringContaining("at most 1 year"),
-    });
-  });
-
-  test("valid timestamp returns success", () => {
-    const twoHours = now + 2 * 60 * 60 * 1000;
-    expect(validateExpiration(twoHours, now)).toEqual({ kind: "success" });
-  });
-});

package/src/cli/lib/extractDeploymentNameForWorkOS.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { extractDeploymentNameForWorkOS } from "./extractDeploymentNameForWorkOS.js";
-
-describe("extractDeploymentNameForWorkOS", () => {
-  it("extracts deployment name from valid URL", () => {
-    expect(
-      extractDeploymentNameForWorkOS("https://happy-capybara-123.convex.cloud"),
-    ).toEqual("happy-capybara-123");
-  });
-
-  it("extracts deployment name from EU region URL", () => {
-    expect(
-      extractDeploymentNameForWorkOS(
-        "https://basic-whale-224.eu-west-1.convex.cloud",
-      ),
-    ).toEqual("basic-whale-224");
-  });
-
-  it("returns null for non-convex.cloud URLs", () => {
-    expect(extractDeploymentNameForWorkOS("https://api.sync.t3.chat")).toEqual(
-      null,
-    );
-  });
-
-  it("returns null for convex.site", () => {
-    expect(
-      extractDeploymentNameForWorkOS("https://happy-capybara-123.convex.site"),
-    ).toEqual(null);
-  });
-});