convex 1.42.2-alpha.0 → 1.42.3

package/src/react/client_provided_base_client.test.tsx

@@ -4,53 +4,171 @@ 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";
 
-// 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 {}
+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,
-  });
+    const testBaseConvexClient = () =>
+      new MinimalBaseConvexClient(address, () => {}, {
+        webSocketConstructor: ws as unknown as typeof WebSocket,
+      });
 
-describe("ConvexReactClient with a provided BaseConvexClient", () => {
-  test("uses the provided client as its `sync` client", () => {
-    const baseClient = testBaseConvexClient();
-    const client = new ConvexReactClient(address, { baseClient });
-    expect(client.sync).toBe(baseClient);
-  });
+    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("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();
+    test("queries and mutations work through the provided client", async () => {
+      const baseClient = testBaseConvexClient();
+      const client = new ConvexReactClient(address, { baseClient });
 
-    // Accessing `sync` lazily instantiates the client, applying admin auth.
-    expect(client.sync).toBe(baseClient);
-    expect(setAdminAuthSpy).toHaveBeenCalledWith("admin-token", undefined);
+      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");
+    });
   });
 
-  test("queries and mutations work through the provided client", async () => {
-    const baseClient = testBaseConvexClient();
-    const client = new ConvexReactClient(address, { baseClient });
+  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");
+      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");
+      const queryResult = client.query(anyApi.myQuery.default, {});
+      expect(await queryResult).toStrictEqual("queryResult");
+    });
   });
 });

package/src/server/meta.ts

@@ -84,9 +84,9 @@ export type DeploymentMetadata = {
    */
   region: string | null;
   /**
-   * The deployment class, e.g. `"s16"`, `"s256"`, or `"d1024"`.
+   * The deployment class, e.g. `"s16"`, `"s256"`, `"d1024"`, or `"d2048"`.
    */
-  class: "s16" | "s256" | "d1024";
+  class: "s16" | "s256" | "d1024" | "d2048";
 };
 
 /**
@@ -120,8 +120,6 @@ export type RequestMetadata = {
    *
    * This is the same token that `ctx.auth.getUserIdentity()` derives its
    * attributes from.
-   *
-   * @internal
    */
   authToken: string | null;
 };