convex 1.44.0 → 1.45.0-alpha.0

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

@@ -1,242 +0,0 @@
-import { test, expect, describe, beforeEach, afterEach } from "vitest";
-import { resolveTemplate } from "./workos.js";
-
-describe("resolveTemplate", () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    // Create a clean environment for each test
-    process.env = { ...originalEnv };
-  });
-
-  afterEach(() => {
-    // Restore original environment
-    process.env = originalEnv;
-  });
-
-  describe("authEnv templates", () => {
-    test("resolves WORKOS_CLIENT_ID when provided", () => {
-      const result = resolveTemplate("${authEnv.WORKOS_CLIENT_ID}", {
-        clientId: "client_123",
-        apiKey: "key_456",
-        environmentId: "env_789",
-      });
-      expect(result).toBe("client_123");
-    });
-
-    test("resolves WORKOS_API_KEY when provided", () => {
-      const result = resolveTemplate("${authEnv.WORKOS_API_KEY}", {
-        clientId: "client_123",
-        apiKey: "key_456",
-        environmentId: "env_789",
-      });
-      expect(result).toBe("key_456");
-    });
-
-    test("resolves WORKOS_ENVIRONMENT_ID when provided", () => {
-      const result = resolveTemplate("${authEnv.WORKOS_ENVIRONMENT_ID}", {
-        clientId: "client_123",
-        apiKey: "key_456",
-        environmentId: "env_789",
-      });
-      expect(result).toBe("env_789");
-    });
-
-    test("throws when WORKOS_CLIENT_ID is not available", () => {
-      expect(() => {
-        resolveTemplate("${authEnv.WORKOS_CLIENT_ID}", {
-          apiKey: "key_456",
-        });
-      }).toThrow(
-        "Cannot resolve template ${authEnv.WORKOS_CLIENT_ID}: WORKOS_CLIENT_ID not available",
-      );
-    });
-
-    test("throws when WORKOS_API_KEY is not available", () => {
-      expect(() => {
-        resolveTemplate("${authEnv.WORKOS_API_KEY}", {
-          clientId: "client_123",
-        });
-      }).toThrow(
-        "Cannot resolve template ${authEnv.WORKOS_API_KEY}: WORKOS_API_KEY not available",
-      );
-    });
-
-    test("throws when provisioned object is undefined", () => {
-      expect(() => {
-        resolveTemplate("${authEnv.WORKOS_CLIENT_ID}");
-      }).toThrow(
-        "Cannot resolve template ${authEnv.WORKOS_CLIENT_ID}: WORKOS_CLIENT_ID not available",
-      );
-    });
-  });
-
-  describe("buildEnv templates", () => {
-    test("resolves environment variable when set", () => {
-      process.env.MY_TEST_VAR = "test_value";
-      const result = resolveTemplate("${buildEnv.MY_TEST_VAR}");
-      expect(result).toBe("test_value");
-    });
-
-    test("throws when environment variable is not set", () => {
-      delete process.env.NONEXISTENT_VAR;
-      expect(() => {
-        resolveTemplate("${buildEnv.NONEXISTENT_VAR}");
-      }).toThrow(
-        "Cannot resolve template ${buildEnv.NONEXISTENT_VAR}: Environment variable NONEXISTENT_VAR is not set",
-      );
-    });
-
-    test("handles empty string environment variable", () => {
-      process.env.EMPTY_VAR = "";
-      expect(() => {
-        resolveTemplate("${buildEnv.EMPTY_VAR}");
-      }).toThrow(
-        "Cannot resolve template ${buildEnv.EMPTY_VAR}: Environment variable EMPTY_VAR is not set",
-      );
-    });
-  });
-
-  describe("unknown templates", () => {
-    test("throws for unknown prefix", () => {
-      expect(() => {
-        resolveTemplate("${unknownPrefix.FOO}");
-      }).toThrow("Unknown template expression: ${unknownPrefix.FOO}");
-    });
-
-    test("throws for no prefix", () => {
-      expect(() => {
-        resolveTemplate("${hello}");
-      }).toThrow("Unknown template expression: ${hello}");
-    });
-
-    test("throws for typo in authEnv", () => {
-      expect(() => {
-        resolveTemplate("${authenv.WORKOS_CLIENT_ID}"); // lowercase 'e'
-      }).toThrow("Unknown template expression: ${authenv.WORKOS_CLIENT_ID}");
-    });
-
-    test("throws for typo in buildEnv", () => {
-      expect(() => {
-        resolveTemplate("${buildenv.MY_VAR}"); // lowercase 'e'
-      }).toThrow("Unknown template expression: ${buildenv.MY_VAR}");
-    });
-
-    test("throws for unknown authEnv variable", () => {
-      expect(() => {
-        resolveTemplate("${authEnv.UNKNOWN_VAR}", {
-          clientId: "client_123",
-        });
-      }).toThrow("Unknown template expression: ${authEnv.UNKNOWN_VAR}");
-    });
-  });
-
-  describe("complex templates", () => {
-    test("resolves multiple templates in one string", () => {
-      process.env.DOMAIN = "example.com";
-      const result = resolveTemplate(
-        "https://${buildEnv.DOMAIN}/auth/${authEnv.WORKOS_CLIENT_ID}",
-        { clientId: "client_123" },
-      );
-      expect(result).toBe("https://example.com/auth/client_123");
-    });
-
-    test("leaves non-template strings unchanged", () => {
-      const result = resolveTemplate("https://example.com/callback");
-      expect(result).toBe("https://example.com/callback");
-    });
-
-    test("handles mixed template and literal text", () => {
-      process.env.PORT = "3000";
-      const result = resolveTemplate("http://localhost:${buildEnv.PORT}/api");
-      expect(result).toBe("http://localhost:3000/api");
-    });
-
-    test("handles adjacent templates", () => {
-      process.env.PROTO = "https";
-      process.env.DOMAIN = "example.com";
-      const result = resolveTemplate("${buildEnv.PROTO}://${buildEnv.DOMAIN}");
-      expect(result).toBe("https://example.com");
-    });
-  });
-
-  describe("edge cases", () => {
-    test("handles empty string input", () => {
-      const result = resolveTemplate("");
-      expect(result).toBe("");
-    });
-
-    test("handles string with no templates", () => {
-      const result = resolveTemplate("plain text without templates");
-      expect(result).toBe("plain text without templates");
-    });
-
-    test("handles malformed template syntax", () => {
-      // Missing closing brace - should not be replaced
-      const result = resolveTemplate("${buildEnv.UNCLOSED");
-      expect(result).toBe("${buildEnv.UNCLOSED");
-    });
-
-    test("handles nested braces incorrectly", () => {
-      // Nested braces don't work - the regex matches the first }
-      // This actually tries to resolve an env var called "${OTHER_VAR"
-      expect(() => {
-        resolveTemplate("${buildEnv.${OTHER_VAR}}");
-      }).toThrow(
-        "Cannot resolve template ${buildEnv.${OTHER_VAR}: Environment variable ${OTHER_VAR is not set.",
-      );
-    });
-
-    test("handles special characters in environment variable names", () => {
-      process.env["MY-VAR-WITH-DASHES"] = "value";
-      const result = resolveTemplate("${buildEnv.MY-VAR-WITH-DASHES}");
-      expect(result).toBe("value");
-    });
-
-    test("handles template at the very end", () => {
-      process.env.SUFFIX = "end";
-      const result = resolveTemplate("prefix-${buildEnv.SUFFIX}");
-      expect(result).toBe("prefix-end");
-    });
-
-    test("handles template at the very beginning", () => {
-      process.env.PREFIX = "start";
-      const result = resolveTemplate("${buildEnv.PREFIX}-suffix");
-      expect(result).toBe("start-suffix");
-    });
-
-    test("throws with helpful message for common typos", () => {
-      const provisioned = { clientId: "client_123" };
-
-      // Wrong case
-      expect(() => {
-        resolveTemplate("${authEnv.workos_client_id}", provisioned);
-      }).toThrow("Unknown template expression");
-
-      // Space in variable name
-      expect(() => {
-        resolveTemplate("${authEnv.WORKOS CLIENT ID}", provisioned);
-      }).toThrow("Unknown template expression");
-    });
-  });
-
-  describe("error message quality", () => {
-    test("provides clear error for missing auth credentials", () => {
-      expect(() => {
-        resolveTemplate("${authEnv.WORKOS_CLIENT_ID}");
-      }).toThrow(/Ensure WorkOS environment is provisioned/);
-    });
-
-    test("provides clear error for missing env var", () => {
-      expect(() => {
-        resolveTemplate("${buildEnv.MISSING_VAR}");
-      }).toThrow(/Environment variable MISSING_VAR is not set/);
-    });
-
-    test("provides suggestions for unknown templates", () => {
-      expect(() => {
-        resolveTemplate("${foo.bar}");
-      }).toThrow(/Use \$\{buildEnv\.VAR_NAME\} for environment variables/);
-    });
-  });
-});

package/src/cli/login.test.ts

@@ -1,261 +0,0 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
-import { nodeFs } from "../bundler/fs.js";
-import { login } from "./login.js";
-import { bigBrainAPI } from "./lib/utils/utils.js";
-import { readGlobalConfig } from "./lib/utils/globalConfig.js";
-
-vi.mock("@sentry/node", () => ({
-  captureException: vi.fn(),
-  close: vi.fn(),
-}));
-
-vi.mock("../bundler/fs.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("../bundler/fs.js")>();
-  return {
-    ...actual,
-    nodeFs: {
-      ...actual.nodeFs,
-      exists: vi.fn(),
-      readUtf8File: vi.fn(),
-    },
-  };
-});
-
-vi.mock("./lib/utils/utils.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("./lib/utils/utils.js")>();
-  return { ...actual, bigBrainAPI: vi.fn() };
-});
-
-vi.mock("./lib/utils/globalConfig.js", async (importOriginal) => {
-  const actual =
-    await importOriginal<typeof import("./lib/utils/globalConfig.js")>();
-  return { ...actual, readGlobalConfig: vi.fn() };
-});
-
-// `initializeBigBrainAuth` loads `.env.local` and `.env` into `process.env`.
-// Tests set those variables directly, and `dotenv.parse` stays real for the
-// file-attribution lookup.
-vi.mock("dotenv", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("dotenv")>();
-  return { ...actual, config: vi.fn() };
-});
-
-const ACCOUNT_TOKEN = "account-token";
-const TEAMS = [{ id: 1, name: "Team One", slug: "team-one" }];
-const DEPLOYMENT_KEY = "dev:tall-goat-123|deployment-secret";
-const PROJECT_KEY = "project:my-team:my-project|project-secret";
-
-/** Authorization headers Big Brain accepts. Anything else gets a 401. */
-let authorized: Set<string>;
-let mockFetch: ReturnType<typeof vi.fn>;
-
-async function runStatus() {
-  await login.parseAsync(["status"], { from: "user" });
-}
-
-function output(): string {
-  return vi
-    .mocked(process.stderr.write)
-    .mock.calls.map((call) => String(call[0]))
-    .join("");
-}
-
-/** The credentials `/api/authorize` was called with, in order. */
-function authorizeHeaders(): string[] {
-  return mockFetch.mock.calls.map(
-    (call) => (call[1] as any).headers.Authorization,
-  );
-}
-
-function setEnvFile(path: string, contents: string) {
-  vi.mocked(nodeFs.exists).mockImplementation((p) => p === path);
-  vi.mocked(nodeFs.readUtf8File).mockImplementation((p) => {
-    if (p !== path) {
-      throw new Error(`Unexpected read of ${p}`);
-    }
-    return contents;
-  });
-}
-
-describe("npx convex login status", () => {
-  let savedEnv: NodeJS.ProcessEnv;
-
-  beforeEach(() => {
-    savedEnv = { ...process.env };
-    process.env = {};
-
-    vi.resetAllMocks();
-    authorized = new Set([`Bearer ${ACCOUNT_TOKEN}`]);
-    mockFetch = vi.fn(async (url: string, options: any) => {
-      if (!String(url).endsWith("/api/authorize")) {
-        throw new Error(`Unexpected fetch of ${url}`);
-      }
-      return {
-        status: authorized.has(options.headers.Authorization) ? 200 : 401,
-      };
-    });
-    vi.stubGlobal("fetch", mockFetch);
-
-    vi.mocked(readGlobalConfig).mockReturnValue({ accessToken: ACCOUNT_TOKEN });
-    vi.mocked(bigBrainAPI).mockResolvedValue(TEAMS);
-    vi.mocked(nodeFs.exists).mockReturnValue(false);
-
-    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
-    vi.spyOn(process, "exit").mockImplementation((() => {
-      throw new Error("process.exit called");
-    }) as any);
-  });
-
-  afterEach(() => {
-    process.env = savedEnv;
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-  });
-
-  describe("account status", () => {
-    test("reports the account and its teams", async () => {
-      await runStatus();
-
-      expect(output()).toContain("Convex account token found in:");
-      expect(output()).toContain("config.json");
-      expect(output()).toContain("Status: Logged in");
-      expect(output()).toContain("Teams: 1 team accessible");
-      expect(output()).toContain("- Team One (team-one)");
-      expect(output()).not.toContain("Working Directory:");
-    });
-
-    test("reports no token when the global config is missing", async () => {
-      vi.mocked(readGlobalConfig).mockReturnValue(null);
-
-      await runStatus();
-
-      expect(output()).toContain("No Convex account token found in:");
-      expect(output()).toContain("Status: Not logged in");
-      expect(bigBrainAPI).not.toHaveBeenCalled();
-    });
-
-    test("reports not logged in when Big Brain rejects the account token", async () => {
-      authorized.clear();
-
-      await runStatus();
-
-      expect(output()).toContain("Convex account token found in:");
-      expect(output()).toContain("Status: Not logged in");
-      expect(bigBrainAPI).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("deploy key in the working directory", () => {
-    test("reports a valid deployment key, checked without its prefix", async () => {
-      process.env.CONVEX_DEPLOY_KEY = DEPLOYMENT_KEY;
-      setEnvFile(".env.local", `CONVEX_DEPLOY_KEY=${DEPLOYMENT_KEY}\n`);
-      // Big Brain only accepts a deployment key with the `dev:` prefix removed.
-      authorized.add("Bearer deployment-secret");
-
-      await runStatus();
-
-      expect(output()).toContain(
-        "Working Directory: Valid CONVEX_DEPLOY_KEY in .env.local",
-      );
-      expect(authorizeHeaders()).toContain("Bearer deployment-secret");
-      expect(authorizeHeaders()).not.toContain(`Bearer ${DEPLOYMENT_KEY}`);
-    });
-
-    test("reports a deployment key Big Brain rejects", async () => {
-      process.env.CONVEX_DEPLOY_KEY = DEPLOYMENT_KEY;
-      setEnvFile(".env.local", `CONVEX_DEPLOY_KEY=${DEPLOYMENT_KEY}\n`);
-
-      await runStatus();
-
-      expect(output()).toContain(
-        "Working Directory: Invalid CONVEX_DEPLOY_KEY in .env.local",
-      );
-    });
-
-    test("attributes a key that isn't in an env file to the shell", async () => {
-      process.env.CONVEX_DEPLOY_KEY = DEPLOYMENT_KEY;
-
-      await runStatus();
-
-      expect(output()).toContain(
-        "Working Directory: Invalid CONVEX_DEPLOY_KEY in shell environment",
-      );
-    });
-
-    test("attributes a key found in .env", async () => {
-      process.env.CONVEX_DEPLOY_KEY = DEPLOYMENT_KEY;
-      setEnvFile(".env", `CONVEX_DEPLOY_KEY=${DEPLOYMENT_KEY}\n`);
-
-      await runStatus();
-
-      expect(output()).toContain(
-        "Working Directory: Invalid CONVEX_DEPLOY_KEY in .env",
-      );
-    });
-
-    test("names CONVEX_DEPLOYMENT_TOKEN when that's the variable set", async () => {
-      process.env.CONVEX_DEPLOYMENT_TOKEN = DEPLOYMENT_KEY;
-      setEnvFile(".env.local", `CONVEX_DEPLOYMENT_TOKEN=${DEPLOYMENT_KEY}\n`);
-      authorized.add("Bearer deployment-secret");
-
-      await runStatus();
-
-      expect(output()).toContain(
-        "Working Directory: Valid CONVEX_DEPLOYMENT_TOKEN in .env.local",
-      );
-    });
-
-    test("reports a project key", async () => {
-      process.env.CONVEX_DEPLOY_KEY = PROJECT_KEY;
-      setEnvFile(".env.local", `CONVEX_DEPLOY_KEY=${PROJECT_KEY}\n`);
-      authorized.add("Bearer project-secret");
-
-      await runStatus();
-
-      expect(output()).toContain(
-        "Working Directory: Valid CONVEX_DEPLOY_KEY in .env.local",
-      );
-      expect(authorizeHeaders()).toContain("Bearer project-secret");
-    });
-
-    test("stays quiet about a preview key, which never outranks the account", async () => {
-      vi.mocked(readGlobalConfig).mockReturnValue(null);
-      process.env.CONVEX_DEPLOY_KEY =
-        "preview:my-team:my-project|preview-secret";
-
-      await runStatus();
-
-      expect(output()).toContain("Status: Not logged in");
-      expect(output()).not.toContain("Working Directory:");
-    });
-  });
-
-  describe("account and deploy key together", () => {
-    test("reports both, listing teams for the account", async () => {
-      process.env.CONVEX_DEPLOY_KEY = DEPLOYMENT_KEY;
-      setEnvFile(".env.local", `CONVEX_DEPLOY_KEY=${DEPLOYMENT_KEY}\n`);
-
-      await runStatus();
-
-      expect(output()).toContain("Status: Logged in");
-      expect(output()).toContain("Teams: 1 team accessible");
-      expect(output()).toContain(
-        "Working Directory: Invalid CONVEX_DEPLOY_KEY in .env.local",
-      );
-    });
-
-    test("reports the key while logged out", async () => {
-      vi.mocked(readGlobalConfig).mockReturnValue(null);
-      process.env.CONVEX_DEPLOY_KEY = DEPLOYMENT_KEY;
-      setEnvFile(".env.local", `CONVEX_DEPLOY_KEY=${DEPLOYMENT_KEY}\n`);
-
-      await runStatus();
-
-      expect(output()).toContain("No Convex account token found in:");
-      expect(output()).toContain("Status: Not logged in");
-      expect(output()).toContain(
-        "Working Directory: Invalid CONVEX_DEPLOY_KEY in .env.local",
-      );
-    });
-  });
-});

package/src/common/README.md

@@ -1,2 +0,0 @@
-Code in this common/ folder is not publicly exposed, there is no 'convex/common'
-export. Code here is used from other entry points.

package/src/common/index.test.ts

@@ -1,35 +0,0 @@
-import { test, describe, expect } from "vitest";
-import { validateDeploymentUrl } from "./index.js";
-
-describe("validateDeploymentUrl", () => {
-  test("localhost is valid", () => {
-    validateDeploymentUrl("http://127.0.0.1:8000");
-    validateDeploymentUrl("http://localhost:8000");
-    validateDeploymentUrl("http://0.0.0.0:8000");
-  });
-  test("real URLs are valid", () => {
-    validateDeploymentUrl("https://small-mouse-123.convex.cloud");
-  });
-
-  test("vanity domain works", () => {
-    validateDeploymentUrl("https://tshirts.com");
-  });
-
-  test("wrong protocol throws", () => {
-    expect(() =>
-      validateDeploymentUrl("ws://small-mouse-123.convex.cloud"),
-    ).toThrow("Invalid deployment address");
-  });
-
-  test("invalid url throws", () => {
-    expect(() => validateDeploymentUrl("https://:small-mouse-123:")).toThrow(
-      "Invalid deployment address",
-    );
-  });
-
-  test(".convex.site domain throws", () => {
-    expect(() =>
-      validateDeploymentUrl("https://small-mouse-123.convex.site"),
-    ).toThrow("Invalid deployment address");
-  });
-});

package/src/nextjs/nextjs.test.tsx

@@ -1,94 +0,0 @@
-/**
- * @vitest-environment custom-vitest-environment.ts
- */
-import { vi, expect, test, describe, beforeEach, afterEach } from "vitest";
-
-import { renderHook } from "@testing-library/react";
-import React from "react";
-import { ConvexProvider, ConvexReactClient } from "../react/client.js";
-import { usePreloadedQuery } from "../react/hydration.js";
-import { anyApi } from "../server/api.js";
-import { convexToJson } from "../values/value.js";
-import { preloadQuery, preloadedQueryResult } from "./index.js";
-
-const address = "https://127.0.0.1:3001";
-
-describe("env setup", () => {
-  test("requires NEXT_PUBLIC_CONVEX_URL", async () => {
-    await expect(preloadQuery(anyApi.myQuery.default)).rejects.toThrow(
-      "Environment variable NEXT_PUBLIC_CONVEX_URL is not set.",
-    );
-  });
-});
-
-describe("preloadQuery and usePreloadedQuery", () => {
-  beforeEach(() => {
-    global.process.env.NEXT_PUBLIC_CONVEX_URL = address;
-    global.fetch = vi.fn().mockResolvedValue({
-      ok: true,
-      json: () =>
-        Promise.resolve({ status: "success", value: convexToJson({ x: 42 }) }),
-    } as never) as any;
-  });
-
-  afterEach(() => {
-    delete global.process.env.NEXT_PUBLIC_CONVEX_URL;
-  });
-
-  test("returns server result before client loads data", async () => {
-    const preloaded = await preloadQuery(anyApi.myQuery.default, {
-      arg: "something",
-    });
-    const serverResult = preloadedQueryResult(preloaded);
-
-    expect(fetch).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.objectContaining({
-        cache: "no-store",
-      }),
-    );
-
-    expect(serverResult).toStrictEqual({ x: 42 });
-
-    const client = new ConvexReactClient(address);
-    const wrapper = ({ children }: any) => (
-      <ConvexProvider client={client}>{children}</ConvexProvider>
-    );
-    const { result: hydrationResult } = renderHook(
-      () => usePreloadedQuery(preloaded),
-      { wrapper },
-    );
-    expect(hydrationResult.current).toStrictEqual({ x: 42 });
-  });
-
-  test("returns client result after client loads data", async () => {
-    const preloaded = await preloadQuery(anyApi.myQuery.default, {
-      arg: "something",
-    });
-    const client = new ConvexReactClient(address);
-    // Use an optimistic update to set up a query to have a result.
-    void client.mutation(
-      anyApi.myMutation.default,
-      {},
-      {
-        optimisticUpdate: (localStore) => {
-          localStore.setQuery(
-            anyApi.myQuery.default,
-            { arg: "something" },
-            // Simplest value to return, and make sure we're correctly
-            // handling it.
-            null,
-          );
-        },
-      },
-    );
-    const wrapper = ({ children }: any) => (
-      <ConvexProvider client={client}>{children}</ConvexProvider>
-    );
-    const { result: clientResult } = renderHook(
-      () => usePreloadedQuery(preloaded),
-      { wrapper },
-    );
-    expect(clientResult.current).toStrictEqual(null);
-  });
-});