convex 1.44.0 → 1.45.0

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

@@ -1,84 +0,0 @@
-import { expect, test } from "vitest";
-import { inlineQueryToQuerySource } from "./runTestFunction.js";
-
-test("wraps inline query expressions in a readonly query module", () => {
-  expect(inlineQueryToQuerySource('ctx.db.query("messages").first()'))
-    .toBe(`import { query, internalQuery } from "convex:/_system/repl/wrappers.js";
-
-export default query({
-  handler: async (ctx) => {
-    return (ctx.db.query("messages").first());
-  },
-});`);
-});
-
-test("preserves explicit return bodies", () => {
-  expect(
-    inlineQueryToQuerySource('return await ctx.db.query("messages").first();'),
-  )
-    .toBe(`import { query, internalQuery } from "convex:/_system/repl/wrappers.js";
-
-export default query({
-  handler: async (ctx) => {
-    return await ctx.db.query("messages").first();
-  },
-});`);
-});
-
-test("wraps awaited expressions without changing them", () => {
-  expect(inlineQueryToQuerySource('await ctx.db.query("messages").first()'))
-    .toBe(`import { query, internalQuery } from "convex:/_system/repl/wrappers.js";
-
-export default query({
-  handler: async (ctx) => {
-    return (await ctx.db.query("messages").first());
-  },
-});`);
-});
-
-test("preserves multi line statement bodies", () => {
-  expect(
-    inlineQueryToQuerySource(`const firstMessage = await ctx.db.query("messages").first();
-console.log(firstMessage?._id);
-return firstMessage;`),
-  )
-    .toBe(`import { query, internalQuery } from "convex:/_system/repl/wrappers.js";
-
-export default query({
-  handler: async (ctx) => {
-    const firstMessage = await ctx.db.query("messages").first();
-    console.log(firstMessage?._id);
-    return firstMessage;
-  },
-});`);
-});
-
-test("preserves full query module source", () => {
-  const source = `import { query } from "convex:/_system/repl/wrappers.js";
-
-export default query({
-  handler: async (ctx) => {
-    return await ctx.db.query("messages").first();
-  },
-});`;
-
-  expect(inlineQueryToQuerySource(source)).toBe(source);
-});
-
-test("injects the wrappers import for full query modules", () => {
-  const source = `export default query({
-  handler: async (ctx) => {
-    return await ctx.db.query("messages").first();
-  },
-});`;
-
-  expect(inlineQueryToQuerySource(source)).toBe(
-    `import { query, internalQuery } from "convex:/_system/repl/wrappers.js";
-
-export default query({
-  handler: async (ctx) => {
-    return await ctx.db.query("messages").first();
-  },
-});`,
-  );
-});

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

@@ -1,71 +0,0 @@
-import { describe, expect, test } from "vitest";
-import path from "path";
-import { findTypeScriptCompilerPath } from "./typecheck.js";
-import type { TypescriptCompiler } from "./typecheck.js";
-
-const compilerPaths = {
-  tsc: path.join("node_modules", "typescript", "bin", "tsc"),
-  native: path.join("node_modules", "@typescript", "native", "bin", "tsc"),
-  tsgo: path.join(
-    "node_modules",
-    "@typescript",
-    "native-preview",
-    "bin",
-    "tsgo",
-  ),
-  legacyTsgo: path.join(
-    "node_modules",
-    "@typescript",
-    "native-preview",
-    "bin",
-    "tsgo.js",
-  ),
-} as const;
-
-describe("findTypeScriptCompilerPath", () => {
-  test.each<{
-    compiler: TypescriptCompiler;
-    existing: string[];
-    expected: string | undefined;
-  }>([
-    {
-      compiler: "tsc",
-      existing: [compilerPaths.tsc],
-      expected: compilerPaths.tsc,
-    },
-    {
-      compiler: "tsc",
-      existing: [compilerPaths.native],
-      expected: compilerPaths.native,
-    },
-    {
-      compiler: "tsc",
-      existing: [compilerPaths.tsc, compilerPaths.native],
-      expected: compilerPaths.native,
-    },
-    {
-      compiler: "tsgo",
-      existing: [compilerPaths.tsgo],
-      expected: compilerPaths.tsgo,
-    },
-    {
-      compiler: "tsgo",
-      existing: [compilerPaths.legacyTsgo],
-      expected: compilerPaths.legacyTsgo,
-    },
-    {
-      compiler: "tsgo",
-      existing: [compilerPaths.tsgo, compilerPaths.legacyTsgo],
-      expected: compilerPaths.tsgo,
-    },
-    { compiler: "tsc", existing: [], expected: undefined },
-    { compiler: "tsgo", existing: [], expected: undefined },
-  ])("finds $expected for $compiler", ({ compiler, existing, expected }) => {
-    expect(
-      findTypeScriptCompilerPath(
-        { exists: (candidate) => existing.includes(candidate) },
-        compiler,
-      ),
-    ).toBe(expected);
-  });
-});

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

@@ -1,157 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { checkVersionAndAiFilesStaleness } from "./updates.js";
-import { getVersion } from "./versionApi.js";
-import { logMessage } from "../../bundler/log.js";
-import { checkAiFilesStalenessAndLog } from "./aiFiles/index.js";
-import { readProjectConfig } from "./config.js";
-import type { Context } from "../../bundler/context.js";
-
-vi.mock("./versionApi.js", () => ({
-  getVersion: vi.fn(),
-}));
-
-vi.mock("./aiFiles/index.js", () => ({
-  checkAiFilesStalenessAndLog: vi.fn(),
-  isAiFilesDisabled: vi.fn((aiFilesConfig) =>
-    aiFilesConfig?.enabled !== undefined
-      ? aiFilesConfig.enabled === false
-      : aiFilesConfig?.disableStalenessMessage === true,
-  ),
-}));
-
-vi.mock("../../bundler/log.js", () => ({
-  logMessage: vi.fn(),
-}));
-
-vi.mock("./config.js", () => ({
-  readProjectConfig: vi.fn(),
-}));
-
-const mockGetVersion = vi.mocked(getVersion);
-const mockLogMessage = vi.mocked(logMessage);
-const mockCheckAiFilesStalenessAndLog = vi.mocked(checkAiFilesStalenessAndLog);
-const mockReadProjectConfig = vi.mocked(readProjectConfig);
-
-const fakeCtx = {} as Context;
-
-const okVersion = (overrides?: object) => ({
-  kind: "ok" as const,
-  data: {
-    message: null,
-    guidelinesHash: "abc-guidelines-hash",
-    agentSkillsSha: "abc-skills-sha",
-    disableSkillsCli: false,
-    disableSkillsCliMessage: null,
-    ...overrides,
-  },
-});
-
-describe("checkVersionAndAiFilesStaleness", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockCheckAiFilesStalenessAndLog.mockResolvedValue(undefined);
-    mockReadProjectConfig.mockResolvedValue({
-      projectConfig: {
-        functions: "convex",
-        node: { externalPackages: [] },
-        generateCommonJSApi: false,
-        codegen: { staticApi: true, staticDataModel: true },
-      },
-      configPath: "convex.json",
-    });
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-
-  it("logs version message when server provides one", async () => {
-    mockGetVersion.mockResolvedValue(
-      okVersion({ message: "New version available: 1.2.3" }),
-    );
-
-    await checkVersionAndAiFilesStaleness(fakeCtx);
-
-    expect(mockLogMessage).toHaveBeenCalledWith("New version available: 1.2.3");
-  });
-
-  it("does not log when version has no message", async () => {
-    mockGetVersion.mockResolvedValue(okVersion());
-
-    await checkVersionAndAiFilesStaleness(fakeCtx);
-
-    expect(mockLogMessage).not.toHaveBeenCalled();
-  });
-
-  it("does nothing when getVersion returns error", async () => {
-    mockGetVersion.mockResolvedValue({ kind: "error" });
-
-    await checkVersionAndAiFilesStaleness(fakeCtx);
-
-    expect(mockLogMessage).not.toHaveBeenCalled();
-    expect(mockCheckAiFilesStalenessAndLog).not.toHaveBeenCalled();
-  });
-
-  it("passes hashes and project paths to staleness check", async () => {
-    mockGetVersion.mockResolvedValue(
-      okVersion({
-        guidelinesHash:
-          "02e43fc1ff0ee48db8da468f5c7525877d8056fcd56c77d78a166ac447efb91c",
-        agentSkillsSha: "abc123def456abc123def456abc123def456abc1",
-      }),
-    );
-
-    await checkVersionAndAiFilesStaleness(fakeCtx);
-
-    expect(mockCheckAiFilesStalenessAndLog).toHaveBeenCalledWith({
-      canonicalGuidelinesHash:
-        "02e43fc1ff0ee48db8da468f5c7525877d8056fcd56c77d78a166ac447efb91c",
-      canonicalAgentSkillsSha: "abc123def456abc123def456abc123def456abc1",
-      projectDir: expect.any(String),
-      convexDir: expect.any(String),
-    });
-  });
-
-  it("passes null hashes when version has none", async () => {
-    mockGetVersion.mockResolvedValue(
-      okVersion({ guidelinesHash: null, agentSkillsSha: null }),
-    );
-
-    await checkVersionAndAiFilesStaleness(fakeCtx);
-
-    expect(mockCheckAiFilesStalenessAndLog).toHaveBeenCalledWith({
-      canonicalGuidelinesHash: null,
-      canonicalAgentSkillsSha: null,
-      projectDir: expect.any(String),
-      convexDir: expect.any(String),
-    });
-  });
-
-  it("skips staleness check when aiFiles.disableStalenessMessage is true", async () => {
-    mockGetVersion.mockResolvedValue(okVersion());
-    mockReadProjectConfig.mockResolvedValue({
-      projectConfig: {
-        functions: "convex",
-        node: { externalPackages: [] },
-        generateCommonJSApi: false,
-        codegen: { staticApi: true, staticDataModel: true },
-        aiFiles: { disableStalenessMessage: true },
-      },
-      configPath: "convex.json",
-    });
-
-    await checkVersionAndAiFilesStaleness(fakeCtx);
-
-    expect(mockCheckAiFilesStalenessAndLog).not.toHaveBeenCalled();
-  });
-
-  it("silently skips staleness check when project config cannot be resolved", async () => {
-    mockGetVersion.mockResolvedValue(okVersion());
-    mockReadProjectConfig.mockRejectedValue(new Error("no convex.json"));
-
-    await expect(
-      checkVersionAndAiFilesStaleness(fakeCtx),
-    ).resolves.toBeUndefined();
-    expect(mockCheckAiFilesStalenessAndLog).not.toHaveBeenCalled();
-  });
-});

package/src/cli/lib/utils/hash.test.ts

@@ -1,25 +0,0 @@
-import { describe, test, expect } from "vitest";
-import { hashSha256 } from "./hash.js";
-
-describe("hashSha256", () => {
-  test("hashes empty string", () => {
-    const result = hashSha256("");
-    expect(result).toBe(
-      "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
-    );
-  });
-
-  test("hashes simple string", () => {
-    const result = hashSha256("hello world");
-    expect(result).toBe(
-      "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
-    );
-  });
-
-  test("hashes unicode string", () => {
-    const result = hashSha256("hello 🌍 world");
-    expect(result).toBe(
-      "d234e59bf292eb39b3c8ba2ee06c21b50c9040530b577e5bf53f028099b37f54",
-    );
-  });
-});

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

@@ -1,340 +0,0 @@
-import { describe, test, expect, vi, afterEach, beforeEach } from "vitest";
-// Must be imported before any module that uses @inquirer/*
-import { screen } from "@inquirer/testing/vitest";
-import type { BigBrainAuth, Context } from "../../../bundler/context.js";
-import {
-  bigBrainFetch,
-  bigBrainAPIMaybeThrows,
-  BIG_BRAIN_URL,
-  selectRegion,
-} from "./utils.js";
-
-// Hoist this mock so it's in place before `retryingFetch` is initialized.
-// We make the factory return a function that delegates to `globalThis.fetch`
-// at call time, so tests can stub it via `vi.stubGlobal`.
-// vitest hoists vi.mock() calls before imports, so this applies to the
-// `retryingFetch = fetchRetryFactory(fetch)` initialization in utils.ts.
-vi.mock("fetch-retry", () => ({
-  default: (_fetch: any) => (resource: any, options: any) =>
-    (globalThis as any).fetch(resource, options),
-}));
-
-function makeContext(auth: BigBrainAuth | null): Context {
-  return {
-    bigBrainAuth: () => auth,
-    crash: vi.fn(),
-    registerCleanup: vi.fn(),
-    removeCleanup: vi.fn(),
-    _updateBigBrainAuth: vi.fn(),
-    fs: {} as any,
-    deprecationMessagePrinted: false,
-    spinner: undefined,
-  } as unknown as Context;
-}
-
-function stubFetch() {
-  const mockFetch = vi
-    .fn()
-    .mockResolvedValue(new Response("{}", { status: 200 }));
-  vi.stubGlobal("fetch", mockFetch);
-  return mockFetch;
-}
-
-function capturedArgs(mockFetch: ReturnType<typeof vi.fn>) {
-  const [resource, options] = mockFetch.mock.calls[0] as [
-    RequestInfo | URL,
-    RequestInit & any,
-  ];
-  return {
-    resource,
-    options,
-    headers: options.headers as Record<string, string>,
-  };
-}
-
-function capturedOptionsHeaders(mockFetch: ReturnType<typeof vi.fn>) {
-  return capturedArgs(mockFetch).headers;
-}
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe("bigBrainFetch", () => {
-  test("sets Convex-Client header and no Authorization when auth is null", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-
-    const fetch = bigBrainFetch(ctx);
-    await fetch("https://api.convex.dev/api/test", { method: "GET" });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const headers = capturedOptionsHeaders(mockFetch);
-    expect(headers["Convex-Client"]).toMatch(/^npm-cli-/);
-    expect(headers["Authorization"]).toBeUndefined();
-  });
-
-  test("sets both Authorization and Convex-Client headers when auth is present", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext({
-      kind: "accessToken",
-      header: "Bearer test-token",
-      accessToken: "test-token",
-    });
-
-    const fetch = bigBrainFetch(ctx);
-    await fetch("https://api.convex.dev/api/test", { method: "GET" });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const headers = capturedOptionsHeaders(mockFetch);
-    expect(headers["Authorization"]).toBe("Bearer test-token");
-    expect(headers["Convex-Client"]).toMatch(/^npm-cli-/);
-  });
-
-  test("caller-supplied options headers are merged over bigBrain headers", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext({
-      kind: "accessToken",
-      header: "Bearer original-token",
-      accessToken: "original-token",
-    });
-
-    const fetch = bigBrainFetch(ctx);
-    await fetch("https://api.convex.dev/api/test", {
-      method: "POST",
-      headers: {
-        Authorization: "Bearer caller-override",
-        "Content-Type": "application/json",
-      },
-    });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const headers = capturedOptionsHeaders(mockFetch);
-    expect(headers["Authorization"]).toBe("Bearer caller-override");
-    expect(headers["Content-Type"]).toBe("application/json");
-    expect(headers["Convex-Client"]).toMatch(/^npm-cli-/);
-  });
-
-  test("uses Request object headers when no options headers provided", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-
-    const request = new Request("https://api.convex.dev/api/test", {
-      method: "GET",
-      headers: { "X-Custom-Header": "custom-value" },
-    });
-
-    const fetch = bigBrainFetch(ctx);
-    await fetch(request, undefined);
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const headers = capturedOptionsHeaders(mockFetch);
-    // The Headers object normalizes header names to lowercase when iterated.
-    expect(headers["x-custom-header"]).toBe("custom-value");
-    expect(headers["Convex-Client"]).toMatch(/^npm-cli-/);
-  });
-
-  test("options headers take precedence over Request object headers", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-
-    const request = new Request("https://api.convex.dev/api/test", {
-      method: "GET",
-      headers: { "X-Custom-Header": "from-request" },
-    });
-
-    const fetch = bigBrainFetch(ctx);
-    await fetch(request, {
-      headers: { "X-Custom-Header": "from-options" },
-    });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const headers = capturedOptionsHeaders(mockFetch);
-    expect(headers["X-Custom-Header"]).toBe("from-options");
-  });
-
-  test("passes the request through to throwingFetch", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-    const request = new Request("https://api.convex.dev/api/some-endpoint", {
-      method: "POST",
-    });
-
-    const fetch = bigBrainFetch(ctx);
-    await fetch(request);
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const [resource] = mockFetch.mock.calls[0] as [any, any];
-    expect(resource).toBe(request);
-  });
-});
-
-describe("bigBrainAPIMaybeThrows", () => {
-  test("joins url with BIG_BRAIN_URL", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-
-    await bigBrainAPIMaybeThrows({ ctx, method: "GET", path: "has_projects" });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const { resource } = capturedArgs(mockFetch);
-    expect(resource.toString()).toBe(
-      new URL("has_projects", BIG_BRAIN_URL).toString(),
-    );
-  });
-
-  test("passes method through for GET with no body", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-
-    await bigBrainAPIMaybeThrows({ ctx, method: "GET", path: "test" });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const { options } = capturedArgs(mockFetch);
-    expect(options.method).toBe("GET");
-    expect(options.body).toBeUndefined();
-  });
-
-  test("POST with no data sends empty object body", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-
-    await bigBrainAPIMaybeThrows({ ctx, method: "POST", path: "test" });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const { options, headers } = capturedArgs(mockFetch);
-    expect(options.method).toBe("POST");
-    expect(options.body).toBe("{}");
-    expect(headers["Content-Type"]).toBe("application/json");
-  });
-
-  test("POST with object data serializes it to JSON", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-    const data = { name: "test", value: 42 };
-
-    await bigBrainAPIMaybeThrows({ ctx, method: "POST", path: "test", data });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const { options } = capturedArgs(mockFetch);
-    expect(options.body).toBe(JSON.stringify(data));
-  });
-
-  test("POST with string data passes it through as-is", async () => {
-    const mockFetch = stubFetch();
-    const ctx = makeContext(null);
-
-    await bigBrainAPIMaybeThrows({
-      ctx,
-      method: "POST",
-      path: "test",
-      data: '{"raw":true}',
-    });
-
-    expect(mockFetch).toHaveBeenCalledOnce();
-    const { options } = capturedArgs(mockFetch);
-    expect(options.body).toBe('{"raw":true}');
-  });
-});
-
-const testRegions = [
-  { name: "aws-eu-west-1", displayName: "EU West (Ireland)", available: true },
-  {
-    name: "aws-us-east-1",
-    displayName: "US East (Virginia)",
-    available: true,
-  },
-  {
-    name: "aws-ap-southeast-1",
-    displayName: "Asia Pacific (Singapore)",
-    available: false,
-  },
-];
-
-function stubRegionsFetch() {
-  const mockFetch = vi.fn().mockImplementation(async (resource: any) => {
-    const url = resource instanceof Request ? resource.url : String(resource);
-    if (url.includes("/list_deployment_regions")) {
-      return new Response(JSON.stringify({ items: testRegions }), {
-        status: 200,
-      });
-    }
-    return new Response("{}", { status: 200 });
-  });
-  vi.stubGlobal("fetch", mockFetch);
-  return mockFetch;
-}
-
-describe("selectRegion", () => {
-  beforeEach(() => {
-    stubRegionsFetch();
-    process.stdin.isTTY = true;
-  });
-
-  afterEach(() => {
-    process.stdin.isTTY = false;
-  });
-
-  test("US region is shown first", async () => {
-    const ctx = makeContext(null);
-
-    const promise = selectRegion(ctx, 123, "dev");
-
-    await screen.next();
-    const rendered = screen.getScreen();
-    // US East should appear before EU West in the rendered output
-    const usIndex = rendered.indexOf("US East");
-    const euIndex = rendered.indexOf("EU West");
-    expect(usIndex).toBeGreaterThanOrEqual(0);
-    expect(euIndex).toBeGreaterThanOrEqual(0);
-    expect(usIndex).toBeLessThan(euIndex);
-
-    // Select the first option (US East) and resolve the promise
-    screen.keypress("enter");
-    const result = await promise;
-    expect(result).toBe("aws-us-east-1");
-  });
-
-  test("unavailable regions are not displayed", async () => {
-    const ctx = makeContext(null);
-
-    const promise = selectRegion(ctx, 123, "dev");
-
-    await screen.next();
-    const rendered = screen.getScreen();
-    expect(rendered).not.toContain("Asia Pacific (Singapore)");
-    expect(rendered).toContain("US East (Virginia)");
-    expect(rendered).toContain("EU West (Ireland)");
-
-    screen.keypress("enter");
-    await promise;
-  });
-
-  const availableRegions = testRegions.filter((r) => r.available);
-
-  test.each(availableRegions.map((r, i) => ({ ...r, downPresses: i })))(
-    "selecting option at position $downPresses returns the correct region",
-    async ({ downPresses }) => {
-      const ctx = makeContext(null);
-
-      const promise = selectRegion(ctx, 123, "dev");
-
-      await screen.next();
-      for (let i = 0; i < downPresses; i++) {
-        screen.keypress("down");
-      }
-
-      // Check which option is currently highlighted on screen,
-      // then find the matching region to know what value to expect.
-      const rendered = screen.getScreen();
-      const selectedRegion = testRegions.find(
-        (r) => r.available && rendered.includes(`❯ ${r.displayName}`),
-      );
-      expect(selectedRegion).toBeDefined();
-
-      screen.keypress("enter");
-      const result = await promise;
-      expect(result).toBe(selectedRegion!.name);
-    },
-  );
-});