convex 1.44.0 → 1.45.0

package/src/browser/sync/client_node_test_helpers.ts

@@ -1,200 +0,0 @@
-import { Base64 } from "../../values/index.js";
-import { Long } from "../../vendor/long.js";
-
-// --experimental-vm-modules which we use for jest doesn't support named exports
-import WebSocket, { WebSocketServer } from "ws";
-
-// Let's pretend this ws WebSocket is a browser WebSocket (it's very close)
-export const nodeWebSocket = WebSocket as unknown as typeof window.WebSocket;
-
-import { ClientMessage, WireServerMessage } from "./protocol.js";
-import {
-  PaginatedQueryToken,
-  QueryToken,
-  serializedQueryTokenIsPaginated,
-} from "./udf_path_utils.js";
-import { BaseConvexClient } from "./client.js";
-import { PaginatedQueryClient } from "./paginated_query_client.js";
-
-export type InMemoryWebSocketTest = (args: {
-  address: string;
-  socket: () => WebSocket;
-  receive: () => Promise<ClientMessage>;
-  send: (message: WireServerMessage) => void;
-  close: () => void;
-}) => Promise<void>;
-
-function listeningSocketServer(): Promise<WebSocketServer> {
-  return new Promise((resolve) => {
-    const wss = new WebSocketServer({ port: 0 });
-    wss.on("listening", () => resolve(wss));
-  });
-}
-
-// Run a test with a real node WebSocket instance connected
-export async function withInMemoryWebSocket(
-  cb: InMemoryWebSocketTest,
-  debug = false,
-) {
-  // These state variables are consistent over multiple sockets.
-  let received: (msg: string) => void;
-  // prettier-ignore
-  const messages: Promise<string>[] = [ new Promise((r) => { received = r; }) ];
-  let socket: WebSocket | null = null;
-
-  const wss = await listeningSocketServer();
-
-  const setUpSocket = () => {
-    wss.once("connection", function connection(ws: WebSocket) {
-      socket = ws;
-      ws.on("message", function message(data: string) {
-        received(data);
-        // eslint-disable-next-line no-console
-        if (debug) console.debug(`client --${JSON.parse(data).type}--> `);
-        messages.push(
-          new Promise((r) => {
-            received = r;
-          }),
-        );
-      });
-    });
-  };
-  setUpSocket();
-
-  // receive and send are stable across multiple socket connections
-  async function receive(): Promise<ClientMessage> {
-    const msgP = messages.shift();
-    if (!msgP) {
-      throw new Error("Receive() called twice? No message promise found.");
-    }
-    const text = await msgP;
-    const structured = JSON.parse(text);
-    return structured;
-  }
-  function send(message: WireServerMessage) {
-    // eslint-disable-next-line no-console
-    if (debug) console.debug(`      <--${message.type}-- server`);
-    socket!.send(encodeServerMessage(message));
-  }
-
-  const s: any = wss.address();
-  const address = typeof s === "string" ? s : `http://127.0.0.1:${s.port}`;
-
-  try {
-    await cb({
-      address,
-      socket: () => socket as unknown as WebSocket,
-      receive,
-      send,
-      close: () => {
-        // eslint-disable-next-line no-console
-        if (debug) console.debug(`           --CLOSE-->8-- server`);
-        socket!.close();
-        setUpSocket();
-      },
-    });
-  } finally {
-    const s = socket!;
-    if (s!) {
-      socket!.close();
-    }
-    wss.close();
-  }
-}
-
-export function encodeServerMessage(message: WireServerMessage): string {
-  function replacer(_key: string, value: any) {
-    if (Long.isLong(value)) {
-      return encodeLong(value);
-    }
-    return value;
-  }
-  return JSON.stringify(message, replacer);
-}
-
-function encodeLong(n: Long) {
-  const integerBytes = Uint8Array.from(n.toBytesLE());
-  return Base64.fromByteArray(integerBytes);
-}
-
-/**
- * const q = new UpdateQueue();
- * const client = new BaseConvexClient(address, queryTokens => { q.onTransition(client)(queryTokens) });
- *
- * await q.updatePromises[3];
- *
- */
-export class UpdateQueue {
-  updateResolves: ((v: Record<QueryToken, any>) => void)[];
-  updatePromises: Promise<Record<QueryToken, any>>[];
-  updates: Record<QueryToken, any>[];
-  allResults: Record<QueryToken, any>;
-  nextIndex: number;
-
-  constructor(maxLength = 10) {
-    this.updateResolves = [];
-    this.updatePromises = [];
-    this.allResults = {};
-    this.updates = [];
-    this.nextIndex = 0;
-
-    let nextResolve: (v: Record<QueryToken, any>) => void;
-    let nextPromise: Promise<Record<QueryToken, any>>;
-
-    for (let i = 0; i < maxLength; i++) {
-      nextPromise = new Promise((r) => {
-        nextResolve = r;
-      });
-      this.updateResolves.push(nextResolve!);
-      this.updatePromises.push(nextPromise);
-    }
-  }
-
-  /**
-   * Useful to use instead of directly awaiting so that the timeout has a line number
-   * unlike the default Vite test timeout.
-   */
-  async awaitPromiseAtIndexWithTimeout(
-    i: number,
-  ): Promise<Record<QueryToken | PaginatedQueryToken, any>> {
-    if (!this.updatePromises[i]) {
-      throw new Error("That promise doesn't exist yet");
-    }
-    const inBandSignal = "UpdateQueue await timed out";
-    const result = await Promise.race([
-      new Promise((r) => setTimeout(() => r(inBandSignal), 1000)),
-      this.updatePromises[i],
-    ]);
-    if (result === inBandSignal) {
-      throw new Error("Awaiting promise in UpdateQueue");
-    }
-    // cast from the updatePromises where this was any, but know it's unknown
-    return result as any;
-  }
-
-  onTransition =
-    (client: BaseConvexClient, paginatedClient?: PaginatedQueryClient) =>
-    (updatedQueryTokens: (QueryToken | PaginatedQueryToken)[]) => {
-      const update: Record<QueryToken, any> = {};
-      for (const queryToken of updatedQueryTokens) {
-        if (serializedQueryTokenIsPaginated(queryToken)) {
-          if (!paginatedClient) {
-            throw new Error(
-              "No PaginatedQueryClient provided to look up value for token " +
-                queryToken,
-            );
-          }
-          const value = paginatedClient?.localQueryResultByToken(queryToken);
-          update[queryToken] = value;
-          this.allResults[queryToken] = value;
-        } else {
-          const value = client.localQueryResultByToken(queryToken);
-          update[queryToken] = value;
-          this.allResults[queryToken] = value;
-        }
-      }
-      this.updateResolves[this.nextIndex](update);
-      this.updates.push(update);
-      this.nextIndex++;
-    };
-}

package/src/browser/sync/local_state.test.ts

@@ -1,128 +0,0 @@
-import { test, expect } from "vitest";
-import { Long } from "../../vendor/long.js";
-
-import { LocalSyncState } from "./local_state.js";
-
-test("can create a local state", () => {
-  new LocalSyncState();
-});
-
-test("has outstanding state older than restart", () => {
-  const state = new LocalSyncState();
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Restarting w/o outstanding queries
-  state.restart();
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Do two subscriptions.
-  state.subscribe("hello:world1", {});
-  state.subscribe("hello:world2", {});
-  const queryId1 = state.queryId("hello:world1", {})!;
-  const queryId2 = state.queryId("hello:world2", {})!;
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Restart before we get results. This should flip synced to false.
-  state.restart();
-  expect(state.hasSyncedPastLastReconnect()).toBe(false);
-
-  // If we provide partial results, then synced should remain false
-  state.transition({
-    type: "Transition",
-    startVersion: {
-      querySet: 0,
-      ts: Long.fromNumber(500),
-      identity: 0,
-    },
-    endVersion: {
-      querySet: 0,
-      ts: Long.fromNumber(1000),
-      identity: 0,
-    },
-    modifications: [
-      {
-        type: "QueryUpdated",
-        queryId: queryId1,
-        value: "hi",
-        logLines: [],
-        journal: null,
-      },
-    ],
-  });
-  expect(state.hasSyncedPastLastReconnect()).toBe(false);
-
-  // If we provide full results, then synced should go true
-  state.transition({
-    type: "Transition",
-    startVersion: {
-      querySet: 0,
-      ts: Long.fromNumber(1000),
-      identity: 0,
-    },
-    endVersion: {
-      querySet: 0,
-      ts: Long.fromNumber(1500),
-      identity: 0,
-    },
-    modifications: [
-      {
-        type: "QueryUpdated",
-        queryId: queryId2,
-        value: "hi",
-        logLines: [],
-        journal: null,
-      },
-    ],
-  });
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-});
-
-test("unsubscribe resets outstanding state older than restart", () => {
-  const state = new LocalSyncState();
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Do one subscription.
-  const sub1 = state.subscribe("hello:world", {});
-
-  // Restart before we get results. This should flip synced to false.
-  state.restart();
-  expect(state.hasSyncedPastLastReconnect()).toBe(false);
-
-  // Unsubscribe. This should flip synced back to true, even before getting result.
-  sub1.unsubscribe();
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-});
-
-test("complete auth resets outstanding state older than restart", () => {
-  const state = new LocalSyncState();
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Set auth
-  state.setAuth("auth123");
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Restart before we get results. This should flip synced to false.
-  state.restart();
-  expect(state.hasSyncedPastLastReconnect()).toBe(false);
-
-  // Mark auth completion
-  state.markAuthCompletion();
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-});
-
-test("cleared auth resets outstanding state older than restart", () => {
-  const state = new LocalSyncState();
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Set auth
-  state.setAuth("auth123");
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-
-  // Restart before we get results. This should flip synced to false.
-  state.restart();
-  expect(state.hasSyncedPastLastReconnect()).toBe(false);
-
-  // Mark auth cleared
-  state.clearAuth();
-  expect(state.hasSyncedPastLastReconnect()).toBe(true);
-});

package/src/browser/sync/optimistic_query_set.test.ts

@@ -1,253 +0,0 @@
-import { Value } from "../../values/index.js";
-import { test, expect, beforeEach } from "vitest";
-
-import {
-  OptimisticQueryResults,
-  QueryResultsMap,
-} from "./optimistic_updates_impl.js";
-import { serializePathAndArgs } from "./udf_path_utils.js";
-import { FunctionResult } from "./function_result.js";
-import { anyApi } from "../../server/api.js";
-
-let optimisticQuerySet: OptimisticQueryResults;
-beforeEach(() => {
-  optimisticQuerySet = new OptimisticQueryResults();
-});
-
-function success(value: Value): FunctionResult {
-  return { success: true, value, logLines: [] };
-}
-
-test("server results are returned back if no optimistic updates exist", () => {
-  const queryToken1 = serializePathAndArgs("query1", {});
-  const queryToken2 = serializePathAndArgs("query2", {});
-  const queryResults: QueryResultsMap = new Map([
-    [
-      queryToken1,
-      {
-        result: success("query1 result"),
-        udfPath: "query1",
-        args: {},
-      },
-    ],
-    [
-      queryToken2,
-      {
-        result: success("query2 result"),
-        udfPath: "query2",
-        args: {},
-      },
-    ],
-  ]);
-  const changedQueries = optimisticQuerySet.ingestQueryResultsFromServer(
-    queryResults,
-    new Set(),
-  );
-
-  expect(changedQueries).toEqual([queryToken1, queryToken2]);
-  expect(optimisticQuerySet.queryResult(queryToken1)).toEqual("query1 result");
-  expect(optimisticQuerySet.queryResult(queryToken2)).toEqual("query2 result");
-});
-
-test("errors are thrown if we receive an error from the server", () => {
-  const queryToken = serializePathAndArgs("query", {});
-  const serverQueryResults: QueryResultsMap = new Map([
-    [
-      queryToken,
-      {
-        result: {
-          success: false,
-          errorMessage: "Server Error",
-          logLines: [],
-        },
-        udfPath: "query",
-        args: {},
-      },
-    ],
-  ]);
-  const changedQueries = optimisticQuerySet.ingestQueryResultsFromServer(
-    serverQueryResults,
-    new Set(),
-  );
-  expect(changedQueries).toEqual([queryToken]);
-  expect(() => optimisticQuerySet.queryResult(queryToken)).toThrow(
-    "[CONVEX Q(query)] Server Error",
-  );
-});
-
-test("optimistic updates edit query results", () => {
-  const queryToken = serializePathAndArgs("query", {});
-  function createQueryResults(value: number): QueryResultsMap {
-    return new Map([
-      [
-        queryToken,
-        {
-          result: success(value),
-          udfPath: "query",
-          args: {},
-        },
-      ],
-    ]);
-  }
-
-  // Add a query to our store
-  const changedQueries = optimisticQuerySet.ingestQueryResultsFromServer(
-    createQueryResults(100),
-    new Set(),
-  );
-  expect(changedQueries).toEqual([queryToken]);
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(100);
-
-  // Edit the query with an optimistic update and confirm it ran.
-  const changedQueries2 = optimisticQuerySet.applyOptimisticUpdate(
-    (localStore) => {
-      const oldResult = localStore.getQuery(anyApi.query.default, {});
-      localStore.setQuery(anyApi.query.default, {}, oldResult + 1);
-    },
-    0,
-  );
-  expect(changedQueries2).toEqual([queryToken]);
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(101);
-
-  // If we receive a new query result while the update is in place, the update is
-  // replayed on top.
-  const changedQueries3 = optimisticQuerySet.ingestQueryResultsFromServer(
-    createQueryResults(200),
-    new Set(),
-  );
-  expect(changedQueries3).toEqual([queryToken]);
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(201);
-
-  // The update can be dropped
-  const changedQueries4 = optimisticQuerySet.ingestQueryResultsFromServer(
-    createQueryResults(300),
-    new Set([0]),
-  );
-  expect(changedQueries4).toEqual([queryToken]);
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(300);
-});
-
-test("optimistic updates only notify changed queries", () => {
-  // Set up 2 queries
-  const queryToken1 = serializePathAndArgs("query1", {});
-  const queryToken2 = serializePathAndArgs("query2", {});
-  const queryResults: QueryResultsMap = new Map([
-    [
-      queryToken1,
-      {
-        result: success("query1 result"),
-        udfPath: "query1",
-        args: {},
-      },
-    ],
-    [
-      queryToken2,
-      {
-        result: success("query2 result"),
-        udfPath: "query2",
-        args: {},
-      },
-    ],
-  ]);
-  const changedQueries = optimisticQuerySet.ingestQueryResultsFromServer(
-    queryResults,
-    new Set(),
-  );
-  // Confirm they were both added
-  expect(changedQueries).toEqual([queryToken1, queryToken2]);
-  expect(optimisticQuerySet.queryResult(queryToken1)).toEqual("query1 result");
-  expect(optimisticQuerySet.queryResult(queryToken2)).toEqual("query2 result");
-
-  // Update the first query
-  const changedQueries2 = optimisticQuerySet.applyOptimisticUpdate(
-    (localStore) => {
-      localStore.setQuery(anyApi.query1.default, {}, "new query1 result");
-    },
-    0,
-  );
-
-  // Only the first query changed
-  expect(changedQueries2).toEqual([queryToken1]);
-  expect(optimisticQuerySet.queryResult(queryToken1)).toEqual(
-    "new query1 result",
-  );
-  expect(optimisticQuerySet.queryResult(queryToken2)).toEqual("query2 result");
-});
-
-test("optimistic updates stack", () => {
-  // Start our server query value at 2.
-  const queryToken = serializePathAndArgs("query", {});
-  const serverQueryResults: QueryResultsMap = new Map([
-    [
-      queryToken,
-      {
-        result: success(2),
-        udfPath: "query",
-        args: {},
-      },
-    ],
-  ]);
-  optimisticQuerySet.ingestQueryResultsFromServer(
-    serverQueryResults,
-    new Set(),
-  );
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(2);
-
-  // The first update adds 1.
-  optimisticQuerySet.applyOptimisticUpdate((localStore) => {
-    const oldResult = localStore.getQuery(anyApi.query.default, {});
-    localStore.setQuery(anyApi.query.default, {}, oldResult + 1);
-  }, 0);
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(3);
-
-  // The second update multiplies by 2.
-  optimisticQuerySet.applyOptimisticUpdate((localStore) => {
-    const oldResult = localStore.getQuery(anyApi.query.default, {});
-    localStore.setQuery(anyApi.query.default, {}, oldResult * 2);
-  }, 1);
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(6);
-
-  // Drop the first update. Now we're just multiplying by 2.
-  optimisticQuerySet.ingestQueryResultsFromServer(
-    serverQueryResults,
-    new Set([0]),
-  );
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(4);
-  // Drop the second update. We're back to the start
-  optimisticQuerySet.ingestQueryResultsFromServer(
-    serverQueryResults,
-    new Set([1]),
-  );
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(2);
-});
-
-test("optimistic updates can set query results to undefined", () => {
-  // This is an important use case because we want to allow devs to set queries
-  // to be "loading"
-
-  // set up a query
-  const queryToken = serializePathAndArgs("query", {});
-  const serverQueryResults: QueryResultsMap = new Map([
-    [
-      queryToken,
-      {
-        result: success("query value"),
-        udfPath: "query",
-        args: {},
-      },
-    ],
-  ]);
-  const changedQueries = optimisticQuerySet.ingestQueryResultsFromServer(
-    serverQueryResults,
-    new Set(),
-  );
-  expect(changedQueries).toEqual([queryToken]);
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual("query value");
-
-  // make it undefined
-  optimisticQuerySet.applyOptimisticUpdate((localStore) => {
-    localStore.setQuery(anyApi.query.default, {}, undefined);
-  }, 0);
-  expect(changedQueries).toEqual([queryToken]);
-  expect(optimisticQuerySet.queryResult(queryToken)).toEqual(undefined);
-});