convex 1.31.1 → 1.31.3

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 1.31.3
+
+- `CONVEX_AGENT_MODE=anonymous` can now be used while logged in.
+
+- The client will try to reconnect immediately after being offline instead of
+  waiting for the scheduled backoff delay.
+
+- Optimize bundling during code push, and add `includeSourcesContent` option in
+  `convex.json` to configure whether to include source code content in bundled
+  sourcemaps.
+
+## 1.31.2
+
+- Bug fix: the TypeScript types of the new `ctx.db` APIs introduced in 1.31.0
+  incorrectly allowed passing IDs with types broader than the table name
+  argument (e.g. `db.get("table1", id)` where `id` is
+  `Id<"table1"> | Id<"table2">`). This issue is fixed in 1.31.2.
+
+## 1.31.1
+
+- You can now increase the speed of type checking when using `npx convex dev` by
+  enabling the
+  [TypeScript native preview](https://devblogs.microsoft.com/typescript/announcing-typescript-native-previews/)
+  ([TypeScript 7](https://devblogs.microsoft.com/typescript/typescript-native-port/)).
+  To do so, add `@typescript/native-preview` as a dev dependency and
+  [set `typescriptCompiler: "tsGo"` in `convex.json`](https://docs.convex.dev/production/project-configuration#configuring-the-typescript-compiler).
+
 ## 1.31.0
 
 - `db.get`, `db.patch`, `db.replace`, and `db.delete` now accept a table name as

package/dist/browser.bundle.js

@@ -28,7 +28,7 @@ var convex = (() => {
   });
 
   // src/index.ts
-  var version = "1.31.1";
+  var version = "1.31.3";
 
   // src/values/base64.ts
   var base64_exports = {};
@@ -1654,6 +1654,7 @@ var convex = (() => {
       this.onMessage = callbacks.onMessage;
       this.onServerDisconnectError = callbacks.onServerDisconnectError;
       this.logger = logger;
+      this.setupNetworkListener();
       this.connect();
     }
     socket;
@@ -1672,6 +1673,11 @@ var convex = (() => {
      * in ms */
     serverInactivityThreshold;
     reconnectDueToServerInactivityTimeout;
+    /** Scheduled reconnect state: timeout handle and timing info */
+    scheduledReconnect = null;
+    networkOnlineHandler = null;
+    /** Pending event to send after reconnecting due to network recovery */
+    pendingNetworkRecoveryInfo = null;
     uri;
     onOpen;
     onResume;
@@ -1686,6 +1692,27 @@ var convex = (() => {
       );
       this.markConnectionStateDirty();
     }
+    setupNetworkListener() {
+      if (typeof window === "undefined") {
+        return;
+      }
+      if (this.networkOnlineHandler !== null) {
+        return;
+      }
+      this.networkOnlineHandler = () => {
+        this._logVerbose("network online event detected");
+        this.tryReconnectImmediately();
+      };
+      window.addEventListener("online", this.networkOnlineHandler);
+      this._logVerbose("network online event listener registered");
+    }
+    cleanupNetworkListener() {
+      if (this.networkOnlineHandler && typeof window !== "undefined") {
+        window.removeEventListener("online", this.networkOnlineHandler);
+        this.networkOnlineHandler = null;
+        this._logVerbose("network online event listener removed");
+      }
+    }
     assembleTransition(chunk) {
       if (chunk.partNumber < 0 || chunk.partNumber >= chunk.totalParts || chunk.totalParts === 0 || this.transitionChunkBuffer && (this.transitionChunkBuffer.totalParts !== chunk.totalParts || this.transitionChunkBuffer.transitionId !== chunk.transitionId)) {
         this.transitionChunkBuffer = null;
@@ -1769,6 +1796,18 @@ var convex = (() => {
         }
         this.connectionCount += 1;
         this.lastCloseReason = null;
+        if (this.pendingNetworkRecoveryInfo !== null) {
+          const { timeSavedMs } = this.pendingNetworkRecoveryInfo;
+          this.pendingNetworkRecoveryInfo = null;
+          this.sendMessage({
+            type: "Event",
+            eventType: "NetworkRecoveryReconnect",
+            event: { timeSavedMs }
+          });
+          this.logger.log(
+            `Network recovery reconnect saved ~${Math.round(timeSavedMs / 1e3)}s of waiting`
+          );
+        }
       };
       ws.onerror = (error) => {
         this.transitionChunkBuffer = null;
@@ -1892,11 +1931,26 @@ var convex = (() => {
       }, this.serverInactivityThreshold);
     }
     scheduleReconnect(reason) {
+      if (this.scheduledReconnect) {
+        clearTimeout(this.scheduledReconnect.timeout);
+        this.scheduledReconnect = null;
+      }
       this.socket = { state: "disconnected" };
       const backoff = this.nextBackoff(reason);
       this.markConnectionStateDirty();
       this.logger.log(`Attempting reconnect in ${Math.round(backoff)}ms`);
-      setTimeout(() => this.connect(), backoff);
+      const scheduledAt = monotonicMillis();
+      const timeoutId = setTimeout(() => {
+        if (this.scheduledReconnect?.timeout === timeoutId) {
+          this.scheduledReconnect = null;
+          this.connect();
+        }
+      }, backoff);
+      this.scheduledReconnect = {
+        timeout: timeoutId,
+        scheduledAt,
+        backoffMs: backoff
+      };
     }
     /**
      * Close the WebSocket and schedule a reconnect.
@@ -1980,6 +2034,11 @@ var convex = (() => {
       if (this.reconnectDueToServerInactivityTimeout) {
         clearTimeout(this.reconnectDueToServerInactivityTimeout);
       }
+      if (this.scheduledReconnect) {
+        clearTimeout(this.scheduledReconnect.timeout);
+        this.scheduledReconnect = null;
+      }
+      this.cleanupNetworkListener();
       switch (this.socket.state) {
         case "terminated":
         case "stopped":
@@ -2006,6 +2065,7 @@ var convex = (() => {
         case "stopped":
         case "disconnected":
         case "ready": {
+          this.cleanupNetworkListener();
           const result = this.close();
           this.socket = { state: "stopped" };
           return result;
@@ -2034,6 +2094,7 @@ var convex = (() => {
           this.socket;
         }
       }
+      this.setupNetworkListener();
       this.connect();
     }
     pause() {
@@ -2053,6 +2114,34 @@ var convex = (() => {
         }
       }
     }
+    /**
+     * Try to reconnect immediately, canceling any scheduled reconnect.
+     * This is useful when detecting network recovery.
+     * Only takes action if we're in disconnected state (waiting to reconnect).
+     */
+    tryReconnectImmediately() {
+      this._logVerbose("tryReconnectImmediately called");
+      if (this.socket.state !== "disconnected") {
+        this._logVerbose(
+          `tryReconnectImmediately called but socket state is ${this.socket.state}, no action taken`
+        );
+        return;
+      }
+      let timeSavedMs = null;
+      if (this.scheduledReconnect) {
+        const elapsed = monotonicMillis() - this.scheduledReconnect.scheduledAt;
+        timeSavedMs = Math.max(0, this.scheduledReconnect.backoffMs - elapsed);
+        this._logVerbose(
+          `would have waited ${Math.round(timeSavedMs)}ms more (backoff was ${Math.round(this.scheduledReconnect.backoffMs)}ms, elapsed ${Math.round(elapsed)}ms)`
+        );
+        clearTimeout(this.scheduledReconnect.timeout);
+        this.scheduledReconnect = null;
+        this._logVerbose("canceled scheduled reconnect");
+      }
+      this.logger.log("Network recovery detected, reconnecting immediately");
+      this.pendingNetworkRecoveryInfo = timeSavedMs !== null ? { timeSavedMs } : null;
+      this.connect();
+    }
     /**
      * Resume the state machine if previously paused.
      */
@@ -3852,8 +3941,8 @@ var convex = (() => {
       return this.client.hasLocalQueryResultByToken(queryToken);
     }
     createDisabledUnsubscribe() {
-      const disabledUnsubscribe = () => {
-      };
+      const disabledUnsubscribe = (() => {
+      });
       const unsubscribeProps = {
         unsubscribe: disabledUnsubscribe,
         getCurrentValue: () => void 0,