@stackframe/stack 2.5.2 → 2.5.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @stackframe/stack
 
+## 2.5.3
+
+### Patch Changes
+
+- Bugfixes
+- Updated dependencies
+  - @stackframe/stack-shared@2.5.3
+  - @stackframe/stack-sc@2.5.3
+  - @stackframe/stack-ui@2.5.3
+
 ## 2.5.2
 
 ### Patch Changes

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

@@ -22,7 +22,7 @@ import * as cookie from "cookie";
 import { InternalSession } from "@stackframe/stack-shared/dist/sessions";
 import { mergeScopeStrings } from "@stackframe/stack-shared/dist/utils/strings";
 var NextNavigation = scrambleDuringCompileTime(NextNavigationUnscrambled);
-var clientVersion = "js @stackframe/stack@2.5.2";
+var clientVersion = "js @stackframe/stack@2.5.3";
 function permissionDefinitionScopeToType(scope) {
   return { "any-team": "team", "specific-team": "team", "global": "global" }[scope.type];
 }
@@ -128,6 +128,97 @@ var numberOfAppsCreated = 0;
 var _StackClientAppImpl = class __StackClientAppImpl {
   constructor(_options) {
     this._options = _options;
+    this._uniqueIdentifier = void 0;
+    this.__DEMO_ENABLE_SLIGHT_FETCH_DELAY = false;
+    this._currentUserCache = createCacheBySession(async (session) => {
+      if (this.__DEMO_ENABLE_SLIGHT_FETCH_DELAY) {
+        await wait(2e3);
+      }
+      const user = await this._interface.getClientUserByToken(session);
+      return Result.or(user, null);
+    });
+    this._currentProjectCache = createCache(async () => {
+      return Result.orThrow(await this._interface.getClientProject());
+    });
+    this._ownedProjectsCache = createCacheBySession(async (session) => {
+      return await this._interface.listProjects(session);
+    });
+    this._currentUserPermissionsCache = createCacheBySession(async (session, [teamId, type, direct]) => {
+      return await this._interface.listClientUserTeamPermissions({ teamId, type, direct }, session);
+    });
+    this._currentUserTeamsCache = createCacheBySession(async (session) => {
+      return await this._interface.listClientUserTeams(session);
+    });
+    this._currentUserOAuthConnectionAccessTokensCache = createCacheBySession(
+      async (session, [accountId, scope]) => {
+        try {
+          return await this._interface.getAccessToken(accountId, scope || "", session);
+        } catch (err) {
+          if (!(err instanceof KnownErrors.OAuthConnectionDoesNotHaveRequiredScope || err instanceof KnownErrors.OAuthConnectionNotConnectedToUser)) {
+            throw err;
+          }
+        }
+        return null;
+      }
+    );
+    this._currentUserOAuthConnectionCache = createCacheBySession(
+      async (session, [connectionId, scope, redirect]) => {
+        const user = await this._currentUserCache.getOrWait([session], "write-only");
+        let hasConnection = true;
+        if (!user || !user.oauthProviders.find((p) => p === 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;
+          }
+        };
+      }
+    );
+    this._memoryTokenStore = createEmptyTokenStore();
+    this._requestTokenStores = /* @__PURE__ */ new WeakMap();
+    this._storedCookieTokenStore = null;
+    /**
+     * A map from token stores and session keys to sessions.
+     * 
+     * This isn't just a map from session keys to sessions for two reasons:
+     * 
+     * - So we can garbage-collect Session objects when the token store is garbage-collected
+     * - So different token stores are separated and don't leak information between each other, eg. if the same user sends two requests to the same server they should get a different session object
+     */
+    this._sessionsByTokenStoreAndSessionKey = /* @__PURE__ */ new WeakMap();
     if ("interface" in _options) {
       this._interface = _options.interface;
     } else {
@@ -150,89 +241,6 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       (process.env.NODE_ENV === "development" ? console.log : console.warn)(`You have created more than 10 Stack apps (${numberOfAppsCreated}). This is usually a sign of a memory leak, but can sometimes be caused by hot reload of your tech stack. In production, make sure to minimize the number of Stack apps per page (usually, one per project).`);
     }
   }
-  _uniqueIdentifier = void 0;
-  _interface;
-  _tokenStoreInit;
-  _urlOptions;
-  _oauthScopesOnSignIn;
-  __DEMO_ENABLE_SLIGHT_FETCH_DELAY = false;
-  _currentUserCache = createCacheBySession(async (session) => {
-    if (this.__DEMO_ENABLE_SLIGHT_FETCH_DELAY) {
-      await wait(2e3);
-    }
-    const user = await this._interface.getClientUserByToken(session);
-    return Result.or(user, null);
-  });
-  _currentProjectCache = createCache(async () => {
-    return Result.orThrow(await this._interface.getClientProject());
-  });
-  _ownedProjectsCache = createCacheBySession(async (session) => {
-    return await this._interface.listProjects(session);
-  });
-  _currentUserPermissionsCache = createCacheBySession(async (session, [teamId, type, direct]) => {
-    return await this._interface.listClientUserTeamPermissions({ teamId, type, direct }, session);
-  });
-  _currentUserTeamsCache = createCacheBySession(async (session) => {
-    return await this._interface.listClientUserTeams(session);
-  });
-  _currentUserOAuthConnectionAccessTokensCache = createCacheBySession(
-    async (session, [accountId, scope]) => {
-      try {
-        return await this._interface.getAccessToken(accountId, scope || "", session);
-      } catch (err) {
-        if (!(err instanceof KnownErrors.OAuthConnectionDoesNotHaveRequiredScope || err instanceof KnownErrors.OAuthConnectionNotConnectedToUser)) {
-          throw err;
-        }
-      }
-      return null;
-    }
-  );
-  _currentUserOAuthConnectionCache = createCacheBySession(
-    async (session, [connectionId, scope, redirect]) => {
-      const user = await this._currentUserCache.getOrWait([session], "write-only");
-      let hasConnection = true;
-      if (!user || !user.oauthProviders.find((p) => p === 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;
-        }
-      };
-    }
-  );
   _initUniqueIdentifier() {
     if (!this._uniqueIdentifier) {
       throw new StackAssertionError("Unique identifier not initialized");
@@ -260,9 +268,6 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     runAsynchronously(this._checkFeatureSupport(featureName, options));
     throw new StackAssertionError(`${featureName} is not currently supported. Please reach out to Stack support for more information.`);
   }
-  _memoryTokenStore = createEmptyTokenStore();
-  _requestTokenStores = /* @__PURE__ */ new WeakMap();
-  _storedCookieTokenStore = null;
   get _refreshTokenCookieName() {
     return `stack-refresh-${this.projectId}`;
   }
@@ -390,15 +395,6 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       }
     }
   }
-  /**
-   * A map from token stores and session keys to sessions.
-   * 
-   * This isn't just a map from session keys to sessions for two reasons:
-   * 
-   * - So we can garbage-collect Session objects when the token store is garbage-collected
-   * - So different token stores are separated and don't leak information between each other, eg. if the same user sends two requests to the same server they should get a different session object
-   */
-  _sessionsByTokenStoreAndSessionKey = /* @__PURE__ */ new WeakMap();
   _getSessionFromTokenStore(tokenStore) {
     const tokenObj = tokenStore.get();
     const sessionKey = InternalSession.calculateSessionKey(tokenObj);
@@ -1003,33 +999,6 @@ var _StackClientAppImpl = class __StackClientAppImpl {
   }
 };
 var _StackServerAppImpl = class extends _StackClientAppImpl {
-  // TODO override the client user cache to use the server user cache, so we save some requests
-  _currentServerUserCache = createCacheBySession(async (session) => {
-    const user = await this._interface.getServerUserByToken(session);
-    return Result.or(user, null);
-  });
-  _serverUsersCache = createCache(async () => {
-    return await this._interface.listServerUsers();
-  });
-  _serverUserCache = createCache(async ([userId]) => {
-    const user = await this._interface.getServerUserById(userId);
-    return Result.or(user, null);
-  });
-  _serverTeamsCache = createCache(async () => {
-    return await this._interface.listServerTeams();
-  });
-  _serverTeamMembersCache = createCache(async ([teamId]) => {
-    return await this._interface.listServerTeamMembers(teamId);
-  });
-  _serverTeamPermissionDefinitionsCache = createCache(async () => {
-    return await this._interface.listPermissionDefinitions();
-  });
-  _serverTeamUserPermissionsCache = createCache(async ([teamId, userId, type, direct]) => {
-    return await this._interface.listServerTeamMemberPermissions({ teamId, userId, type, direct });
-  });
-  _serverEmailTemplatesCache = createCache(async () => {
-    return await this._interface.listEmailTemplates();
-  });
   constructor(options) {
     super("interface" in options ? {
       interface: options.interface,
@@ -1048,6 +1017,33 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       urls: options.urls ?? {},
       oauthScopesOnSignIn: options.oauthScopesOnSignIn ?? {}
     });
+    // TODO override the client user cache to use the server user cache, so we save some requests
+    this._currentServerUserCache = createCacheBySession(async (session) => {
+      const user = await this._interface.getServerUserByToken(session);
+      return Result.or(user, null);
+    });
+    this._serverUsersCache = createCache(async () => {
+      return await this._interface.listServerUsers();
+    });
+    this._serverUserCache = createCache(async ([userId]) => {
+      const user = await this._interface.getServerUserById(userId);
+      return Result.or(user, null);
+    });
+    this._serverTeamsCache = createCache(async () => {
+      return await this._interface.listServerTeams();
+    });
+    this._serverTeamMembersCache = createCache(async ([teamId]) => {
+      return await this._interface.listServerTeamMembers(teamId);
+    });
+    this._serverTeamPermissionDefinitionsCache = createCache(async () => {
+      return await this._interface.listPermissionDefinitions();
+    });
+    this._serverTeamUserPermissionsCache = createCache(async ([teamId, userId, type, direct]) => {
+      return await this._interface.listServerTeamMemberPermissions({ teamId, userId, type, direct });
+    });
+    this._serverEmailTemplatesCache = createCache(async () => {
+      return await this._interface.listEmailTemplates();
+    });
   }
   _createBaseUser(json) {
     return {
@@ -1374,12 +1370,6 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
   }
 };
 var _StackAdminAppImpl = class extends _StackServerAppImpl {
-  _adminProjectCache = createCache(async () => {
-    return await this._interface.getProject();
-  });
-  _apiKeySetsCache = createCache(async () => {
-    return await this._interface.listApiKeySets();
-  });
   constructor(options) {
     super({
       interface: new StackAdminInterface({
@@ -1398,6 +1388,12 @@ var _StackAdminAppImpl = class extends _StackServerAppImpl {
       urls: options.urls,
       oauthScopesOnSignIn: options.oauthScopesOnSignIn
     });
+    this._adminProjectCache = createCache(async () => {
+      return await this._interface.getProject();
+    });
+    this._apiKeySetsCache = createCache(async () => {
+      return await this._interface.listApiKeySets();
+    });
   }
   _createApiKeySetBaseFromJson(data) {
     const app = this;