@stackframe/stack 2.5.7 → 2.5.9

package/dist/lib/stack-app.js

@@ -53,6 +53,7 @@ var import_react = require("@stackframe/stack-shared/dist/utils/react");
 var import_results = require("@stackframe/stack-shared/dist/utils/results");
 var import_stores = require("@stackframe/stack-shared/dist/utils/stores");
 var import_strings = require("@stackframe/stack-shared/dist/utils/strings");
+var import_urls = require("@stackframe/stack-shared/dist/utils/urls");
 var import_uuids = require("@stackframe/stack-shared/dist/utils/uuids");
 var cookie = __toESM(require("cookie"));
 var NextNavigationUnscrambled = __toESM(require("next/navigation"));
@@ -61,23 +62,25 @@ var import_url = require("../utils/url");
 var import_auth = require("./auth");
 var import_cookie = require("./cookie");
 var NextNavigation = (0, import_compile_time.scrambleDuringCompileTime)(NextNavigationUnscrambled);
-var clientVersion = "js @stackframe/stack@2.5.7";
+var clientVersion = "js @stackframe/stack@2.5.9";
 function getUrls(partial) {
   const handler = partial.handler ?? "/handler";
+  const home = partial.home ?? "/";
+  const afterSignIn = partial.afterSignIn ?? home;
   return {
     handler,
     signIn: `${handler}/sign-in`,
-    afterSignIn: "/",
+    afterSignIn: home,
     signUp: `${handler}/sign-up`,
-    afterSignUp: "/",
+    afterSignUp: afterSignIn,
     signOut: `${handler}/sign-out`,
-    afterSignOut: "/",
+    afterSignOut: home,
     emailVerification: `${handler}/email-verification`,
     passwordReset: `${handler}/password-reset`,
     forgotPassword: `${handler}/forgot-password`,
     oauthCallback: `${handler}/oauth-callback`,
     magicLinkCallback: `${handler}/magic-link-callback`,
-    home: "/",
+    home,
     accountSettings: `${handler}/account-settings`,
     error: `${handler}/error`,
     ...(0, import_objects.filterUndefined)(partial)
@@ -85,7 +88,7 @@ function getUrls(partial) {
 }
 async function _redirectTo(url, options) {
   if (import_stack_sc.isReactServer) {
-    NextNavigation.redirect(url, options?.replace ? NextNavigation.RedirectType.replace : NextNavigation.RedirectType.push);
+    NextNavigation.redirect(url.toString(), options?.replace ? NextNavigation.RedirectType.replace : NextNavigation.RedirectType.push);
   } else {
     if (options?.replace) {
       window.location.replace(url);
@@ -188,7 +191,10 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     this._currentUserOAuthConnectionAccessTokensCache = createCacheBySession(
       async (session, [accountId, scope]) => {
         try {
-          return await this._interface.getAccessToken(accountId, scope || "", session);
+          const result = await this._interface.createProviderAccessToken(accountId, scope || "", session);
+          return {
+            accessToken: result.access_token
+          };
         } catch (err) {
           if (!(err instanceof import_stack_shared.KnownErrors.OAuthConnectionDoesNotHaveRequiredScope || err instanceof import_stack_shared.KnownErrors.OAuthConnectionNotConnectedToUser)) {
             throw err;
@@ -300,12 +306,12 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     }
     return this._uniqueIdentifier;
   }
-  async _checkFeatureSupport(featureName, options) {
-    return await this._interface.checkFeatureSupport({ ...options, featureName });
+  async _checkFeatureSupport(name, options) {
+    return await this._interface.checkFeatureSupport({ ...options, name });
   }
-  _useCheckFeatureSupport(featureName, options) {
-    (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.`);
+  _useCheckFeatureSupport(name, options) {
+    (0, import_promises.runAsynchronously)(this._checkFeatureSupport(name, options));
+    throw new import_errors.StackAssertionError(`${name} is not currently supported. Please reach out to Stack support for more information.`);
   }
   get _refreshTokenCookieName() {
     return `stack-refresh-${this.projectId}`;
@@ -552,7 +558,6 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       throw new import_errors.StackAssertionError("User not found");
     }
     return {
-      projectId: crud.project_id,
       id: crud.id,
       displayName: crud.display_name,
       primaryEmail: crud.primary_email,
@@ -569,7 +574,7 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       }
     };
   }
-  _createCurrentUserExtra(crud, session) {
+  _createUserExtra(crud, session) {
     const app = this;
     async function getConnectedAccount(id, options) {
       const scopeString = options?.scopes?.join(" ");
@@ -639,7 +644,10 @@ var _StackClientAppImpl = class __StackClientAppImpl {
         return app._updateClientUser(update, session);
       },
       sendVerificationEmail() {
-        return app._sendVerificationEmail(session);
+        if (!crud?.primary_email) {
+          throw new import_errors.StackAssertionError("User does not have a primary email");
+        }
+        return app._sendVerificationEmail(crud.primary_email, session);
       },
       updatePassword(options) {
         return app._updatePassword(options, session);
@@ -665,7 +673,7 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     const currentUser = {
       ...this._createBaseUser(crud),
       ...this._createAuth(session),
-      ...this._createCurrentUserExtra(crud, session),
+      ...this._createUserExtra(crud, session),
       ...this._isInternalProject() ? this._createInternalUserExtra(session) : {}
     };
     Object.freeze(currentUser);
@@ -686,57 +694,93 @@ var _StackClientAppImpl = class __StackClientAppImpl {
   get projectId() {
     return this._interface.projectId;
   }
+  async _isTrusted(url) {
+    return (0, import_urls.isRelative)(url);
+  }
   get urls() {
     return getUrls(this._urlOptions);
   }
-  async _redirectTo(handlerName, options) {
-    const url = this.urls[handlerName];
+  async _redirectIfTrusted(url, options) {
+    if (!await this._isTrusted(url)) {
+      throw new Error(`Redirect URL ${url} is not trusted; should be relative.`);
+    }
+    return await _redirectTo(url, options);
+  }
+  async _redirectToHandler(handlerName, options) {
+    let url = this.urls[handlerName];
     if (!url) {
       throw new Error(`No URL for handler name ${handlerName}`);
     }
-    await _redirectTo(url, options);
+    if (handlerName === "afterSignIn" || handlerName === "afterSignUp") {
+      if (import_stack_sc.isReactServer || typeof window === "undefined") {
+        try {
+          await this._checkFeatureSupport("rsc-handler-" + handlerName, {});
+        } catch (e) {
+        }
+      } else {
+        const queryParams = new URLSearchParams(window.location.search);
+        url = queryParams.get("after_auth_return_to") || url;
+      }
+    } else if (handlerName === "signIn" || handlerName === "signUp") {
+      if (import_stack_sc.isReactServer || typeof window === "undefined") {
+        try {
+          await this._checkFeatureSupport("rsc-handler-" + handlerName, {});
+        } catch (e) {
+        }
+      } else {
+        const currentUrl = new URL(window.location.href);
+        const nextUrl = new URL(url, currentUrl);
+        if (currentUrl.searchParams.has("after_auth_return_to")) {
+          nextUrl.searchParams.set("after_auth_return_to", currentUrl.searchParams.get("after_auth_return_to"));
+        } else if (currentUrl.protocol === nextUrl.protocol && currentUrl.host === nextUrl.host) {
+          nextUrl.searchParams.set("after_auth_return_to", (0, import_urls.getRelativePart)(currentUrl));
+        }
+        url = (0, import_urls.getRelativePart)(nextUrl);
+      }
+    }
+    await this._redirectIfTrusted(url, options);
   }
-  async redirectToSignIn() {
-    return await this._redirectTo("signIn");
+  async redirectToSignIn(options) {
+    return await this._redirectToHandler("signIn", options);
   }
-  async redirectToSignUp() {
-    return await this._redirectTo("signUp");
+  async redirectToSignUp(options) {
+    return await this._redirectToHandler("signUp", options);
   }
-  async redirectToSignOut() {
-    return await this._redirectTo("signOut");
+  async redirectToSignOut(options) {
+    return await this._redirectToHandler("signOut", options);
   }
-  async redirectToEmailVerification() {
-    return await this._redirectTo("emailVerification");
+  async redirectToEmailVerification(options) {
+    return await this._redirectToHandler("emailVerification", options);
   }
-  async redirectToPasswordReset() {
-    return await this._redirectTo("passwordReset");
+  async redirectToPasswordReset(options) {
+    return await this._redirectToHandler("passwordReset", options);
   }
-  async redirectToForgotPassword() {
-    return await this._redirectTo("forgotPassword");
+  async redirectToForgotPassword(options) {
+    return await this._redirectToHandler("forgotPassword", options);
   }
-  async redirectToHome() {
-    return await this._redirectTo("home");
+  async redirectToHome(options) {
+    return await this._redirectToHandler("home", options);
   }
-  async redirectToOAuthCallback() {
-    return await this._redirectTo("oauthCallback");
+  async redirectToOAuthCallback(options) {
+    return await this._redirectToHandler("oauthCallback", options);
   }
-  async redirectToMagicLinkCallback() {
-    return await this._redirectTo("magicLinkCallback");
+  async redirectToMagicLinkCallback(options) {
+    return await this._redirectToHandler("magicLinkCallback", options);
   }
-  async redirectToAfterSignIn() {
-    return await this._redirectTo("afterSignIn");
+  async redirectToAfterSignIn(options) {
+    return await this._redirectToHandler("afterSignIn", options);
   }
-  async redirectToAfterSignUp() {
-    return await this._redirectTo("afterSignUp");
+  async redirectToAfterSignUp(options) {
+    return await this._redirectToHandler("afterSignUp", options);
   }
-  async redirectToAfterSignOut() {
-    return await this._redirectTo("afterSignOut");
+  async redirectToAfterSignOut(options) {
+    return await this._redirectToHandler("afterSignOut", options);
   }
-  async redirectToAccountSettings() {
-    return await this._redirectTo("accountSettings");
+  async redirectToAccountSettings(options) {
+    return await this._redirectToHandler("accountSettings", options);
   }
-  async redirectToError() {
-    return await this._redirectTo("error");
+  async redirectToError(options) {
+    return await this._redirectToHandler("error", options);
   }
   async sendForgotPasswordEmail(email) {
     const redirectUrl = (0, import_url.constructRedirectUrl)(this.urls.passwordReset);
@@ -765,7 +809,7 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     if (crud === null) {
       switch (options?.or) {
         case "redirect": {
-          await this.redirectToSignIn();
+          await this.redirectToSignIn({ replace: true });
           break;
         }
         case "throw": {
@@ -786,7 +830,7 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     if (crud === null) {
       switch (options?.or) {
         case "redirect": {
-          setTimeout(() => router.replace(this.urls.signIn), 0);
+          (0, import_promises.runAsynchronously)(this.redirectToSignIn({ replace: true }));
           (0, import_react.suspend)();
           throw new import_errors.StackAssertionError("suspend should never return");
         }
@@ -880,9 +924,9 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     await this._interface.signOut(session);
     await this.redirectToAfterSignOut();
   }
-  async _sendVerificationEmail(session) {
+  async _sendVerificationEmail(email, session) {
     const emailVerificationRedirectUrl = (0, import_url.constructRedirectUrl)(this.urls.emailVerification);
-    return await this._interface.sendVerificationEmail(emailVerificationRedirectUrl, session);
+    return await this._interface.sendVerificationEmail(email, emailVerificationRedirectUrl, session);
   }
   async _updatePassword(options, session) {
     return await this._interface.updatePassword(options, session);
@@ -1027,7 +1071,13 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       return await this._interface.listServerTeamMemberPermissions({ teamId, userId, recursive });
     });
   }
+  async _updateServerUser(userId, update) {
+    const result = await this._interface.updateServerUser(userId, userUpdateOptionsToCrud(update));
+    await this._refreshUsers();
+    return result;
+  }
   _createBaseUser(crud) {
+    const app = this;
     if (!crud) {
       throw new import_errors.StackAssertionError("User not found");
     }
@@ -1036,10 +1086,41 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       ..."server_metadata" in crud ? {
         // server user
         serverMetadata: crud.server_metadata
-      } : {}
+      } : {},
+      async setServerMetadata(metadata) {
+        await app._updateServerUser(crud.id, { serverMetadata: metadata });
+      },
+      async setPrimaryEmail(email, options) {
+        await app._updateServerUser(crud.id, { primaryEmail: email, primaryEmailVerified: options?.verified });
+      },
+      async grantPermission(scope, permissionId) {
+        await app._interface.grantServerTeamUserPermission(scope.id, crud.id, permissionId);
+        for (const recursive of [true, false]) {
+          await app._serverTeamUserPermissionsCache.refresh([scope.id, crud.id, recursive]);
+        }
+      },
+      async revokePermission(scope, permissionId) {
+        await app._interface.revokeServerTeamUserPermission(scope.id, crud.id, permissionId);
+        for (const recursive of [true, false]) {
+          await app._serverTeamUserPermissionsCache.refresh([scope.id, crud.id, recursive]);
+        }
+      },
+      async delete() {
+        const res = await app._interface.deleteServerServerUser(crud.id);
+        await app._refreshUsers();
+        return res;
+      },
+      async createSession(options) {
+        const tokens = await app._interface.createServerUserSession(crud.id, options.expiresInMillis ?? 1e3 * 60 * 60 * 24 * 365);
+        return {
+          async getTokens() {
+            return tokens;
+          }
+        };
+      }
     };
   }
-  _createCurrentUserExtra(crud) {
+  _createUserExtra(crud) {
     if (!crud) {
       throw new import_errors.StackAssertionError("User not found");
     }
@@ -1051,15 +1132,9 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       async setClientMetadata(metadata) {
         return await this.update({ clientMetadata: metadata });
       },
-      async setServerMetadata(metadata) {
-        return await this.update({ serverMetadata: metadata });
-      },
       async setSelectedTeam(team) {
         return await this.update({ selectedTeamId: team?.id ?? null });
       },
-      async setPrimaryEmail(email, options) {
-        return await this.update({ primaryEmail: email, primaryEmailVerified: options?.verified });
-      },
       getConnectedAccount: async () => {
         return await app._checkFeatureSupport("getConnectedAccount() on ServerUser", {});
       },
@@ -1106,26 +1181,8 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       async hasPermission(scope, permissionId) {
         return await this.getPermission(scope, permissionId) !== null;
       },
-      async grantPermission(scope, permissionId) {
-        await app._interface.grantServerTeamUserPermission(scope.id, crud.id, permissionId);
-        for (const recursive of [true, false]) {
-          await app._serverTeamUserPermissionsCache.refresh([scope.id, crud.id, recursive]);
-        }
-      },
-      async revokePermission(scope, permissionId) {
-        await app._interface.revokeServerTeamUserPermission(scope.id, crud.id, permissionId);
-        for (const recursive of [true, false]) {
-          await app._serverTeamUserPermissionsCache.refresh([scope.id, crud.id, recursive]);
-        }
-      },
-      async delete() {
-        const res = await app._interface.deleteServerServerUser(crud.id);
-        await app._refreshUsers();
-        return res;
-      },
       async update(update) {
-        const res = await app._interface.updateServerUser(crud.id, serverUserUpdateOptionsToCrud(update));
-        await app._refreshUsers();
+        await app._updateServerUser(crud.id, update);
       },
       async sendVerificationEmail() {
         return await app._checkFeatureSupport("sendVerificationEmail() on ServerUser", {});
@@ -1137,8 +1194,8 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
   }
   _serverUserFromCrud(crud) {
     return {
-      ...this._createBaseUser(crud),
-      ...this._createCurrentUserExtra(crud)
+      ...this._createUserExtra(crud),
+      ...this._createBaseUser(crud)
     };
   }
   _currentUserFromCrud(crud, session) {
@@ -1196,7 +1253,7 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
     if (crud === null) {
       switch (options?.or) {
         case "redirect": {
-          await this.redirectToSignIn();
+          await this.redirectToSignIn({ replace: true });
           break;
         }
         case "throw": {
@@ -1225,7 +1282,7 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
     if (crud === null) {
       switch (options?.or) {
         case "redirect": {
-          setTimeout(() => router.replace(this.urls.signIn), 0);
+          (0, import_promises.runAsynchronously)(this.redirectToSignIn({ replace: true }));
           (0, import_react.suspend)();
           throw new import_errors.StackAssertionError("suspend should never return");
         }
@@ -1541,16 +1598,6 @@ function userUpdateOptionsToCrud(options) {
     selected_team_id: options.selectedTeamId
   };
 }
-function serverUserUpdateOptionsToCrud(options) {
-  return {
-    display_name: options.displayName,
-    client_metadata: options.clientMetadata,
-    selected_team_id: options.selectedTeamId,
-    primary_email: options.primaryEmail,
-    primary_email_verified: options.primaryEmailVerified,
-    server_metadata: options.serverMetadata
-  };
-}
 function adminProjectUpdateOptionsToCrud(options) {
   return {
     display_name: options.displayName,