@stackframe/stack 2.6.33 → 2.6.36

package/dist/lib/stack-app.d.ts

@@ -109,7 +109,9 @@ type Session = {
 type Auth = {
     readonly _internalSession: InternalSession;
     readonly currentSession: Session;
-    signOut(): Promise<void>;
+    signOut(options?: {
+        redirectUrl?: URL | string;
+    }): Promise<void>;
     /**
      * Returns headers for sending authenticated HTTP requests to external servers. Most commonly used in cross-origin
      * requests. Similar to `getAuthJson`, but specifically for HTTP requests.
@@ -628,8 +630,12 @@ type StackClientApp<HasTokenStore extends boolean = boolean, ProjectId extends s
     }): Promise<Result<undefined, KnownErrors["UserEmailAlreadyExists"] | KnownErrors["PasswordRequirementsNotMet"]>>;
     signInWithPasskey(): Promise<Result<undefined, KnownErrors["PasskeyAuthenticationFailed"] | KnownErrors["InvalidTotpCode"] | KnownErrors["PasskeyWebAuthnError"]>>;
     callOAuthCallback(): Promise<boolean>;
-    sendForgotPasswordEmail(email: string): Promise<Result<undefined, KnownErrors["UserNotFound"]>>;
-    sendMagicLinkEmail(email: string): Promise<Result<{
+    sendForgotPasswordEmail(email: string, options?: {
+        callbackUrl?: string;
+    }): Promise<Result<undefined, KnownErrors["UserNotFound"]>>;
+    sendMagicLinkEmail(email: string, options?: {
+        callbackUrl?: string;
+    }): Promise<Result<{
         nonce: string;
     }, KnownErrors["RedirectUrlNotWhitelisted"]>>;
     resetPassword(options: {

package/dist/lib/stack-app.js

@@ -64,7 +64,7 @@ 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.6.33";
+var clientVersion = "js @stackframe/stack@2.6.36";
 function getUrls(partial) {
   const handler = partial.handler ?? "/handler";
   const home = partial.home ?? "/";
@@ -148,14 +148,15 @@ function useAsyncCache(cache, dependencies, caller) {
   const result = import_react2.default.use(promise);
   if (result.status === "error") {
     const error = result.error;
-    if (error instanceof Error) {
+    if (error instanceof Error && !error.__stackHasConcatenatedStacktraces) {
       (0, import_errors.concatStacktraces)(error, new Error());
+      error.__stackHasConcatenatedStacktraces = true;
     }
     throw error;
   }
   return result.data;
 }
-var stackAppInternalsSymbol = Symbol.for("StackAppInternals");
+var stackAppInternalsSymbol = Symbol.for("StackAuth--DO-NOT-USE-OR-YOU-WILL-BE-FIRED--StackAppInternals");
 var allClientApps = /* @__PURE__ */ new Map();
 var createCache = (fetcher) => {
   return new import_caches.AsyncCache(
@@ -185,6 +186,9 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       if (this.__DEMO_ENABLE_SLIGHT_FETCH_DELAY) {
         await (0, import_promises.wait)(2e3);
       }
+      if (session.isKnownToBeInvalid()) {
+        return null;
+      }
       return await this._interface.getClientUserByToken(session);
     });
     this._currentProjectCache = createCache(async () => {
@@ -712,8 +716,8 @@ var _StackClientAppImpl = class __StackClientAppImpl {
         await app._refreshUser(session);
         return registrationResult;
       },
-      signOut() {
-        return app._signOut(session);
+      signOut(options) {
+        return app._signOut(session, options);
       }
     };
   }
@@ -831,11 +835,14 @@ var _StackClientAppImpl = class __StackClientAppImpl {
       async update(update) {
         return await app._updateClientUser(update, session);
       },
-      async sendVerificationEmail() {
+      async sendVerificationEmail(options) {
         if (!crud.primary_email) {
           throw new import_errors.StackAssertionError("User does not have a primary email");
         }
-        return await app._sendVerificationEmail(crud.primary_email, session);
+        if (!options?.callbackUrl && typeof window === "undefined") {
+          throw new Error("Cannot send verification email without a callback URL from the server. Make sure you pass the `callbackUrl` option: `sendVerificationEmail({ callbackUrl: ... })`");
+        }
+        return await app._interface.sendVerificationEmail(crud.primary_email, options?.callbackUrl ?? (0, import_url.constructRedirectUrl)(app.urls.emailVerification), session);
       },
       async updatePassword(options) {
         const result = await app._interface.updatePassword(options, session);
@@ -1008,13 +1015,17 @@ var _StackClientAppImpl = class __StackClientAppImpl {
   async redirectToTeamInvitation(options) {
     return await this._redirectToHandler("teamInvitation", options);
   }
-  async sendForgotPasswordEmail(email) {
-    const redirectUrl = (0, import_url.constructRedirectUrl)(this.urls.passwordReset);
-    return await this._interface.sendForgotPasswordEmail(email, redirectUrl);
+  async sendForgotPasswordEmail(email, options) {
+    if (!options?.callbackUrl && typeof window === "undefined") {
+      throw new Error("Cannot send forgot password email without a callback URL from the server. Make sure you pass the `callbackUrl` option: `sendForgotPasswordEmail({ email, callbackUrl: ... })`");
+    }
+    return await this._interface.sendForgotPasswordEmail(email, options?.callbackUrl ?? (0, import_url.constructRedirectUrl)(this.urls.passwordReset));
   }
-  async sendMagicLinkEmail(email) {
-    const magicLinkRedirectUrl = (0, import_url.constructRedirectUrl)(this.urls.magicLinkCallback);
-    return await this._interface.sendMagicLinkEmail(email, magicLinkRedirectUrl);
+  async sendMagicLinkEmail(email, options) {
+    if (!options?.callbackUrl && typeof window === "undefined") {
+      throw new Error("Cannot send magic link email without a callback URL from the server. Make sure you pass the `callbackUrl` option: `sendMagicLinkEmail({ email, callbackUrl: ... })`");
+    }
+    return await this._interface.sendMagicLinkEmail(email, options?.callbackUrl ?? (0, import_url.constructRedirectUrl)(this.urls.magicLinkCallback));
   }
   async resetPassword(options) {
     return await this._interface.resetPassword(options);
@@ -1279,18 +1290,18 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     }
     return false;
   }
-  async _signOut(session) {
+  async _signOut(session, options) {
     await this._interface.signOut(session);
-    await this.redirectToAfterSignOut();
-  }
-  async _sendVerificationEmail(email, session) {
-    const emailVerificationRedirectUrl = (0, import_url.constructRedirectUrl)(this.urls.emailVerification);
-    return await this._interface.sendVerificationEmail(email, emailVerificationRedirectUrl, session);
+    if (options?.redirectUrl) {
+      await _redirectTo(options.redirectUrl);
+    } else {
+      await this.redirectToAfterSignOut();
+    }
   }
-  async signOut() {
+  async signOut(options) {
     const user = await this.getUser();
     if (user) {
-      await user.signOut();
+      await user.signOut(options);
     }
   }
   async getProject() {
@@ -1366,7 +1377,7 @@ var _StackClientAppImpl = class __StackClientAppImpl {
     return {
       toClientJson: () => {
         if (!("publishableClientKey" in this._interface.options)) {
-          throw Error("Cannot serialize to JSON from an application without a publishable client key");
+          throw new import_errors.StackAssertionError("Cannot serialize to JSON from an application without a publishable client key");
         }
         return {
           baseUrl: this._interface.options.baseUrl,
@@ -1382,6 +1393,9 @@ var _StackClientAppImpl = class __StackClientAppImpl {
         (0, import_promises.runAsynchronously)(async () => {
           await this._currentUserCache.forceSetCachedValueAsync([await this._getSession()], import_results.Result.fromPromise(userJsonPromise));
         });
+      },
+      sendRequest: async (path, requestOptions, requestType = "client") => {
+        return await this._interface.sendClientRequest(path, requestOptions, await this._getSession(), requestType);
       }
     };
   }
@@ -1407,6 +1421,9 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
     });
     // TODO override the client user cache to use the server user cache, so we save some requests
     this._currentServerUserCache = createCacheBySession(async (session) => {
+      if (session.isKnownToBeInvalid()) {
+        return null;
+      }
       return await this._interface.getServerUserByToken(session);
     });
     this._serverUsersCache = createCache(async ([cursor, limit, orderBy, desc, query]) => {
@@ -1501,8 +1518,11 @@ var _StackServerAppImpl = class extends _StackClientAppImpl {
       isVerified: crud.is_verified,
       isPrimary: crud.is_primary,
       usedForAuth: crud.used_for_auth,
-      async sendVerificationEmail() {
-        await app._interface.sendServerContactChannelVerificationEmail(userId, crud.id, (0, import_url.constructRedirectUrl)(app.urls.emailVerification));
+      async sendVerificationEmail(options) {
+        if (!options?.callbackUrl && typeof window === "undefined") {
+          throw new Error("Cannot send verification email without a callback URL from the server. Make sure you pass the `callbackUrl` option: `sendVerificationEmail({ callbackUrl: ... })`");
+        }
+        await app._interface.sendServerContactChannelVerificationEmail(userId, crud.id, options?.callbackUrl ?? (0, import_url.constructRedirectUrl)(app.urls.emailVerification));
       },
       async update(data) {
         await app._interface.updateServerContactChannel(userId, crud.id, serverContactChannelUpdateOptionsToCrud(data));