convex 1.44.0 → 1.45.0

package/src/react/client.test.tsx

@@ -1,261 +0,0 @@
-/**
- * @vitest-environment happy-dom
- */
-import { test, expect, describe, vi } from "vitest";
-import ws from "ws";
-
-import {
-  ConvexReactClient,
-  createMutation,
-  useQuery,
-  useQuery_experimental,
-} from "./client.js";
-import { convexQueryOptions } from "../browser/query_options.js";
-import { ConvexProvider } from "./index.js";
-import React from "react";
-import { renderHook } from "@testing-library/react";
-import { anyApi, makeFunctionReference } from "../server/api.js";
-
-const address = "https://127.0.0.1:3001";
-
-const testConvexReactClient = () =>
-  new ConvexReactClient(address, {
-    webSocketConstructor: ws as unknown as typeof WebSocket,
-  });
-
-describe("ConvexReactClient", () => {
-  test("can be constructed", () => {
-    const client = testConvexReactClient();
-    expect(typeof client).not.toEqual("undefined");
-  });
-});
-describe("createMutation", () => {
-  test("Optimistic updates can be created", () => {
-    const client = testConvexReactClient();
-    createMutation(anyApi.myMutation.default, client).withOptimisticUpdate(
-      () => {
-        // no update
-      },
-    );
-  });
-
-  test("Specifying an optimistic update twice produces an error", () => {
-    const client = testConvexReactClient();
-    const mutation = createMutation(
-      anyApi.myMutation.default,
-      client,
-    ).withOptimisticUpdate(() => {
-      // no update
-    });
-    expect(() => {
-      mutation.withOptimisticUpdate(() => {
-        // no update
-      });
-    }).toThrow("Already specified optimistic update for mutation myMutation");
-  });
-
-  test("Using a mutation as an event handler directly throws a useful error", () => {
-    const client = testConvexReactClient();
-
-    const fakeSyntheticEvent: any = {
-      bubbles: false,
-      cancelable: true,
-      defaultPrevented: false,
-      isTrusted: false,
-      nativeEvent: {},
-      preventDefault: () => undefined,
-      isDefaultPrevented: false,
-      stopPropagation: () => undefined,
-      isPropagationStopped: false,
-      persist: () => undefined,
-      timeStamp: 0,
-      type: "something",
-    };
-    const myMutation = createMutation(anyApi.myMutation.default, client);
-    expect(() => myMutation(fakeSyntheticEvent)).toThrow(
-      "Convex function called with SyntheticEvent object.",
-    );
-  });
-});
-
-describe("useQuery", () => {
-  function createClientWithQuery() {
-    const client = testConvexReactClient();
-    // 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, {}, "queryResult");
-        },
-      },
-    );
-    return client;
-  }
-
-  test("returns the result", () => {
-    const client = createClientWithQuery();
-    const wrapper = ({ children }: any) => (
-      <ConvexProvider client={client}>{children}</ConvexProvider>
-    );
-    const { result } = renderHook(() => useQuery(anyApi.myQuery.default), {
-      wrapper,
-    });
-    expect(result.current).toStrictEqual("queryResult");
-  });
-
-  test("returns undefined when skipped", () => {
-    const client = createClientWithQuery();
-    const wrapper = ({ children }: any) => (
-      <ConvexProvider client={client}>{children}</ConvexProvider>
-    );
-    const { result } = renderHook(
-      () => useQuery(anyApi.myQuery.default, "skip"),
-      {
-        wrapper,
-      },
-    );
-    expect(result.current).toStrictEqual(undefined);
-  });
-
-  test("useQuery_experimental object form returns success result", () => {
-    const client = createClientWithQuery();
-    const wrapper = ({ children }: any) => (
-      <ConvexProvider client={client}>{children}</ConvexProvider>
-    );
-    const { result } = renderHook(
-      () =>
-        useQuery_experimental({
-          query: anyApi.myQuery.default,
-          args: {},
-        }),
-      { wrapper },
-    );
-    expect(result.current).toStrictEqual({
-      data: "queryResult",
-      status: "success",
-    });
-  });
-
-  test("useQuery_experimental object form returns pending when skipped", () => {
-    const client = createClientWithQuery();
-    const wrapper = ({ children }: any) => (
-      <ConvexProvider client={client}>{children}</ConvexProvider>
-    );
-    const { result } = renderHook(
-      () =>
-        useQuery_experimental({
-          query: anyApi.myQuery.default,
-          args: "skip",
-        }),
-      { wrapper },
-    );
-    expect(result.current).toStrictEqual({
-      status: "pending",
-    });
-  });
-
-  test("Optimistic update handlers can’t be async", () => {
-    const client = testConvexReactClient();
-    const mutation = createMutation(
-      anyApi.myMutation.default,
-      client,
-      // @ts-expect-error
-    ).withOptimisticUpdate(async () => {});
-
-    // Calling the mutation should warn in the console
-    const consoleWarnSpy = vi.spyOn(console, "warn");
-    void mutation();
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "Optimistic update handler returned a Promise. Optimistic updates should be synchronous.",
-    );
-  });
-});
-
-// Intentionally disabled because we're only testing types
-describe.skip("useQuery typing", () => {
-  test("useQuery with no args query", () => {
-    const queryWithNoArgs = makeFunctionReference<
-      "query",
-      Record<string, never>
-    >("foo");
-    useQuery(queryWithNoArgs, {});
-    // @ts-expect-error This should be an error
-    useQuery(queryWithNoArgs, { x: 3 });
-    useQuery(queryWithNoArgs, "skip");
-    const x: number | null = null;
-    useQuery(queryWithNoArgs, x === null ? "skip" : {});
-    // This should be an error, but isn't :(, probably a bug in TypeScript
-    useQuery(queryWithNoArgs, x === null ? "skip" : { x });
-    // @ts-expect-error This should be an error
-    useQuery(queryWithNoArgs, x === null ? "skip" : { x: 3 });
-  });
-
-  test("useQuery with query taking args", () => {
-    const queryWithArgs = makeFunctionReference<"query", { x: number }>("foo");
-    // @ts-expect-error This should be an error
-    useQuery(queryWithArgs);
-    // @ts-expect-error This should be an error
-    useQuery(queryWithArgs, { x: "not a number" });
-    useQuery(queryWithArgs, { x: 42 });
-    useQuery(queryWithArgs, "skip");
-    const x: number | null = null;
-    useQuery(queryWithArgs, x === null ? "skip" : { x });
-    // @ts-expect-error This should be an error
-    useQuery(queryWithArgs, x === null ? null : { x: "not a number" });
-  });
-});
-
-describe("async query fetch", () => {
-  const client = testConvexReactClient();
-
-  function optimisticUpdate() {
-    // 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, {}, "queryResult");
-        },
-      },
-    );
-  }
-
-  test("returns after optimistic update", async () => {
-    const queryResult = client.query(anyApi.myQuery.default, {});
-    optimisticUpdate();
-    expect(await queryResult).toStrictEqual("queryResult");
-  });
-
-  test("returns existing result", async () => {
-    optimisticUpdate();
-    const queryResult = client.query(anyApi.myQuery.default, {});
-    expect(await queryResult).toStrictEqual("queryResult");
-  });
-});
-
-describe("prewarmQuery types", () => {
-  test("accepts QueryOptions shape", () => {
-    const client = testConvexReactClient();
-    const opts = convexQueryOptions({
-      query: makeFunctionReference<"query", { name: string }, string>(
-        "myQuery",
-      ),
-      args: { name: "hi" },
-    });
-    client.prewarmQuery(opts);
-  });
-
-  test("accepts extendSubscriptionFor on prewarmQuery", () => {
-    const client = testConvexReactClient();
-    client.prewarmQuery({
-      query: makeFunctionReference<"query", { name: string }, string>(
-        "myQuery",
-      ),
-      args: { name: "hi" },
-      extendSubscriptionFor: 10_000,
-    });
-  });
-});

package/src/react/client_provided_base_client.test.tsx

@@ -1,174 +0,0 @@
-import { test, expect, describe, vi } from "vitest";
-import ws from "ws";
-
-import { ConvexReactClient } from "./client.js";
-import { anyApi } from "../server/api.js";
-import { BaseConvexClient } from "../browser/index.js";
-import { BaseConvexClientInterface } from "../browser/sync/client.js";
-
-const address = "https://127.0.0.1:3001";
-
-describe("Creating a ConvexReactClient with a custom base client", () => {
-  describe("with a `BaseConvexClient` subclass", () => {
-    // A minimal subclass of `BaseConvexClient` used to prove that a
-    // caller-provided `BaseConvexClient` (of any subclass) can be plugged into
-    // a `ConvexReactClient` via the `client` option.
-    class MinimalBaseConvexClient extends BaseConvexClient {}
-
-    const testBaseConvexClient = () =>
-      new MinimalBaseConvexClient(address, () => {}, {
-        webSocketConstructor: ws as unknown as typeof WebSocket,
-      });
-
-    test("uses the provided client as its `sync` client", () => {
-      const baseClient = testBaseConvexClient();
-      const client = new ConvexReactClient(address, { baseClient });
-      expect(client.sync).toBe(baseClient);
-    });
-
-    test("applies setAdminAuth called before the client is lazily instantiated", () => {
-      const baseClient = testBaseConvexClient();
-      const setAdminAuthSpy = vi.spyOn(baseClient, "setAdminAuth");
-      const client = new ConvexReactClient(address, { baseClient });
-      client.setAdminAuth("admin-token");
-      expect(setAdminAuthSpy).not.toHaveBeenCalled();
-
-      // Accessing `sync` lazily instantiates the client, applying admin auth.
-      expect(client.sync).toBe(baseClient);
-      expect(setAdminAuthSpy).toHaveBeenCalledWith("admin-token", undefined);
-    });
-
-    test("queries and mutations work through the provided client", async () => {
-      const baseClient = testBaseConvexClient();
-      const client = new ConvexReactClient(address, { baseClient });
-
-      void client.mutation(
-        anyApi.myMutation.default,
-        {},
-        {
-          optimisticUpdate: (localStore) => {
-            localStore.setQuery(anyApi.myQuery.default, {}, "queryResult");
-          },
-        },
-      );
-
-      const queryResult = client.query(anyApi.myQuery.default, {});
-      expect(await queryResult).toStrictEqual("queryResult");
-    });
-  });
-
-  describe("with a from-scratch BaseConvexClientInterface implementation", () => {
-    // A from-scratch (non-subclass) implementation of `BaseConvexClientInterface`.
-    // Unlike `MinimalBaseConvexClient` above, this does not extend
-    // `BaseConvexClient`, so TypeScript forces every public member to be
-    // declared here explicitly — if `BaseConvexClientInterface` ever gains a member,
-    // this class fails to compile until a matching forwarding method is added.
-    class ComposedBaseConvexClient implements BaseConvexClientInterface {
-      private inner: BaseConvexClient;
-
-      constructor(...args: ConstructorParameters<typeof BaseConvexClient>) {
-        this.inner = new BaseConvexClient(...args);
-      }
-
-      addOnTransitionHandler(
-        ...args: Parameters<BaseConvexClient["addOnTransitionHandler"]>
-      ) {
-        return this.inner.addOnTransitionHandler(...args);
-      }
-      setAuth(...args: Parameters<BaseConvexClient["setAuth"]>) {
-        return this.inner.setAuth(...args);
-      }
-      setAdminAuth(...args: Parameters<BaseConvexClient["setAdminAuth"]>) {
-        return this.inner.setAdminAuth(...args);
-      }
-      clearAuth() {
-        return this.inner.clearAuth();
-      }
-      subscribe(...args: Parameters<BaseConvexClient["subscribe"]>) {
-        return this.inner.subscribe(...args);
-      }
-      localQueryResult(
-        ...args: Parameters<BaseConvexClient["localQueryResult"]>
-      ) {
-        return this.inner.localQueryResult(...args);
-      }
-      localQueryResultByToken(
-        ...args: Parameters<BaseConvexClient["localQueryResultByToken"]>
-      ) {
-        return this.inner.localQueryResultByToken(...args);
-      }
-      hasLocalQueryResultByToken(
-        ...args: Parameters<BaseConvexClient["hasLocalQueryResultByToken"]>
-      ) {
-        return this.inner.hasLocalQueryResultByToken(...args);
-      }
-      localQueryLogs(...args: Parameters<BaseConvexClient["localQueryLogs"]>) {
-        return this.inner.localQueryLogs(...args);
-      }
-      queryJournal(...args: Parameters<BaseConvexClient["queryJournal"]>) {
-        return this.inner.queryJournal(...args);
-      }
-      connectionState() {
-        return this.inner.connectionState();
-      }
-      subscribeToConnectionState(
-        ...args: Parameters<BaseConvexClient["subscribeToConnectionState"]>
-      ) {
-        return this.inner.subscribeToConnectionState(...args);
-      }
-      mutation(...args: Parameters<BaseConvexClient["mutation"]>) {
-        return this.inner.mutation(...args);
-      }
-      action(...args: Parameters<BaseConvexClient["action"]>) {
-        return this.inner.action(...args);
-      }
-      close() {
-        return this.inner.close();
-      }
-      get url() {
-        return this.inner.url;
-      }
-    }
-
-    const testBaseConvexClient = () =>
-      new ComposedBaseConvexClient(address, () => {}, {
-        webSocketConstructor: ws as unknown as typeof WebSocket,
-      });
-
-    test("uses the provided client as its `sync` client", () => {
-      const baseClient = testBaseConvexClient();
-      const client = new ConvexReactClient(address, { baseClient });
-      expect(client.sync).toBe(baseClient);
-    });
-
-    test("applies setAdminAuth called before the client is lazily instantiated", () => {
-      const baseClient = testBaseConvexClient();
-      const setAdminAuthSpy = vi.spyOn(baseClient, "setAdminAuth");
-      const client = new ConvexReactClient(address, { baseClient });
-      client.setAdminAuth("admin-token");
-      expect(setAdminAuthSpy).not.toHaveBeenCalled();
-
-      // Accessing `sync` lazily instantiates the client, applying admin auth.
-      expect(client.sync).toBe(baseClient);
-      expect(setAdminAuthSpy).toHaveBeenCalledWith("admin-token", undefined);
-    });
-
-    test("queries and mutations work through the provided client", async () => {
-      const baseClient = testBaseConvexClient();
-      const client = new ConvexReactClient(address, { baseClient });
-
-      void client.mutation(
-        anyApi.myMutation.default,
-        {},
-        {
-          optimisticUpdate: (localStore) => {
-            localStore.setQuery(anyApi.myQuery.default, {}, "queryResult");
-          },
-        },
-      );
-
-      const queryResult = client.query(anyApi.myQuery.default, {});
-      expect(await queryResult).toStrictEqual("queryResult");
-    });
-  });
-});

package/src/react/queries_observer.test.ts

@@ -1,176 +0,0 @@
-import { Value } from "../values/index.js";
-import {
-  test,
-  beforeEach,
-  afterEach,
-  expect,
-  vi,
-  MockedFunction,
-} from "vitest";
-import FakeWatch from "../test/fake_watch.js";
-import { QueriesObserver } from "./queries_observer.js";
-import { FunctionReference, anyApi } from "../server/api.js";
-
-let queriesObserver: QueriesObserver;
-let createWatch: MockedFunction<
-  (
-    query: FunctionReference<"query">,
-    args: Record<string, Value>,
-  ) => FakeWatch<any>
->;
-let listener: MockedFunction<() => void>;
-
-beforeEach(() => {
-  createWatch = vi.fn(() => new FakeWatch<any>()) as any;
-  queriesObserver = new QueriesObserver(createWatch);
-  listener = vi.fn() as any;
-  queriesObserver.subscribe(listener);
-});
-
-afterEach(() => {
-  queriesObserver.destroy();
-});
-
-test("`getLocalResults`", () => {
-  const queries = {
-    query: {
-      query: anyApi.myQuery.default,
-      args: {},
-    },
-  };
-  queriesObserver.setQueries(queries);
-  expect(queriesObserver.getLocalResults(queries)).toStrictEqual({
-    query: undefined,
-  });
-  // The listener isn't notified for our own changes.
-  expect(listener.mock.calls.length).toBe(0);
-
-  // If we update the value of the query, the listener is notified and the
-  // local results include the update.
-  createWatch.mock.results[0].value.setValue("query value");
-  expect(listener.mock.calls.length).toBe(1);
-  createWatch.mockImplementation(() => {
-    const watch = new FakeWatch<any>();
-    watch.value = "query value";
-    return watch;
-  });
-  expect(queriesObserver.getLocalResults(queries)).toStrictEqual({
-    query: "query value",
-  });
-});
-
-test("If the query changes, only stay subscribed to the second query", () => {
-  queriesObserver.setQueries({
-    query: {
-      query: anyApi.myQuery.default,
-      args: {},
-    },
-  });
-
-  queriesObserver.setQueries({
-    query: {
-      query: anyApi.myQuery2.default,
-      args: {},
-    },
-  });
-
-  // The listener isn't notified for our own changes.
-  expect(listener.mock.calls.length).toBe(0);
-
-  // There were 2 watches created. We should be subscribed to only the second.
-  expect(createWatch.mock.calls.length).toBe(2);
-  expect(createWatch.mock.results[0].value.numCallbacks()).toBe(0);
-  expect(createWatch.mock.results[1].value.numCallbacks()).toBe(1);
-});
-
-test("If the query args change, only stay subscribed to the second args", () => {
-  queriesObserver.setQueries({
-    query: {
-      query: anyApi.myQuery.default,
-      args: { arg: "first arg" },
-    },
-  });
-
-  queriesObserver.setQueries({
-    query: {
-      query: anyApi.myQuery.default,
-      args: { arg: "new arg" },
-    },
-  });
-
-  // The listener isn't notified for our own changes.
-  expect(listener.mock.calls.length).toBe(0);
-
-  // There were 2 watches created. We should be subscribed to only the second.
-  expect(createWatch.mock.calls.length).toBe(2);
-  expect(createWatch.mock.results[0].value.numCallbacks()).toBe(0);
-  expect(createWatch.mock.results[1].value.numCallbacks()).toBe(1);
-});
-
-test("If the query doesn't change, we only have one subscription", () => {
-  queriesObserver.setQueries({
-    query: {
-      query: anyApi.myQuery.default,
-      args: { arg1: "arg1", arg2: 1, arg3: {} },
-    },
-  });
-  expect(createWatch.mock.calls.length).toBe(1);
-  expect(createWatch.mock.results[0].value.numCallbacks()).toBe(1);
-
-  // Re-adding the same query doesn't create a new watch.
-  queriesObserver.setQueries({
-    query: {
-      query: anyApi.myQuery.default,
-      args: { arg1: "arg1", arg2: 1, arg3: {} },
-    },
-  });
-  expect(createWatch.mock.calls.length).toBe(1);
-  expect(createWatch.mock.results[0].value.numCallbacks()).toBe(1);
-});
-
-test("destroy unsubscribes from all queries", async () => {
-  queriesObserver.setQueries({
-    query: {
-      query: anyApi.myQuery.default,
-      args: {},
-    },
-  });
-
-  queriesObserver.destroy();
-
-  // No subscriptions to the watch now.
-  expect(createWatch.mock.calls.length).toBe(1);
-  expect(createWatch.mock.results[0].value.numCallbacks()).toBe(0);
-});
-
-test("swapping createWatch recreates subscriptions", async () => {
-  queriesObserver.setQueries({
-    query: {
-      query: anyApi.myQuery.default,
-      args: {},
-    },
-  });
-  // We should have a listen for the query.
-  expect(createWatch.mock.calls.length).toBe(1);
-  expect(createWatch.mock.results[0].value.numCallbacks()).toBe(1);
-  // Pretend that the server sent us a query journal
-  createWatch.mock.results[0].value.setJournal("query journal");
-
-  // Swap out the `createWatch` function.
-  const createWatch2 = vi.fn(() => new FakeWatch<any>()) as any;
-  queriesObserver.setCreateWatch(createWatch2);
-
-  // No subscriptions left for the original watch.
-  expect(createWatch.mock.calls.length).toBe(1);
-  expect(createWatch.mock.results[0].value.numCallbacks()).toBe(0);
-
-  // Now there is a sub using the new createWatch function and the
-  // journal was passed through!
-  expect(createWatch2.mock.calls.length).toBe(1);
-  expect(createWatch2.mock.results[0].value.numCallbacks()).toBe(1);
-  expect(createWatch2.mock.calls[0]).toEqual([
-    anyApi.myQuery.default,
-    {},
-    { journal: "query journal" },
-  ]);
-});

package/src/react/react_node.test.ts

@@ -1,78 +0,0 @@
-import { test, expect } from "vitest";
-import { Long } from "../vendor/long.js";
-
-import { ConvexReactClient } from "./client.js";
-import {
-  ClientMessage,
-  QuerySetModification,
-  WireServerMessage,
-} from "../browser/sync/protocol.js";
-import {
-  nodeWebSocket,
-  withInMemoryWebSocket,
-} from "../browser/sync/client_node_test_helpers.js";
-import { anyApi } from "../server/api.js";
-
-const testReactClient = (address: string) =>
-  new ConvexReactClient(address, {
-    webSocketConstructor: nodeWebSocket,
-    unsavedChangesWarning: false,
-  });
-
-test("ConvexReactClient ends subscriptions on close", async () => {
-  await withInMemoryWebSocket(async ({ address, receive, send }) => {
-    const client = testReactClient(address);
-    const watch = client.watchQuery(anyApi.myQuery.default, {});
-    let timesCallbackRan = 0;
-    watch.onUpdate(() => timesCallbackRan++);
-
-    expect((await receive()).type).toEqual("Connect");
-    const modify = expectQuerySetModification(await receive());
-    expect(modify.modifications).toEqual([
-      {
-        args: [{}],
-        queryId: 0,
-        type: "Add",
-        udfPath: "myQuery:default",
-      },
-    ]);
-    expect(timesCallbackRan).toEqual(0);
-
-    send(transition());
-
-    // After the callback has been registered but before the callback has been
-    // run, close the client.
-    const closePromise = client.close();
-
-    expect(timesCallbackRan).toEqual(0);
-
-    // After the internal client has closed, same nothing.
-    await closePromise;
-    expect(timesCallbackRan).toEqual(0);
-  });
-});
-
-const expectQuerySetModification = (
-  message: ClientMessage,
-): QuerySetModification => {
-  expect(message.type).toEqual("ModifyQuerySet");
-  if (message.type !== "ModifyQuerySet") throw new Error("Wrong message!");
-  return message;
-};
-
-function transition(): WireServerMessage {
-  return {
-    type: "Transition",
-    startVersion: { querySet: 0, identity: 0, ts: Long.fromNumber(0) },
-    endVersion: { querySet: 1, identity: 0, ts: Long.fromNumber(1) },
-    modifications: [
-      {
-        type: "QueryUpdated",
-        queryId: 0,
-        value: 0.0,
-        logLines: [],
-        journal: null,
-      },
-    ],
-  };
-}