convex 1.43.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/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);
-  });
-});