@stackframe/stack-shared 2.4.13 → 2.4.14

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @stackframe/stack-shared
 
+## 2.4.14
+
+### Patch Changes
+
+- Bugfixes
+
 ## 2.4.13
 
 ### Patch Changes

package/dist/hooks/use-trigger.d.ts

@@ -0,0 +1 @@
+export declare function useTrigger(callback: () => void): () => void;

package/dist/hooks/use-trigger.js

@@ -0,0 +1,10 @@
+import * as React from "react";
+export function useTrigger(callback) {
+    const [hasTriggered, setHasTriggered] = React.useState(false);
+    React.useEffect(() => {
+        if (hasTriggered) {
+            callback();
+        }
+    }, [hasTriggered]);
+    return () => setHasTriggered(true);
+}

package/dist/interface/adminInterface.d.ts

@@ -1,9 +1,10 @@
 import { ServerAuthApplicationOptions, StackServerInterface } from "./serverInterface";
-import { EmailConfigJson, ProjectJson, ReadonlyTokenStore, SharedProvider, StandardProvider, TokenStore } from "./clientInterface";
+import { EmailConfigJson, ProjectJson, SharedProvider, StandardProvider } from "./clientInterface";
+import { Session } from "../sessions";
 export type AdminAuthApplicationOptions = Readonly<ServerAuthApplicationOptions & ({
     superSecretAdminKey: string;
 } | {
-    projectOwnerTokens: ReadonlyTokenStore;
+    projectOwnerSession: Session;
 })>;
 export type OAuthProviderUpdateOptions = {
     id: string;
@@ -66,11 +67,11 @@ export type ApiKeySetCreateOptions = {
 export declare class StackAdminInterface extends StackServerInterface {
     readonly options: AdminAuthApplicationOptions;
     constructor(options: AdminAuthApplicationOptions);
-    protected sendAdminRequest(path: string, options: RequestInit, tokenStore: TokenStore | null, requestType?: "admin"): Promise<Response & {
-        usedTokens: Readonly<{
-            refreshToken: string | null;
-            accessToken: string | null;
-        }>;
+    protected sendAdminRequest(path: string, options: RequestInit, session: Session | null, requestType?: "admin"): Promise<Response & {
+        usedTokens: {
+            accessToken: import("../sessions").AccessToken;
+            refreshToken: import("../sessions").RefreshToken | null;
+        } | null;
     }>;
     getProject(options?: {
         showDisabledOAuth?: boolean;
@@ -79,5 +80,5 @@ export declare class StackAdminInterface extends StackServerInterface {
     createApiKeySet(options: ApiKeySetCreateOptions): Promise<ApiKeySetFirstViewJson>;
     listApiKeySets(): Promise<ApiKeySetJson[]>;
     revokeApiKeySetById(id: string): Promise<void>;
-    getApiKeySet(id: string, tokenStore: TokenStore): Promise<ApiKeySetJson>;
+    getApiKeySet(id: string, session: Session): Promise<ApiKeySetJson>;
 }

package/dist/interface/adminInterface.js

@@ -5,14 +5,14 @@ export class StackAdminInterface extends StackServerInterface {
         super(options);
         this.options = options;
     }
-    async sendAdminRequest(path, options, tokenStore, requestType = "admin") {
+    async sendAdminRequest(path, options, session, requestType = "admin") {
         return await this.sendServerRequest(path, {
             ...options,
             headers: {
                 "x-stack-super-secret-admin-key": "superSecretAdminKey" in this.options ? this.options.superSecretAdminKey : "",
                 ...options.headers,
             },
-        }, tokenStore, requestType);
+        }, session, requestType);
     }
     async getProject(options) {
         const response = await this.sendAdminRequest("/projects/" + encodeURIComponent(this.projectId), {
@@ -60,8 +60,8 @@ export class StackAdminInterface extends StackServerInterface {
             }),
         }, null);
     }
-    async getApiKeySet(id, tokenStore) {
-        const response = await this.sendAdminRequest(`/api-keys/${id}`, {}, tokenStore);
+    async getApiKeySet(id, session) {
+        const response = await this.sendAdminRequest(`/api-keys/${id}`, {}, session);
         return await response.json();
     }
 }

package/dist/interface/clientInterface.d.ts

@@ -1,9 +1,8 @@
-import * as oauth from 'oauth4webapi';
 import { Result } from "../utils/results";
 import { ReadonlyJson } from '../utils/json';
-import { AsyncStore, ReadonlyAsyncStore } from '../utils/stores';
 import { KnownErrors } from '../known-errors';
 import { ProjectUpdateOptions } from './adminInterface';
+import { AccessToken, RefreshToken, Session } from '../sessions';
 type UserCustomizableJson = {
     displayName: string | null;
     clientMetadata: ReadonlyJson;
@@ -44,8 +43,7 @@ export type ClientInterfaceOptions = {
 } & ({
     publishableClientKey: string;
 } | {
-    projectOwnerTokens: TokenStore;
-    refreshProjectOwnerTokens: () => Promise<void>;
+    projectOwnerSession: Session;
 });
 export type SharedProvider = "shared-github" | "shared-google" | "shared-facebook" | "shared-microsoft" | "shared-spotify";
 export declare const sharedProviders: readonly ["shared-github", "shared-google", "shared-facebook", "shared-microsoft", "shared-spotify"];
@@ -53,12 +51,6 @@ export type StandardProvider = "github" | "facebook" | "google" | "microsoft" |
 export declare const standardProviders: readonly ["github", "facebook", "google", "microsoft", "spotify"];
 export declare function toStandardProvider(provider: SharedProvider | StandardProvider): StandardProvider;
 export declare function toSharedProvider(provider: SharedProvider | StandardProvider): SharedProvider;
-export type ReadonlyTokenStore = ReadonlyAsyncStore<TokenObject>;
-export type TokenStore = AsyncStore<TokenObject>;
-export type TokenObject = Readonly<{
-    refreshToken: string | null;
-    accessToken: string | null;
-}>;
 export type ProjectJson = {
     id: string;
     displayName: string;
@@ -136,20 +128,24 @@ export declare class StackClientInterface {
     constructor(options: ClientInterfaceOptions);
     get projectId(): string;
     getApiUrl(): string;
-    refreshAccessToken(tokenStore: TokenStore): Promise<void>;
-    protected sendClientRequest(path: string, requestOptions: RequestInit, tokenStoreOrNull: TokenStore | null, requestType?: "client" | "server" | "admin"): Promise<Response & {
-        usedTokens: Readonly<{
-            refreshToken: string | null;
-            accessToken: string | null;
-        }>;
+    fetchNewAccessToken(refreshToken: RefreshToken): Promise<AccessToken | null>;
+    protected sendClientRequest(path: string, requestOptions: RequestInit, session: Session | null, requestType?: "client" | "server" | "admin"): Promise<Response & {
+        usedTokens: {
+            accessToken: AccessToken;
+            refreshToken: RefreshToken | null;
+        } | null;
     }>;
-    protected sendClientRequestAndCatchKnownError<E extends typeof KnownErrors[keyof KnownErrors]>(path: string, requestOptions: RequestInit, tokenStoreOrNull: TokenStore | null, errorsToCatch: readonly E[]): Promise<Result<Response & {
-        usedTokens: TokenObject;
+    createSession(options: Omit<ConstructorParameters<typeof Session>[0], "refreshAccessTokenCallback">): Session;
+    protected sendClientRequestAndCatchKnownError<E extends typeof KnownErrors[keyof KnownErrors]>(path: string, requestOptions: RequestInit, tokenStoreOrNull: Session | null, errorsToCatch: readonly E[]): Promise<Result<Response & {
+        usedTokens: {
+            accessToken: AccessToken;
+            refreshToken: RefreshToken | null;
+        } | null;
     }, InstanceType<E>>>;
     private sendClientRequestInner;
     private _processResponse;
     sendForgotPasswordEmail(email: string, redirectUrl: string): Promise<KnownErrors["UserNotFound"] | undefined>;
-    sendVerificationEmail(emailVerificationRedirectUrl: string, tokenStore: TokenStore): Promise<KnownErrors["EmailAlreadyVerified"] | undefined>;
+    sendVerificationEmail(emailVerificationRedirectUrl: string, session: Session): Promise<KnownErrors["EmailAlreadyVerified"] | undefined>;
     sendMagicLinkEmail(email: string, redirectUrl: string): Promise<KnownErrors["RedirectUrlNotWhitelisted"] | undefined>;
     resetPassword(options: {
         code: string;
@@ -161,30 +157,42 @@ export declare class StackClientInterface {
     updatePassword(options: {
         oldPassword: string;
         newPassword: string;
-    }, tokenStore: TokenStore): Promise<KnownErrors["PasswordMismatch"] | KnownErrors["PasswordRequirementsNotMet"] | undefined>;
+    }, session: Session): Promise<KnownErrors["PasswordMismatch"] | KnownErrors["PasswordRequirementsNotMet"] | undefined>;
     verifyPasswordResetCode(code: string): Promise<KnownErrors["PasswordResetCodeError"] | undefined>;
     verifyEmail(code: string): Promise<KnownErrors["EmailVerificationError"] | undefined>;
-    signInWithCredential(email: string, password: string, tokenStore: TokenStore): Promise<KnownErrors["EmailPasswordMismatch"] | undefined>;
-    signUpWithCredential(email: string, password: string, emailVerificationRedirectUrl: string, tokenStore: TokenStore): Promise<KnownErrors["UserEmailAlreadyExists"] | KnownErrors["PasswordRequirementsNotMet"] | undefined>;
-    signInWithMagicLink(code: string, tokenStore: TokenStore): Promise<KnownErrors["MagicLinkError"] | {
+    signInWithCredential(email: string, password: string, session: Session): Promise<KnownErrors["EmailPasswordMismatch"] | {
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signUpWithCredential(email: string, password: string, emailVerificationRedirectUrl: string, session: Session): Promise<KnownErrors["UserEmailAlreadyExists"] | KnownErrors["PasswordRequirementsNotMet"] | {
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signInWithMagicLink(code: string, session: Session): Promise<KnownErrors["MagicLinkError"] | {
         newUser: boolean;
+        accessToken: string;
+        refreshToken: string;
     }>;
     getOAuthUrl(provider: string, redirectUrl: string, codeChallenge: string, state: string): Promise<string>;
-    callOAuthCallback(oauthParams: URLSearchParams, redirectUri: string, codeVerifier: string, state: string, tokenStore: TokenStore): Promise<oauth.OAuth2TokenEndpointResponse>;
-    signOut(tokenStore: TokenStore): Promise<void>;
-    getClientUserByToken(tokenStore: TokenStore): Promise<Result<UserJson>>;
+    callOAuthCallback(oauthParams: URLSearchParams, redirectUri: string, codeVerifier: string, state: string): Promise<{
+        newUser: boolean;
+        accessToken: string;
+        refreshToken: string;
+    }>;
+    signOut(session: Session): Promise<void>;
+    getClientUserByToken(tokenStore: Session): Promise<Result<UserJson>>;
     listClientUserTeamPermissions(options: {
         teamId: string;
         type: 'global' | 'team';
         direct: boolean;
-    }, tokenStore: TokenStore): Promise<PermissionDefinitionJson[]>;
-    listClientUserTeams(tokenStore: TokenStore): Promise<TeamJson[]>;
+    }, session: Session): Promise<PermissionDefinitionJson[]>;
+    listClientUserTeams(session: Session): Promise<TeamJson[]>;
     getClientProject(): Promise<Result<ClientProjectJson>>;
-    setClientUserCustomizableData(update: UserUpdateJson, tokenStore: TokenStore): Promise<void>;
-    listProjects(tokenStore: TokenStore): Promise<ProjectJson[]>;
+    setClientUserCustomizableData(update: UserUpdateJson, session: Session): Promise<void>;
+    listProjects(session: Session): Promise<ProjectJson[]>;
     createProject(project: ProjectUpdateOptions & {
         displayName: string;
-    }, tokenStore: TokenStore): Promise<ProjectJson>;
+    }, session: Session): Promise<ProjectJson>;
 }
 export declare function getProductionModeErrors(project: ProjectJson): ProductionModeError[];
 export {};