@stackframe/stack 2.5.2 → 2.5.3

package/dist/lib/stack-app.js

@@ -59,7 +59,7 @@ var cookie = __toESM(require("cookie"));
 var import_sessions = require("@stackframe/stack-shared/dist/sessions");
 var import_strings = require("@stackframe/stack-shared/dist/utils/strings");
 var NextNavigation = (0, import_compile_time.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];
 }
@@ -165,6 +165,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 (0, import_promises.wait)(2e3);
+      }
+      const user = await this._interface.getClientUserByToken(session);
+      return import_results.Result.or(user, null);
+    });
+    this._currentProjectCache = createCache(async () => {
+      return import_results.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 import_stack_shared.KnownErrors.OAuthConnectionDoesNotHaveRequiredScope || err instanceof import_stack_shared.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 (0, import_auth.addNewOAuthProviderOrScope)(
+            this._interface,
+            {
+              provider: connectionId,
+              redirectUrl: this.urls.oauthCallback,
+              errorRedirectUrl: this.urls.error,
+              providerScope: (0, import_strings.mergeScopeStrings)(scope || "", (this._oauthScopesOnSignIn[connectionId] ?? []).join(" "))
+            },
+            session
+          );
+          return await (0, import_promises.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 import_errors.StackAssertionError("No access token available");
+            }
+            return result;
+          },
+          useAccessToken() {
+            const result = useAsyncCache(app._currentUserOAuthConnectionAccessTokensCache, [session, connectionId, scope || ""], "oauthAccount.useAccessToken()");
+            if (!result) {
+              throw new import_errors.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 {
@@ -187,89 +278,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 (0, import_promises.wait)(2e3);
-    }
-    const user = await this._interface.getClientUserByToken(session);
-    return import_results.Result.or(user, null);
-  });
-  _currentProjectCache = createCache(async () => {
-    return import_results.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 import_stack_shared.KnownErrors.OAuthConnectionDoesNotHaveRequiredScope || err instanceof import_stack_shared.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 (0, import_auth.addNewOAuthProviderOrScope)(
-          this._interface,
-          {
-            provider: connectionId,
-            redirectUrl: this.urls.oauthCallback,
-            errorRedirectUrl: this.urls.error,
-            providerScope: (0, import_strings.mergeScopeStrings)(scope || "", (this._oauthScopesOnSignIn[connectionId] ?? []).join(" "))
-          },
-          session
-        );
-        return await (0, import_promises.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 import_errors.StackAssertionError("No access token available");
-          }
-          return result;
-        },
-        useAccessToken() {
-          const result = useAsyncCache(app._currentUserOAuthConnectionAccessTokensCache, [session, connectionId, scope || ""], "oauthAccount.useAccessToken()");
-          if (!result) {
-            throw new import_errors.StackAssertionError("No access token available");
-          }
-          return result;
-        }
-      };
-    }
-  );
   _initUniqueIdentifier() {
     if (!this._uniqueIdentifier) {
       throw new import_errors.StackAssertionError("Unique identifier not initialized");
@@ -297,9 +305,6 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     (0, import_promises.runAsynchronously)(this._checkFeatureSupport(featureName, options));
     throw new import_errors.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}`;
   }
@@ -427,15 +432,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 = import_sessions.InternalSession.calculateSessionKey(tokenObj);
@@ -1040,33 +1036,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 import_results.Result.or(user, null);
-  });
-  _serverUsersCache = createCache(async () => {
-    return await this._interface.listServerUsers();
-  });
-  _serverUserCache = createCache(async ([userId]) => {
-    const user = await this._interface.getServerUserById(userId);
-    return import_results.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,
@@ -1085,6 +1054,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 import_results.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 import_results.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 {
@@ -1411,12 +1407,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 import_stack_shared.StackAdminInterface({
@@ -1435,6 +1425,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;