convex 1.27.0 → 1.27.1

package/CHANGELOG.md

@@ -1,13 +1,28 @@
 # Changelog
 
+## 1.27.1
+
+- Changes to logged messages in the console, where previously only WebSocket
+  reconnection messages were logged. These can still be silenced with the
+  `logger: false` client option.
+- Improved support for the TypeScript tsconfig.json compiler option
+  "exactOptionalPropertTypes" with the convex package.
+- Additional WebSocket connection debugging information about Transition
+  messages.
+- Clearer error messages when running codegen in preview deployments.
+- Token limits for especially verbose logs MCP tool.
+- Add (preexisting) `codegen` options to `convex.json` schema.
+
 ## 1.27.0
 
-- Add support for configuring the Node.js version used by Node actions
-  using the `node.nodeVersion` field of the `convex.json` file
+- Add support for configuring the Node.js version used by Node actions using the
+  `node.nodeVersion` field of the `convex.json` file
   ([docs](https://docs.convex.dev/production/project-configuration#configuring-the-nodejs-version)).
-- `npx convex data` now supports exporting data as JSON or JSONL with the `--format` option.
-- `npx convex env set` now supports setting environment variables via piping (STDIN)
-  (for example `cat keys/my-private-key.txt | npx convex env set JWT_PRIVATE_KEY`).
+- `npx convex data` now supports exporting data as JSON or JSONL with the
+  `--format` option.
+- `npx convex env set` now supports setting environment variables via piping
+  (STDIN) (for example
+  `cat keys/my-private-key.txt | npx convex env set JWT_PRIVATE_KEY`).
 
 ## 1.26.2
 

package/dist/browser.bundle.js

@@ -28,7 +28,7 @@ var convex = (() => {
   });
 
   // src/index.ts
-  var version = "1.27.0";
+  var version = "1.27.1";
 
   // src/values/base64.ts
   var base64_exports = {};
@@ -1556,6 +1556,19 @@ var convex = (() => {
   var CLOSE_GOING_AWAY = 1001;
   var CLOSE_NO_STATUS = 1005;
   var CLOSE_NOT_FOUND = 4040;
+  var firstTime;
+  function monotonicMillis() {
+    if (firstTime === void 0) {
+      firstTime = Date.now();
+    }
+    if (typeof performance === "undefined" || !performance.now) {
+      return Date.now();
+    }
+    return Math.round(firstTime + performance.now());
+  }
+  function prettyNow() {
+    return `t=${Math.round((monotonicMillis() - firstTime) / 100) / 10}s`;
+  }
   var serverDisconnectErrors = {
     // A known error, e.g. during a restart or push
     InternalServerError: { timeout: 1e3 },
@@ -1571,7 +1584,7 @@ var convex = (() => {
     VectorIndexesUnavailable: { timeout: 1e3 },
     SearchIndexesUnavailable: { timeout: 1e3 },
     TableSummariesUnavailable: { timeout: 1e3 },
-    // More ErrorMeatadata::overloaded()
+    // More ErrorMetadata::overloaded()
     VectorIndexTooLarge: { timeout: 3e3 },
     SearchIndexTooLarge: { timeout: 3e3 },
     TooManyWritesInTimePeriod: { timeout: 3e3 }
@@ -1588,8 +1601,9 @@ var convex = (() => {
     return "Unknown";
   }
   var WebSocketManager = class {
-    constructor(uri, callbacks, webSocketConstructor, logger, markConnectionStateDirty) {
+    constructor(uri, callbacks, webSocketConstructor, logger, markConnectionStateDirty, debug) {
       this.markConnectionStateDirty = markConnectionStateDirty;
+      this.debug = debug;
       this.webSocketConstructor = webSocketConstructor;
       this.socket = { state: "disconnected" };
       this.connectionCount = 0;
@@ -1667,23 +1681,42 @@ var convex = (() => {
           this._hasEverConnected = true;
           this.onOpen({
             connectionCount: this.connectionCount,
-            lastCloseReason: this.lastCloseReason
+            lastCloseReason: this.lastCloseReason,
+            clientTs: monotonicMillis()
           });
         }
         if (this.lastCloseReason !== "InitialConnect") {
-          this.logger.log("WebSocket reconnected");
+          if (this.lastCloseReason) {
+            this.logger.log(
+              "WebSocket reconnected at",
+              prettyNow(),
+              "after disconnect due to",
+              this.lastCloseReason
+            );
+          } else {
+            this.logger.log("WebSocket reconnected at", prettyNow());
+          }
         }
         this.connectionCount += 1;
         this.lastCloseReason = null;
       };
       ws.onerror = (error) => {
         const message = error.message;
-        this.logger.log(`WebSocket error: ${message}`);
+        if (message) {
+          this.logger.log(`WebSocket error message: ${message}`);
+        }
       };
       ws.onmessage = (message) => {
         this.resetServerInactivityTimeout();
+        const messageLength = message.data.length;
         const serverMessage = parseServerMessage(JSON.parse(message.data));
         this._logVerbose(`received ws message with type ${serverMessage.type}`);
+        if (serverMessage.type === "Transition") {
+          this.reportLargeTransition({
+            messageLength,
+            transition: serverMessage
+          });
+        }
         const response = this.onMessage(serverMessage);
         if (response.hasSyncedPastLastReconnect) {
           this.retries = 0;
@@ -1693,7 +1726,7 @@ var convex = (() => {
       ws.onclose = (event) => {
         this._logVerbose("begin ws.onclose");
         if (this.lastCloseReason === null) {
-          this.lastCloseReason = event.reason ?? "OnCloseInvoked";
+          this.lastCloseReason = event.reason || `closed with code ${event.code}`;
         }
         if (event.code !== CLOSE_NORMAL && event.code !== CLOSE_GOING_AWAY && // This commonly gets fired on mobile apps when the app is backgrounded
         event.code !== CLOSE_NO_STATUS && event.code !== CLOSE_NOT_FOUND) {
@@ -1731,8 +1764,10 @@ var convex = (() => {
       if (this.socket.state === "ready" && this.socket.paused === "no") {
         const encodedMessage = encodeClientMessage(message);
         const request = JSON.stringify(encodedMessage);
+        let sent = false;
         try {
           this.socket.ws.send(request);
+          sent = true;
         } catch (error) {
           this.logger.log(
             `Failed to send message on WebSocket, reconnecting: ${error}`
@@ -1740,7 +1775,7 @@ var convex = (() => {
           this.closeAndReconnect("FailedToSendMessage");
         }
         this._logVerbose(
-          `sent message with type ${message.type}: ${JSON.stringify(
+          `${sent ? "sent" : "failed to send"} message with type ${message.type}: ${JSON.stringify(
             messageForLog
           )}`
         );
@@ -1769,7 +1804,7 @@ var convex = (() => {
       this.socket = { state: "disconnected" };
       const backoff = this.nextBackoff(reason);
       this.markConnectionStateDirty();
-      this.logger.log(`Attempting reconnect in ${backoff}ms`);
+      this.logger.log(`Attempting reconnect in ${Math.round(backoff)}ms`);
       setTimeout(() => this.connect(), backoff);
     }
     /**
@@ -1933,7 +1968,8 @@ var convex = (() => {
             this.socket = { ...this.socket, paused: "no" };
             this.onOpen({
               connectionCount: this.connectionCount,
-              lastCloseReason: this.lastCloseReason
+              lastCloseReason: this.lastCloseReason,
+              clientTs: monotonicMillis()
             });
           } else if (this.socket.paused === "yes") {
             this.socket = { ...this.socket, paused: "no" };
@@ -1969,6 +2005,48 @@ var convex = (() => {
       const jitter = actualBackoff * (Math.random() - 0.5);
       return actualBackoff + jitter;
     }
+    reportLargeTransition({
+      transition,
+      messageLength
+    }) {
+      if (transition.clientClockSkew === void 0 || transition.serverTs === void 0) {
+        return;
+      }
+      const transitionTransitTime = monotonicMillis() - // client time now
+      // clientClockSkew = (server time + upstream latency) - client time
+      // clientClockSkew is "how many milliseconds behind (slow) is the client clock"
+      // but the latency of the Connect message inflates this, making it appear further behind
+      transition.clientClockSkew - transition.serverTs / 1e6;
+      const prettyTransitionTime = `${Math.round(transitionTransitTime)}ms`;
+      const prettyMessageMB = `${Math.round(messageLength / 1e4) / 100}MB`;
+      const bytesPerSecond = messageLength / (transitionTransitTime / 1e3);
+      const prettyBytesPerSecond = `${Math.round(bytesPerSecond / 1e4) / 100}MB per second`;
+      this._logVerbose(
+        `received ${prettyMessageMB} transition in ${prettyTransitionTime} at ${prettyBytesPerSecond}`
+      );
+      if (transitionTransitTime > 1e4 && messageLength > 1e7) {
+        this.logger.log(
+          `received query results totalling more than 10MB (${prettyMessageMB}) which took more than 10s (${prettyTransitionTime}) to arrive`
+        );
+      } else if (messageLength > 2e7) {
+        this.logger.log(
+          `received query results totalling more that 20MB (${prettyMessageMB}) which will take a long time to download on slower connections`
+        );
+      } else if (transitionTransitTime > 2e4) {
+        this.logger.log(
+          `received query results totalling ${prettyMessageMB} which took more than 20s to arrive (${prettyTransitionTime})`
+        );
+      }
+      if (this.debug) {
+        if (transitionTransitTime > 1e4 || messageLength > 1e7) {
+          this.sendMessage({
+            type: "Event",
+            eventType: "ClientReceivedTransition",
+            event: { transitionTransitTime, messageLength }
+          });
+        }
+      }
+    }
   };
 
   // src/browser/sync/session.ts
@@ -2612,7 +2690,8 @@ var convex = (() => {
         },
         webSocketConstructor,
         this.logger,
-        this.markConnectionStateDirty
+        this.markConnectionStateDirty,
+        this.debug
       );
       this.mark("convexClientConstructed");
       if (options.expectAuth) {
@@ -3405,6 +3484,8 @@ var convex = (() => {
       this.logger = options?.logger === false ? instantiateNoopLogger({ verbose: false }) : options?.logger !== true && options?.logger ? options.logger : instantiateDefaultLogger({ verbose: false });
       this.address = address;
       this.debug = true;
+      this.auth = void 0;
+      this.adminAuth = void 0;
       if (options?.auth) {
         this.setAuth(options.auth);
       }