@stackframe/stack 1.0.0

package/dist/lib/stack-app.js

@@ -0,0 +1,575 @@
+import React, { use, useCallback } from "react";
+import { StackAdminInterface, StackClientInterface, StackServerInterface } from "@stackframe/stack-shared";
+import { getCookie, setOrDeleteCookie } from "./cookie";
+import { throwErr } from "@stackframe/stack-shared/dist/utils/errors";
+import { generateUuid } from "@stackframe/stack-shared/dist/utils/uuids";
+import { AsyncResult } from "@stackframe/stack-shared/dist/utils/results";
+import { suspendIfSsr } from "@stackframe/stack-shared/dist/utils/react";
+import { AsyncStore } from "@stackframe/stack-shared/dist/utils/stores";
+import { isClient } from "../utils/next";
+import { callOauthCallback, signInWithCredential, signInWithOauth, signUpWithCredential } from "./auth";
+import { RedirectType, redirect, useRouter } from "next/navigation";
+import { constructRedirectUrl } from "../utils/url";
+import { filterUndefined } from "@stackframe/stack-shared/dist/utils/objects";
+import { neverResolve, resolved } from "@stackframe/stack-shared/dist/utils/promises";
+function getUrls(partial) {
+    const handler = partial.handler ?? "/handler";
+    return {
+        handler,
+        signIn: `${handler}/signin`,
+        signUp: `${handler}/signup`,
+        signOut: `${handler}/signout`,
+        emailVerification: `${handler}/email-verification`,
+        passwordReset: `${handler}/password-reset`,
+        forgotPassword: `${handler}/forgot-password`,
+        oauthCallback: `${handler}/oauth-callback`,
+        home: "/",
+        userHome: "/",
+        ...filterUndefined(partial),
+    };
+}
+function getDefaultProjectId() {
+    return process.env.NEXT_PUBLIC_STACK_PROJECT_ID || throwErr("No project ID provided. Please copy your project ID from the Stack dashboard and put it in the NEXT_PUBLIC_STACK_PROJECT_ID environment variable.");
+}
+function getDefaultPublishableClientKey() {
+    return process.env.NEXT_PUBLIC_STACK_PUBLISHABLE_CLIENT_KEY || throwErr("No publishable client key provided. Please copy your publishable client key from the Stack dashboard and put it in the NEXT_PUBLIC_STACK_PUBLISHABLE_CLIENT_KEY environment variable.");
+}
+function getDefaultSecretServerKey() {
+    return process.env.STACK_SECRET_SERVER_KEY || throwErr("No secret server key provided. Please copy your publishable client key from the Stack dashboard and put your it in the STACK_SECRET_SERVER_KEY environment variable.");
+}
+function getDefaultSuperSecretAdminKey() {
+    return process.env.STACK_SUPER_SECRET_ADMIN_KEY || throwErr("No super secret admin key provided. Please copy your publishable client key from the Stack dashboard and put it in the STACK_SUPER_SECRET_ADMIN_KEY environment variable.");
+}
+function getDefaultBaseUrl() {
+    return process.env.NEXT_PUBLIC_STACK_URL || defaultBaseUrl;
+}
+const defaultBaseUrl = "https://api.stackframe.co";
+function createEmptyTokenStore() {
+    const store = new AsyncStore();
+    store.set({
+        refreshToken: null,
+        accessToken: null,
+    });
+    return store;
+}
+const memoryTokenStore = createEmptyTokenStore();
+let cookieTokenStore = null;
+const cookieTokenStoreInitializer = () => {
+    if (!isClient()) {
+        throw new Error("Cannot use cookie token store on the server!");
+    }
+    if (cookieTokenStore === null) {
+        cookieTokenStore = new AsyncStore();
+        let hasSucceededInWriting = true;
+        setInterval(() => {
+            if (hasSucceededInWriting) {
+                const newValue = {
+                    refreshToken: getCookie('stack-refresh'),
+                    accessToken: getCookie('stack-access'),
+                };
+                const res = cookieTokenStore.get();
+                if (res.status !== "ok"
+                    || res.data.refreshToken !== newValue.refreshToken
+                    || res.data.accessToken !== newValue.accessToken) {
+                    cookieTokenStore.set(newValue);
+                }
+            }
+        }, 10);
+        cookieTokenStore.onChange((value) => {
+            try {
+                setOrDeleteCookie('stack-refresh', value.refreshToken);
+                setOrDeleteCookie('stack-access', value.accessToken);
+                hasSucceededInWriting = true;
+            }
+            catch (e) {
+                hasSucceededInWriting = false;
+            }
+        });
+    }
+    return cookieTokenStore;
+};
+const tokenStoreInitializers = new Map([
+    ["cookie", cookieTokenStoreInitializer],
+    ["nextjs-cookie", () => {
+            if (isClient()) {
+                return cookieTokenStoreInitializer();
+            }
+            else {
+                const store = new AsyncStore();
+                store.set({
+                    refreshToken: getCookie('stack-refresh'),
+                    accessToken: getCookie('stack-access'),
+                });
+                store.onChange((value) => {
+                    try {
+                        setOrDeleteCookie('stack-refresh', value.refreshToken);
+                        setOrDeleteCookie('stack-access', value.accessToken);
+                    }
+                    catch (e) {
+                        // ignore
+                    }
+                });
+                return store;
+            }
+        }],
+    ["memory", () => memoryTokenStore],
+    [null, () => createEmptyTokenStore()],
+]);
+function getTokenStore(tokenStoreOptions) {
+    return (tokenStoreInitializers.get(tokenStoreOptions) ?? throwErr(`Invalid token store ${tokenStoreOptions}`))();
+}
+const loadingSentinel = Symbol("stackAppCacheLoadingSentinel");
+function useValueCache(cache) {
+    // we explicitly don't want to run this hook in SSR
+    suspendIfSsr();
+    const subscribe = useCallback((cb) => {
+        const { unsubscribe } = cache.onChange(() => cb());
+        return unsubscribe;
+    }, [cache]);
+    const getSnapshot = useCallback(() => {
+        return AsyncResult.or(cache.get(), loadingSentinel);
+    }, [cache]);
+    // note: we must use React.useSyncExternalStore instead of importing the function directly, as it will otherwise
+    // throw an error ("can't import useSyncExternalStore from the server")
+    const value = React.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    if (value === loadingSentinel) {
+        return use(cache.getOrWait());
+    }
+    else {
+        // still need to call `use` because React expects the control flow to not change
+        return use(resolved(value));
+    }
+}
+export const stackAppInternalsSymbol = Symbol.for("StackAppInternals");
+const allClientApps = new Map();
+class _StackClientAppImpl {
+    _uniqueIdentifier;
+    _interface;
+    _tokenStoreOptions;
+    _urlOptions;
+    constructor(options) {
+        if ("interface" in options) {
+            this._interface = options.interface;
+        }
+        else {
+            this._interface = new StackClientInterface({
+                baseUrl: options.baseUrl ?? getDefaultBaseUrl(),
+                projectId: options.projectId ?? getDefaultProjectId(),
+                publishableClientKey: options.publishableClientKey ?? getDefaultPublishableClientKey(),
+            });
+        }
+        this._tokenStoreOptions = options.tokenStore;
+        this._urlOptions = options.urls ?? {};
+        this._uniqueIdentifier = options.uniqueIdentifier ?? generateUuid();
+        if (allClientApps.has(this._uniqueIdentifier)) {
+            throw new Error("A Stack client app with the same unique identifier already exists");
+        }
+        allClientApps.set(this._uniqueIdentifier, [options.checkString ?? "default check string", this]);
+    }
+    _ensurePersistentTokenStore() {
+        if (!this._tokenStoreOptions) {
+            throw new Error("Cannot call this function on a Stack app without a persistent token store. Make sure the tokenStore option is set to a non-null value when initializing Stack.");
+        }
+    }
+    _ensureInternalProject() {
+        if (this.projectId !== "internal") {
+            throw new Error("Cannot call this function on a Stack app with a project ID other than 'internal'.");
+        }
+    }
+    _userFromJson(json) {
+        return {
+            projectId: json.projectId,
+            id: json.id,
+            displayName: json.displayName,
+            primaryEmail: json.primaryEmail,
+            primaryEmailVerified: json.primaryEmailVerified,
+            profileImageUrl: json.profileImageUrl,
+            signedUpAt: new Date(json.signedUpAtMillis),
+            clientMetadata: json.clientMetadata,
+            toJson() {
+                return json;
+            }
+        };
+    }
+    _currentUserFromJson(json, tokenStore) {
+        if (json === null)
+            return null;
+        const app = this;
+        const res = {
+            ...this._userFromJson(json),
+            get accessToken() {
+                return AsyncResult.or(tokenStore.get(), null)?.accessToken ?? null;
+            },
+            get refreshToken() {
+                return AsyncResult.or(tokenStore.get(), null)?.refreshToken ?? null;
+            },
+            update(update) {
+                return app._updateUser(update, tokenStore);
+            },
+            signOut(redirectUrl) {
+                return app._signOut(tokenStore, redirectUrl);
+            },
+        };
+        Object.freeze(res);
+        return res;
+    }
+    _userToJson(user) {
+        return {
+            projectId: user.projectId,
+            id: user.id,
+            displayName: user.displayName,
+            primaryEmail: user.primaryEmail,
+            primaryEmailVerified: user.primaryEmailVerified,
+            profileImageUrl: user.profileImageUrl,
+            signedUpAtMillis: user.signedUpAt.getTime(),
+            clientMetadata: user.clientMetadata,
+        };
+    }
+    _projectAdminFromJson(data) {
+        return {
+            id: data.id,
+            displayName: data.displayName,
+            description: data.description,
+            createdAt: new Date(data.createdAtMillis),
+            userCount: data.userCount,
+            isProductionMode: data.isProductionMode,
+            evaluatedConfig: {
+                id: data.evaluatedConfig.id,
+                allowLocalhost: data.evaluatedConfig.allowLocalhost,
+                oauthProviders: data.evaluatedConfig.oauthProviders,
+                emailConfig: data.evaluatedConfig.emailConfig,
+                domains: data.evaluatedConfig.domains,
+            },
+        };
+    }
+    get projectId() {
+        return this._interface.projectId;
+    }
+    get urls() {
+        return getUrls(this._urlOptions);
+    }
+    _redirectTo(handlerName) {
+        if (!this.urls[handlerName]) {
+            throw new Error(`No URL for handler name ${handlerName}`);
+        }
+        window.location.href = this.urls[handlerName];
+        return neverResolve();
+    }
+    async redirectToHandler() { return await this._redirectTo("handler"); }
+    async redirectToSignIn() { return await this._redirectTo("signIn"); }
+    async redirectToSignUp() { return await this._redirectTo("signUp"); }
+    async redirectToSignOut() { return await this._redirectTo("signOut"); }
+    async redirectToEmailVerification() { return await this._redirectTo("emailVerification"); }
+    async redirectToPasswordReset() { return await this._redirectTo("passwordReset"); }
+    async redirectToForgotPassword() { return await this._redirectTo("forgotPassword"); }
+    async redirectToHome() { return await this._redirectTo("home"); }
+    async redirectToUserHome() { return await this._redirectTo("userHome"); }
+    async redirectToOauthCallback() { return await this._redirectTo("oauthCallback"); }
+    async sendForgotPasswordEmail(email) {
+        const redirectUrl = constructRedirectUrl(this.urls.passwordReset);
+        await this._interface.sendForgotPasswordEmail(email, redirectUrl);
+    }
+    async resetPassword(options) {
+        return await this._interface.resetPassword(options);
+    }
+    async verifyPasswordResetCode(code) {
+        return await this._interface.verifyPasswordResetCode(code);
+    }
+    async verifyEmail(code) {
+        return await this._interface.verifyEmail(code);
+    }
+    async getUser(options) {
+        this._ensurePersistentTokenStore();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        const userJson = await this._interface.currentUserCache.getOrWait(tokenStore);
+        if (userJson === null) {
+            switch (options?.or) {
+                case 'redirect': {
+                    redirect(this.urls.signIn, RedirectType.replace);
+                    throw new Error("redirect should never return!");
+                }
+                case 'throw': {
+                    throw new Error("User is not signed in");
+                }
+                default: {
+                    return null;
+                }
+            }
+        }
+        return this._currentUserFromJson(userJson, tokenStore);
+    }
+    useUser(options) {
+        this._ensurePersistentTokenStore();
+        const router = useRouter();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        const userJson = useValueCache(this._interface.currentUserCache.getValueCache(tokenStore));
+        if (userJson === null) {
+            switch (options?.or) {
+                case 'redirect': {
+                    router.replace(this.urls.signIn);
+                    break;
+                }
+                case 'throw': {
+                    throw new Error("User is not signed in");
+                }
+                default: {
+                    return null;
+                }
+            }
+        }
+        return this._currentUserFromJson(userJson, tokenStore);
+    }
+    onUserChange(callback) {
+        this._ensurePersistentTokenStore();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        return this._interface.currentUserCache.getValueCache(tokenStore).onChange((userJson) => {
+            callback(this._currentUserFromJson(userJson, tokenStore));
+        });
+    }
+    async _updateUser(update, tokenStore) {
+        return await this._interface.setClientUserCustomizableData(update, tokenStore);
+    }
+    async signInWithOauth(provider) {
+        this._ensurePersistentTokenStore();
+        await signInWithOauth(this._interface, { provider, redirectUrl: this.urls.oauthCallback });
+    }
+    async signInWithCredential(options) {
+        if (!options.redirectUrl) {
+            options.redirectUrl = constructRedirectUrl(options.redirectUrl);
+        }
+        this._ensurePersistentTokenStore();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        return await signInWithCredential(this._interface, tokenStore, options);
+    }
+    async signUpWithCredential(options) {
+        if (!options.redirectUrl) {
+            options.redirectUrl = constructRedirectUrl(options.redirectUrl);
+        }
+        this._ensurePersistentTokenStore();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        return await signUpWithCredential(this._interface, tokenStore, options);
+    }
+    async callOauthCallback(options = {}) {
+        this._ensurePersistentTokenStore();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        await callOauthCallback(this._interface, tokenStore, options.redirectUrl);
+    }
+    async _signOut(tokenStore, redirectUrl) {
+        redirectUrl = constructRedirectUrl(redirectUrl);
+        await this._interface.signOut(tokenStore);
+        window.location.assign(redirectUrl);
+        return await neverResolve();
+    }
+    async signOut(redirectUrl) {
+        const user = await this.getUser();
+        if (user) {
+            await user.signOut(redirectUrl);
+        }
+        window.location.assign(redirectUrl);
+        return await neverResolve();
+    }
+    async getProject() {
+        return await this._interface.clientProjectCache.getOrWait();
+    }
+    useProject() {
+        return useValueCache(this._interface.clientProjectCache);
+    }
+    onProjectChange(callback) {
+        return this._interface.clientProjectCache.onChange(callback);
+    }
+    async listOwnedProjects() {
+        this._ensureInternalProject();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        const json = await this._interface.listProjects(tokenStore);
+        return json.map((j) => this._projectAdminFromJson(j));
+    }
+    async createProject(newProject) {
+        this._ensureInternalProject();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        const json = await this._interface.createProject(newProject, tokenStore);
+        return this._projectAdminFromJson(json);
+    }
+    static get [stackAppInternalsSymbol]() {
+        return {
+            fromClientJson: (json) => {
+                const existing = allClientApps.get(json.uniqueIdentifier);
+                if (existing) {
+                    const [checkString, clientApp] = existing;
+                    if (checkString !== JSON.stringify(json)) {
+                        throw new Error("The provided app JSON does not match the configuration of the existing client app with the same unique identifier");
+                    }
+                    return clientApp;
+                }
+                return new _StackClientAppImpl({
+                    ...json,
+                    checkString: JSON.stringify(json),
+                });
+            }
+        };
+    }
+    get [stackAppInternalsSymbol]() {
+        return {
+            toClientJson: async () => {
+                if (!("publishableClientKey" in this._interface.options)) {
+                    // TODO find a way to do this
+                    throw Error("Cannot serialize to JSON from an application without a publishable client key");
+                }
+                return {
+                    baseUrl: this._interface.options.baseUrl,
+                    projectId: this.projectId,
+                    publishableClientKey: this._interface.options.publishableClientKey,
+                    tokenStore: this._tokenStoreOptions,
+                    urls: this._urlOptions,
+                    uniqueIdentifier: this._uniqueIdentifier,
+                };
+            }
+        };
+    }
+    ;
+}
+class _StackServerAppImpl extends _StackClientAppImpl {
+    constructor(options) {
+        if ("interface" in options) {
+            super({
+                interface: options.interface,
+                tokenStore: options.tokenStore,
+                urls: options.urls,
+            });
+        }
+        else {
+            super({
+                interface: new StackServerInterface({
+                    baseUrl: options.baseUrl ?? getDefaultBaseUrl(),
+                    projectId: options.projectId ?? getDefaultProjectId(),
+                    publishableClientKey: options.publishableClientKey ?? getDefaultPublishableClientKey(),
+                    secretServerKey: options.secretServerKey ?? getDefaultSecretServerKey(),
+                }),
+                tokenStore: options.tokenStore,
+                urls: options.urls ?? {},
+            });
+        }
+    }
+    _serverUserFromJson(json) {
+        if (json === null)
+            return null;
+        const app = this;
+        return {
+            ...this._userFromJson(json),
+            serverMetadata: json.serverMetadata,
+            async delete() {
+                await app._interface.deleteServerUser(this.id);
+            },
+            async update(update) {
+                await app._interface.setServerUserCustomizableData(this.id, update);
+            },
+            getClientUser() {
+                return {
+                    ...app._userFromJson(json),
+                };
+            },
+            toJson() {
+                return app._serverUserToJson(this);
+            },
+        };
+    }
+    _currentServerUserFromJson(json, tokenStore) {
+        if (json === null)
+            return null;
+        const app = this;
+        const res = {
+            ...this._serverUserFromJson(json),
+            get accessToken() {
+                return AsyncResult.or(tokenStore.get(), null)?.accessToken ?? null;
+            },
+            get refreshToken() {
+                return AsyncResult.or(tokenStore.get(), null)?.refreshToken ?? null;
+            },
+            signOut(redirectUrl) {
+                return app._signOut(tokenStore, redirectUrl);
+            },
+            getClientUser() {
+                const serverUser = this;
+                return {
+                    ...app._userFromJson(json),
+                    get accessToken() {
+                        return serverUser.accessToken;
+                    },
+                    get refreshToken() {
+                        return serverUser.refreshToken;
+                    },
+                    update(update) {
+                        return serverUser.update(update);
+                    },
+                    signOut(redirectUrl) {
+                        return serverUser.signOut(redirectUrl);
+                    },
+                };
+            },
+        };
+        Object.freeze(res);
+        return res;
+    }
+    _serverUserToJson(user) {
+        return {
+            projectId: user.projectId,
+            id: user.id,
+            displayName: user.displayName,
+            primaryEmail: user.primaryEmail,
+            primaryEmailVerified: user.primaryEmailVerified,
+            profileImageUrl: user.profileImageUrl,
+            signedUpAtMillis: user.signedUpAt.getTime(),
+            clientMetadata: user.clientMetadata,
+            serverMetadata: user.serverMetadata,
+        };
+    }
+    async getServerUser() {
+        this._ensurePersistentTokenStore();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        const userJson = await this._interface.currentServerUserCache.getOrWait(tokenStore);
+        return this._currentServerUserFromJson(userJson, tokenStore);
+    }
+    useServerUser(options) {
+        this._ensurePersistentTokenStore();
+        const router = useRouter();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        const userJson = useValueCache(this._interface.currentServerUserCache.getValueCache(tokenStore));
+        if (options?.required && userJson === null) {
+            use(this.redirectToSignIn());
+        }
+        return this._currentServerUserFromJson(userJson, tokenStore);
+    }
+    onServerUserChange(callback) {
+        this._ensurePersistentTokenStore();
+        const tokenStore = getTokenStore(this._tokenStoreOptions);
+        return this._interface.currentServerUserCache.getValueCache(tokenStore).onChange((userJson) => {
+            callback(this._currentServerUserFromJson(userJson, tokenStore));
+        });
+    }
+}
+class _StackAdminAppImpl extends _StackServerAppImpl {
+    constructor(options) {
+        super({
+            interface: new StackAdminInterface({
+                baseUrl: options.baseUrl ?? getDefaultBaseUrl(),
+                projectId: options.projectId ?? getDefaultProjectId(),
+                publishableClientKey: options.publishableClientKey ?? getDefaultPublishableClientKey(),
+                secretServerKey: options.secretServerKey ?? getDefaultSecretServerKey(),
+                superSecretAdminKey: options.superSecretAdminKey ?? getDefaultSuperSecretAdminKey(),
+            }),
+            tokenStore: options.tokenStore,
+            urls: options.urls,
+        });
+    }
+    async getProjectAdmin() {
+        return this._projectAdminFromJson(await this._interface.projectCache.getOrWait());
+    }
+    useProjectAdmin() {
+        return this._projectAdminFromJson(useValueCache(this._interface.projectCache));
+    }
+    onProjectAdminChange(callback) {
+        return this._interface.projectCache.onChange((j) => callback(this._projectAdminFromJson(j)));
+    }
+}
+export const StackClientApp = _StackClientAppImpl;
+export const StackServerApp = _StackServerAppImpl;
+export const StackAdminApp = _StackAdminAppImpl;

package/dist/providers/StackProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { StackClientApp } from '../lib/stack-app';
+export default function StackProvider({ children, app, }: {
+    children: ReactNode;
+    app: StackClientApp<true>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/providers/StackProvider.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { stackAppInternalsSymbol } from '../lib/stack-app';
+import { StackProviderClient } from './StackProviderClient';
+export default function StackProvider({ children, app, }) {
+    return (_jsx(StackProviderClient, { appJsonPromise: app[stackAppInternalsSymbol].toClientJson(), children: children }));
+}

package/dist/providers/StackProviderClient.d.ts

@@ -0,0 +1,9 @@
+import { StackClientApp, StackClientAppJson } from "../lib/stack-app";
+import React from "react";
+export declare const StackContext: React.Context<{
+    app: StackClientApp<true>;
+} | null>;
+export declare function StackProviderClient(props: {
+    appJsonPromise: Promise<StackClientAppJson<true, string>>;
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/providers/StackProviderClient.js

@@ -0,0 +1,14 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { use } from "react";
+import { StackClientApp, stackAppInternalsSymbol } from "../lib/stack-app";
+import React from "react";
+export const StackContext = React.createContext(null);
+export function StackProviderClient(props) {
+    const appJson = use(props.appJsonPromise);
+    const app = StackClientApp[stackAppInternalsSymbol].fromClientJson(appJson);
+    if (process.env.NODE_ENV === "development") {
+        globalThis.stackApp = app;
+    }
+    return (_jsx(StackContext.Provider, { value: { app }, children: props.children }));
+}