@stackframe/stack 2.5.12 → 2.5.15

package/dist/esm/lib/stack-app.js

@@ -23,7 +23,7 @@ import { constructRedirectUrl } from "../utils/url";
 import { addNewOAuthProviderOrScope, callOAuthCallback, signInWithOAuth } from "./auth";
 import { deleteCookie, getCookie, setOrDeleteCookie } from "./cookie";
 var NextNavigation = scrambleDuringCompileTime(NextNavigationUnscrambled);
-var clientVersion = "js @stackframe/stack@2.5.12";
+var clientVersion = "js @stackframe/stack@2.5.15";
 function getUrls(partial) {
   const handler = partial.handler ?? "/handler";
   const home = partial.home ?? "/";
@@ -150,12 +150,10 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       return await this._interface.listCurrentUserTeams(session);
     });
     this._currentUserOAuthConnectionAccessTokensCache = createCacheBySession(
-      async (session, [accountId, scope]) => {
+      async (session, [providerId, scope]) => {
         try {
-          const result = await this._interface.createProviderAccessToken(accountId, scope || "", session);
-          return {
-            accessToken: result.access_token
-          };
+          const result = await this._interface.createProviderAccessToken(providerId, scope || "", session);
+          return { accessToken: result.access_token };
         } catch (err) {
           if (!(err instanceof KnownErrors.OAuthConnectionDoesNotHaveRequiredScope || err instanceof KnownErrors.OAuthConnectionNotConnectedToUser)) {
             throw err;
@@ -165,49 +163,16 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       }
     );
     this._currentUserOAuthConnectionCache = createCacheBySession(
-      async (session, [connectionId, scope, redirect]) => {
-        const user = await this._currentUserCache.getOrWait([session], "write-only");
-        let hasConnection = true;
-        if (!user || !user.oauth_providers.find((p) => p.id === connectionId)) {
-          hasConnection = false;
-        }
-        const token = await this._currentUserOAuthConnectionAccessTokensCache.getOrWait([session, connectionId, scope || ""], "write-only");
-        if (!token) {
-          hasConnection = false;
-        }
-        if (!hasConnection && redirect) {
-          await addNewOAuthProviderOrScope(
-            this._interface,
-            {
-              provider: connectionId,
-              redirectUrl: this.urls.oauthCallback,
-              errorRedirectUrl: this.urls.error,
-              providerScope: mergeScopeStrings(scope || "", (this._oauthScopesOnSignIn[connectionId] ?? []).join(" "))
-            },
-            session
-          );
-          return await neverResolve();
-        } else if (!hasConnection) {
-          return null;
-        }
-        const app = this;
-        return {
-          id: connectionId,
-          async getAccessToken() {
-            const result = await app._currentUserOAuthConnectionAccessTokensCache.getOrWait([session, connectionId, scope || ""], "write-only");
-            if (!result) {
-              throw new StackAssertionError("No access token available");
-            }
-            return result;
-          },
-          useAccessToken() {
-            const result = useAsyncCache(app._currentUserOAuthConnectionAccessTokensCache, [session, connectionId, scope || ""], "oauthAccount.useAccessToken()");
-            if (!result) {
-              throw new StackAssertionError("No access token available");
-            }
-            return result;
-          }
-        };
+      async (session, [providerId, scope, redirect]) => {
+        return await this._getUserOAuthConnectionCacheFn({
+          getUser: async () => await this._currentUserCache.getOrWait([session], "write-only"),
+          getOrWaitOAuthToken: async () => await this._currentUserOAuthConnectionAccessTokensCache.getOrWait([session, providerId, scope || ""], "write-only"),
+          useOAuthToken: () => useAsyncCache(this._currentUserOAuthConnectionAccessTokensCache, [session, providerId, scope || ""], "useOAuthToken"),
+          providerId,
+          scope,
+          redirect,
+          session
+        });
       }
     );
     this._memoryTokenStore = createEmptyTokenStore();
@@ -246,6 +211,53 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       }
     }
   }
+  async _getUserOAuthConnectionCacheFn(options) {
+    const user = await options.getUser();
+    let hasConnection = true;
+    if (!user || !user.oauth_providers.find((p) => p.id === options.providerId)) {
+      hasConnection = false;
+    }
+    const token = await options.getOrWaitOAuthToken();
+    if (!token) {
+      hasConnection = false;
+    }
+    if (!hasConnection && options.redirect) {
+      if (!options.session) {
+        throw new Error("No session found. You might be calling getConnectedAccount with redirect without having a user session.");
+      }
+      await addNewOAuthProviderOrScope(
+        this._interface,
+        {
+          provider: options.providerId,
+          redirectUrl: this.urls.oauthCallback,
+          errorRedirectUrl: this.urls.error,
+          providerScope: mergeScopeStrings(options.scope || "", (this._oauthScopesOnSignIn[options.providerId] ?? []).join(" "))
+        },
+        options.session
+      );
+      return await neverResolve();
+    } else if (!hasConnection) {
+      return null;
+    }
+    const app = this;
+    return {
+      id: options.providerId,
+      async getAccessToken() {
+        const result = await options.getOrWaitOAuthToken();
+        if (!result) {
+          throw new StackAssertionError("No access token available");
+        }
+        return result;
+      },
+      useAccessToken() {
+        const result = options.useOAuthToken();
+        if (!result) {
+          throw new StackAssertionError("No access token available");
+        }
+        return result;
+      }
+    };
+  }
   _initUniqueIdentifier() {
     if (!this._uniqueIdentifier) {
       throw new StackAssertionError("Unique identifier not initialized");
@@ -1021,11 +1033,8 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       const user = await this._interface.getServerUserById(userId);
       return Result.or(user, null);
     });
-    this._serverTeamsCache = createCache(async () => {
-      return await this._interface.listServerTeams();
-    });
-    this._serverCurrentUserTeamsCache = createCacheBySession(async (session) => {
-      return await this._interface.listServerCurrentUserTeams(session);
+    this._serverTeamsCache = createCache(async ([userId]) => {
+      return await this._interface.listServerTeams({ userId });
     });
     this._serverTeamUsersCache = createCache(async ([teamId]) => {
       return await this._interface.listServerTeamUsers(teamId);
@@ -1033,6 +1042,32 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
     this._serverTeamUserPermissionsCache = createCache(async ([teamId, userId, recursive]) => {
       return await this._interface.listServerTeamMemberPermissions({ teamId, userId, recursive });
     });
+    this._serverUserOAuthConnectionAccessTokensCache = createCache(
+      async ([userId, providerId, scope]) => {
+        try {
+          const result = await this._interface.createServerProviderAccessToken(userId, providerId, scope || "");
+          return { accessToken: result.access_token };
+        } catch (err) {
+          if (!(err instanceof KnownErrors.OAuthConnectionDoesNotHaveRequiredScope || err instanceof KnownErrors.OAuthConnectionNotConnectedToUser)) {
+            throw err;
+          }
+        }
+        return null;
+      }
+    );
+    this._serverUserOAuthConnectionCache = createCache(
+      async ([userId, providerId, scope, redirect]) => {
+        return await this._getUserOAuthConnectionCacheFn({
+          getUser: async () => await this._serverUserCache.getOrWait([userId], "write-only"),
+          getOrWaitOAuthToken: async () => await this._serverUserOAuthConnectionAccessTokensCache.getOrWait([userId, providerId, scope || ""], "write-only"),
+          useOAuthToken: () => useAsyncCache(this._serverUserOAuthConnectionAccessTokensCache, [userId, providerId, scope || ""], "user.useConnectedAccount()"),
+          providerId,
+          scope,
+          redirect,
+          session: null
+        });
+      }
+    );
   }
   async _updateServerUser(userId, update) {
     const result = await this._interface.updateServerUser(userId, serverUserUpdateOptionsToCrud(update));
@@ -1041,6 +1076,14 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
   }
   _serverUserFromCrud(crud) {
     const app = this;
+    async function getConnectedAccount(id, options) {
+      const scopeString = options?.scopes?.join(" ");
+      return await app._serverUserOAuthConnectionCache.getOrWait([crud.id, id, scopeString || "", options?.or === "redirect"], "write-only");
+    }
+    function useConnectedAccount(id, options) {
+      const scopeString = options?.scopes?.join(" ");
+      return useAsyncCache(app._serverUserOAuthConnectionCache, [crud.id, id, scopeString || "", options?.or === "redirect"], "user.useConnectedAccount()");
+    }
     return {
       ...super._createBaseUser(crud),
       serverMetadata: crud.server_metadata,
@@ -1084,29 +1127,29 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       async setSelectedTeam(team) {
         return await this.update({ selectedTeamId: team?.id ?? null });
       },
-      getConnectedAccount: async () => {
-        return await app._checkFeatureSupport("getConnectedAccount() on ServerUser", {});
-      },
-      useConnectedAccount: () => {
-        return app._useCheckFeatureSupport("useConnectedAccount() on ServerUser", {});
-      },
+      getConnectedAccount,
+      useConnectedAccount,
       async getTeam(teamId) {
         const teams = await this.listTeams();
         return teams.find((t) => t.id === teamId) ?? null;
       },
       useTeam(teamId) {
-        return app._useCheckFeatureSupport("useTeam() on ServerUser", {});
+        const teams = this.useTeams();
+        return useMemo(() => {
+          return teams.find((t) => t.id === teamId) ?? null;
+        }, [teams, teamId]);
       },
       async listTeams() {
-        const crud2 = await app._serverCurrentUserTeamsCache.getOrWait([app._getSession()], "write-only");
-        return crud2.map((t) => app._serverTeamFromCrud(t));
+        const teams = await app._serverTeamsCache.getOrWait([crud.id], "write-only");
+        return teams.map((t) => app._serverTeamFromCrud(t));
       },
       useTeams() {
-        return app._useCheckFeatureSupport("useTeams() on ServerUser", {});
+        const teams = useAsyncCache(app._serverTeamsCache, [crud.id], "user.useTeams()");
+        return useMemo(() => teams.map((t) => app._serverTeamFromCrud(t)), [teams]);
       },
       createTeam: async (data) => {
         const team = await app._interface.createServerTeam(serverTeamCreateOptionsToCrud(data), app._getSession());
-        await app._serverTeamsCache.refresh([]);
+        await app._serverTeamsCache.refresh([void 0]);
         return app._serverTeamFromCrud(team);
       },
       async listPermissions(scope, options) {
@@ -1163,11 +1206,11 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       },
       async update(update) {
         await app._interface.updateServerTeam(crud.id, serverTeamUpdateOptionsToCrud(update));
-        await app._serverTeamsCache.refresh([]);
+        await app._serverTeamsCache.refresh([void 0]);
       },
       async delete() {
         await app._interface.deleteServerTeam(crud.id);
-        await app._serverTeamsCache.refresh([]);
+        await app._serverTeamsCache.refresh([void 0]);
       },
       useUsers() {
         const result = useAsyncCache(app._serverTeamUsersCache, [crud.id], "team.useUsers()");
@@ -1270,16 +1313,16 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
     };
   }
   async listTeams() {
-    const teams = await this._serverTeamsCache.getOrWait([], "write-only");
+    const teams = await this._serverTeamsCache.getOrWait([void 0], "write-only");
     return teams.map((t) => this._serverTeamFromCrud(t));
   }
   async createTeam(data) {
     const team = await this._interface.createServerTeam(serverTeamCreateOptionsToCrud(data));
-    await this._serverTeamsCache.refresh([]);
+    await this._serverTeamsCache.refresh([void 0]);
     return this._serverTeamFromCrud(team);
   }
   useTeams() {
-    const teams = useAsyncCache(this._serverTeamsCache, [], "useServerTeams()");
+    const teams = useAsyncCache(this._serverTeamsCache, [void 0], "useServerTeams()");
     return useMemo(() => {
       return teams.map((t) => this._serverTeamFromCrud(t));
     }, [teams]);
@@ -1338,6 +1381,9 @@ var _StackAdminAppImpl = class extends _StackServerAppImpl {
     this._adminTeamPermissionDefinitionsCache = createCache(async () => {
       return await this._interface.listPermissionDefinitions();
     });
+    this._svixTokenCache = createCache(async () => {
+      return await this._interface.getSvixToken();
+    });
   }
   _adminOwnedProjectFromCrud(data, onRefresh) {
     if (this._tokenStoreInit !== null) {
@@ -1525,6 +1571,10 @@ var _StackAdminAppImpl = class extends _StackServerAppImpl {
       return crud.map((p) => this._serverTeamPermissionDefinitionFromCrud(p));
     }, [crud]);
   }
+  useSvixToken() {
+    const crud = useAsyncCache(this._svixTokenCache, [], "useSvixToken()");
+    return crud.token;
+  }
   async _refreshProject() {
     await Promise.all([
       super._refreshProject(),