convex 1.17.3 → 1.17.5-alpha.0

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## Unreleased
+
+- Warn on direct Convex function call. This adds a console.warn whenever a
+  Convex Function (mutation, query, action, internalMutation, etc.) is called
+  directly
+
+  ```ts
+  export const foo = mutation(...);
+
+  export const bar = mutation({
+    args: v.any(),
+    returns: v.any(),
+    handler: (ctx, args) => {
+      const result = await foo();
+    })
+  }
+  ```
+
+  because this pattern causes problems and there are straightforward
+  workarounds. The problems here:
+
+  1. Arguments and return values aren't validated despite the presence of
+     validators at the function definition site.
+  2. Functions called this way unexpectedly lack isolation and atomicity. Convex
+     functions may be writting assuming they will run as independent
+     transactions, but running these function directly breaks that assumption.
+  3. Running Convex functions defined by customFunctions like triggers can cause
+     deadlocks and other bad behavior.
+
+  There are two options for how to modify your code to address the warning:
+
+  1. Refactor it out as a helper function, then call that helper function
+     directly.
+  2. Use `ctx.runMutation`, `ctx.runQuery`, or `ctx.runAction()` instead of
+     calling the function directly. This has more overhead (it's slower) but you
+     gain isolation and atomicity because it runs as a subtransaction.
+
+  See
+  https://docs.convex.dev/production/best-practices/#use-helper-functions-to-write-shared-code
+  for more.
+
+  Filter to warnings in the convex dashboard logs to see if you're using this
+  pattern.
+
+  For now running functions this way only logs a warning, but this pattern is
+  now deprecated and may be deleted in a future version.
+
+- Support for Next.js 15 and
+  [Clerk core 2](https://clerk.com/docs/upgrade-guides/core-2/overview):
+  `@clerk/nextjs@5` and `@clerk/nextjs@6` are now known to work to Convex. Docs,
+  quickstarts and templates have not yet been updated. If you're upgrading
+  `@clerk/nextjs` be sure to follow the Clerk upgrade guides as there are many
+  breaking changes.
+
+- Fix type for FieldTypeFromFieldPath with optional objects.
+
+- Fix types when a handler returns a promise when using return value validators
+  with object syntax.
+
+## 1.17.4
+
+- Revert use of the identity of useAuth from Clerk to determine whether
+  refreshing auth is necessary. This was causing an auth loop in Expo.
+
+## 1.17.3
+
+- Fetch a new JWT from Clerk when using Clerk components to change the active
+  orgId or orgRole in React on the client. Any auth provider can implement this
+  by returning a new `getToken` function from the `useAuth` hook passed into
+  `ConvexProviderWithAuth`.
+
 ## 1.17.3
 
 - Fetch a new JWT from Clerk when using CLerk components to change the active

package/dist/browser.bundle.js

@@ -28,7 +28,7 @@ var convex = (() => {
   });
 
   // src/index.ts
-  var version = "1.17.3";
+  var version = "1.17.5-alpha.0";
 
   // src/values/base64.ts
   var base64_exports = {};
@@ -931,32 +931,36 @@ var convex = (() => {
         logForFunction(this.logger, "info", udfType, udfPath, line);
       }
       const status = requestInfo.status;
+      let result;
       let onResolve;
       if (response.success) {
-        onResolve = () => status.onResult({
+        result = {
           success: true,
           logLines: response.logLines,
           value: jsonToConvex(response.result)
-        });
+        };
+        onResolve = () => status.onResult(result);
       } else {
         const errorMessage = response.result;
         const { errorData } = response;
         logForFunction(this.logger, "error", udfType, udfPath, errorMessage);
-        onResolve = () => status.onResult({
+        result = {
           success: false,
           errorMessage,
           errorData: errorData !== void 0 ? jsonToConvex(errorData) : void 0,
           logLines: response.logLines
-        });
+        };
+        onResolve = () => status.onResult(result);
       }
       if (response.type === "ActionResponse" || !response.success) {
         onResolve();
         this.inflightRequests.delete(response.requestId);
         this.requestsOlderThanRestart.delete(response.requestId);
-        return response.requestId;
+        return { requestId: response.requestId, result };
       }
       requestInfo.status = {
         status: "Completed",
+        result,
         ts: response.ts,
         onResolve
       };
@@ -964,12 +968,12 @@ var convex = (() => {
     }
     // Remove and returns completed requests.
     removeCompleted(ts) {
-      const completeRequests = /* @__PURE__ */ new Set();
+      const completeRequests = /* @__PURE__ */ new Map();
       for (const [requestId, requestInfo] of this.inflightRequests.entries()) {
         const status = requestInfo.status;
         if (status.status === "Completed" && status.ts.lessThanOrEqual(ts)) {
           status.onResolve();
-          completeRequests.add(requestId);
+          completeRequests.set(requestId, status.result);
           this.inflightRequests.delete(requestId);
           this.requestsOlderThanRestart.delete(requestId);
         }
@@ -2218,8 +2222,9 @@ var convex = (() => {
     authenticationManager;
     remoteQuerySet;
     optimisticQueryResults;
-    onTransition;
+    _transitionHandlerCounter = 0;
     _nextRequestId;
+    _onTransitionFns = /* @__PURE__ */ new Map();
     _sessionId;
     firstMessageReceived = false;
     debug;
@@ -2229,7 +2234,8 @@ var convex = (() => {
      * @param address - The url of your Convex deployment, often provided
      * by an environment variable. E.g. `https://small-mouse-123.convex.cloud`.
      * @param onTransition - A callback receiving an array of query tokens
-     * corresponding to query results that have changed.
+     * corresponding to query results that have changed -- additional handlers
+     * can be added via `addOnTransitionHandler`.
      * @param options - See {@link BaseConvexClientOptions} for a full description.
      */
     constructor(address, onTransition, options) {
@@ -2298,7 +2304,9 @@ var convex = (() => {
         }
       );
       this.optimisticQueryResults = new OptimisticQueryResults();
-      this.onTransition = onTransition;
+      this.addOnTransitionHandler((transition) => {
+        onTransition(transition.queries.map((q) => q.token));
+      });
       this._nextRequestId = 0;
       this._sessionId = newSessionId();
       const { unsavedChangesWarning } = options;
@@ -2381,9 +2389,16 @@ var convex = (() => {
                 if (serverMessage.success) {
                   this.observedTimestamp(serverMessage.ts);
                 }
-                const completedMutationId = this.requestManager.onResponse(serverMessage);
-                if (completedMutationId !== null) {
-                  this.notifyOnQueryResultChanges(/* @__PURE__ */ new Set([completedMutationId]));
+                const completedMutationInfo = this.requestManager.onResponse(serverMessage);
+                if (completedMutationInfo !== null) {
+                  this.notifyOnQueryResultChanges(
+                    /* @__PURE__ */ new Map([
+                      [
+                        completedMutationInfo.requestId,
+                        completedMutationInfo.result
+                      ]
+                    ])
+                  );
                 }
                 break;
               }
@@ -2441,7 +2456,7 @@ var convex = (() => {
      * @param completedMutations - A set of mutation IDs whose optimistic updates
      * are no longer needed.
      */
-    notifyOnQueryResultChanges(completedRequest) {
+    notifyOnQueryResultChanges(completedRequests) {
       const remoteQueryResults = this.remoteQuerySet.remoteQueryResults();
       const queryTokenToValue = /* @__PURE__ */ new Map();
       for (const [queryId, result] of remoteQueryResults) {
@@ -2455,12 +2470,45 @@ var convex = (() => {
           queryTokenToValue.set(queryToken, query);
         }
       }
-      this.onTransition(
-        this.optimisticQueryResults.ingestQueryResultsFromServer(
-          queryTokenToValue,
-          completedRequest
-        )
+      const changedQueryTokens = this.optimisticQueryResults.ingestQueryResultsFromServer(
+        queryTokenToValue,
+        new Set(completedRequests.keys())
       );
+      this.handleTransition({
+        queries: changedQueryTokens.map((token) => ({
+          token,
+          modification: {
+            kind: "Updated",
+            result: queryTokenToValue.get(token).result
+          }
+        })),
+        reflectedMutations: Array.from(completedRequests).map(
+          ([requestId, result]) => ({
+            requestId,
+            result
+          })
+        ),
+        timestamp: this.remoteQuerySet.timestamp()
+      });
+    }
+    handleTransition(transition) {
+      for (const fn of this._onTransitionFns.values()) {
+        fn(transition);
+      }
+    }
+    /**
+     * Add a handler that will be called on a transition.
+     *
+     * Any external side effects (e.g. setting React state) should be handled here.
+     *
+     * @param fn
+     *
+     * @returns
+     */
+    addOnTransitionHandler(fn) {
+      const id = this._transitionHandlerCounter++;
+      this._onTransitionFns.set(id, fn);
+      return () => this._onTransitionFns.delete(id);
     }
     /**
      * Set the authentication token to be used for subsequent queries and mutations.
@@ -2616,6 +2664,18 @@ var convex = (() => {
      * @internal
      */
     async mutationInternal(udfPath, args, options, componentPath) {
+      const { mutationPromise } = this.enqueueMutation(
+        udfPath,
+        args,
+        options,
+        componentPath
+      );
+      return mutationPromise;
+    }
+    /**
+     * @internal
+     */
+    enqueueMutation(udfPath, args, options, componentPath) {
       const mutationArgs = parseArgs(args);
       this.tryReportLongDisconnect();
       const requestId = this.nextRequestId;
@@ -2626,11 +2686,29 @@ var convex = (() => {
           const wrappedUpdate = (localQueryStore) => {
             optimisticUpdate(localQueryStore, mutationArgs);
           };
-          const changedQueries = this.optimisticQueryResults.applyOptimisticUpdate(
+          const changedQueryTokens = this.optimisticQueryResults.applyOptimisticUpdate(
             wrappedUpdate,
             requestId
           );
-          this.onTransition(changedQueries);
+          const changedQueries = changedQueryTokens.map((token) => {
+            const localResult = this.localQueryResultByToken(token);
+            return {
+              token,
+              modification: {
+                kind: "Updated",
+                result: localResult === void 0 ? void 0 : {
+                  success: true,
+                  value: localResult,
+                  logLines: []
+                }
+              }
+            };
+          });
+          this.handleTransition({
+            queries: changedQueries,
+            reflectedMutations: [],
+            timestamp: this.remoteQuerySet.timestamp()
+          });
         }
       }
       const message = {
@@ -2641,7 +2719,11 @@ var convex = (() => {
         args: [convexToJson(mutationArgs)]
       };
       const mightBeSent = this.webSocketManager.sendMessage(message);
-      return this.requestManager.request(message, mightBeSent);
+      const mutationPromise = this.requestManager.request(message, mightBeSent);
+      return {
+        requestId,
+        mutationPromise
+      };
     }
     /**
      * Execute an action function.