@meshagent/meshagent-react-auth 0.36.3 → 0.37.2

package/dist/esm/use-login-scope.js

@@ -1,223 +1,7 @@
-import { useMemo, useState } from "react";
-import { useQuery } from "@tanstack/react-query";
-import { meshagentAuth, OAuthSessionManager, LocalStoragePkceCache, PkceGenerator, getDefaultStorage, } from "@meshagent/meshagent-ts-auth";
-import { useMeshagentAuth } from "./use-meshagent-auth";
-function toUrl(value) {
-    return value instanceof URL ? value : new URL(value);
-}
-class UserProfileFetchError extends Error {
-    constructor(status, message) {
-        super(message);
-        Object.defineProperty(this, "status", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.name = "UserProfileFetchError";
-        this.status = status;
-    }
-}
-function isAuthProfileError(error) {
-    return error instanceof UserProfileFetchError
-        && (error.status === 401 || error.status === 403);
-}
-async function fetchUserProfile(params) {
-    const response = await fetch(new URL("/accounts/profiles/me", toUrl(params.serverUrl)), {
-        signal: params.signal,
-        headers: {
-            "Authorization": `Bearer ${params.accessToken}`,
-            "Accept": "application/json",
-        },
-    });
-    if (!response.ok) {
-        throw new UserProfileFetchError(response.status, `Failed to fetch user profile: ${response.status} ${await response.text()}`);
-    }
-    return await response.json();
-}
-function serializeExtraQueryParams(extraQueryParams) {
-    return JSON.stringify(Object.entries(extraQueryParams ?? {}).sort(([left], [right]) => left.localeCompare(right)));
-}
-export async function buildOAuthAuthorizeUrl(params) {
-    const serverUrl = toUrl(params.serverUrl);
-    const callbackUrl = toUrl(params.callbackUrl);
-    const generator = new PkceGenerator();
-    const pair = await generator.generate();
-    const cache = new LocalStoragePkceCache(params.storage ?? getDefaultStorage());
-    await cache.saveVerifier(pair.codeVerifier);
-    const query = new URLSearchParams({
-        ...(params.extraQueryParams ?? {}),
-        scope: params.scope ?? "profile",
-        client_id: params.oauthClientId,
-        code_challenge: pair.codeChallenge,
-        response_type: "code",
-        redirect_uri: callbackUrl.toString(),
-        prompt: "select_account",
-    });
-    if (params.provider) {
-        query.set("provider", params.provider);
-    }
-    return new URL(`/oauth/authorize?${query.toString()}`, serverUrl);
-}
-async function launchSignIn(params) {
-    const authorizeUrl = await buildOAuthAuthorizeUrl({
-        serverUrl: params.serverUrl,
-        callbackUrl: params.callbackUrl,
-        oauthClientId: params.oauthClientId,
-        scope: params.scope,
-        provider: params.provider,
-        extraQueryParams: params.extraQueryParams,
-        storage: params.storage,
-    });
-    if (typeof window === "undefined") {
-        throw new Error("LoginScope requires a browser environment");
-    }
-    window.location.assign(authorizeUrl.toString());
-}
-export function useLoginScope(options) {
-    const storage = options.storage ?? getDefaultStorage();
-    const auth = options.auth ?? meshagentAuth;
-    const authSnapshot = useMeshagentAuth(auth);
-    const session = useMemo(() => new OAuthSessionManager({
-        serverUrl: options.serverUrl,
-        clientId: options.oauthClientId,
-        auth,
-    }), [auth, options.oauthClientId, options.serverUrl]);
-    const autoSignIn = options.autoSignIn ?? true;
-    const extraQueryParamsKey = useMemo(() => serializeExtraQueryParams(options.extraQueryParams), [options.extraQueryParams]);
-    const [signInFailed, setSignInFailed] = useState(null);
-    const [isSigningIn, setIsSigningIn] = useState(false);
-    const [isCancelled, setIsCancelled] = useState(false);
-    const [refreshVersion, setRefreshVersion] = useState(0);
-    const signIn = async (provider) => {
-        setIsSigningIn(true);
-        setSignInFailed(null);
-        setIsCancelled(false);
-        try {
-            await launchSignIn({
-                serverUrl: options.serverUrl,
-                callbackUrl: options.callbackUrl,
-                oauthClientId: options.oauthClientId,
-                scope: options.scope,
-                provider,
-                extraQueryParams: options.extraQueryParams,
-                storage,
-            });
-        }
-        catch (error) {
-            setSignInFailed(error);
-            setIsSigningIn(false);
-        }
-    };
-    const loginQuery = useQuery({
-        queryKey: [
-            "login-scope",
-            toUrl(options.serverUrl).toString(),
-            toUrl(options.callbackUrl).toString(),
-            options.oauthClientId,
-            options.scope ?? "profile",
-            extraQueryParamsKey,
-            autoSignIn,
-            authSnapshot.accessToken,
-            refreshVersion,
-        ],
-        retry: false,
-        refetchOnReconnect: false,
-        refetchOnWindowFocus: false,
-        queryFn: async ({ signal }) => {
-            if (!authSnapshot.accessToken) {
-                setSignInFailed(null);
-                if (autoSignIn) {
-                    setIsSigningIn(true);
-                    try {
-                        await launchSignIn({
-                            serverUrl: options.serverUrl,
-                            callbackUrl: options.callbackUrl,
-                            oauthClientId: options.oauthClientId,
-                            scope: options.scope,
-                            provider: null,
-                            extraQueryParams: options.extraQueryParams,
-                            storage,
-                        });
-                        return {
-                            failed: null,
-                            isLoginLaunched: false,
-                        };
-                    }
-                    catch (error) {
-                        setIsSigningIn(false);
-                        return {
-                            failed: error,
-                            isLoginLaunched: true,
-                        };
-                    }
-                }
-                setIsSigningIn(false);
-                return {
-                    failed: null,
-                    isLoginLaunched: true,
-                };
-            }
-            let accessToken;
-            try {
-                accessToken = await session.getValidAccessTokenOrThrow();
-            }
-            catch (error) {
-                auth.signOut();
-                setIsSigningIn(false);
-                return {
-                    failed: error,
-                    isLoginLaunched: true,
-                };
-            }
-            try {
-                const user = await fetchUserProfile({
-                    serverUrl: options.serverUrl,
-                    accessToken,
-                    signal,
-                });
-                auth.setUser(user);
-                setSignInFailed(null);
-                setIsSigningIn(false);
-                return {
-                    failed: null,
-                    isLoginLaunched: false,
-                };
-            }
-            catch (error) {
-                setIsSigningIn(false);
-                if (isAuthProfileError(error)) {
-                    auth.signOut();
-                    return {
-                        failed: error,
-                        isLoginLaunched: true,
-                    };
-                }
-                return {
-                    failed: error,
-                    isLoginLaunched: false,
-                };
-            }
-        },
+import { useAuth } from "./use-auth";
+export function useLoginScope(props) {
+    return useAuth({
+        ...props,
+        scope: props.scope ?? "email",
     });
-    const refresh = () => {
-        setSignInFailed(null);
-        setIsCancelled(false);
-        setRefreshVersion((version) => version + 1);
-    };
-    const failed = signInFailed ?? (loginQuery.isFetching ? null : loginQuery.data?.failed ?? null);
-    const isLoginLaunched = signInFailed !== null
-        ? true
-        : loginQuery.data?.isLoginLaunched ?? false;
-    const refreshing = loginQuery.isPending || loginQuery.isFetching;
-    return {
-        failed,
-        isCancelled,
-        isSigningIn,
-        refreshing,
-        user: authSnapshot.user,
-        signIn,
-        refresh,
-        isLoginLaunched,
-    };
 }

package/package.json

@@ -1,10 +1,12 @@
 {
     "name": "@meshagent/meshagent-react-auth",
-    "version": "0.36.3",
+    "version": "0.37.2",
     "description": "Meshagent React Auth Helpers",
     "homepage": "https://github.com/meshagent/meshagent-react-auth",
     "scripts": {
-        "build": "mkdir -p dist && bash ./scripts/build.sh"
+        "build": "mkdir -p dist && bash ./scripts/build.sh",
+        "test": "jest",
+        "test:watch": "jest --watch"
     },
     "author": "Meshagent Software",
     "license": "Apache-2.0",
@@ -26,8 +28,8 @@
         "CHANGELOG.md"
     ],
     "dependencies": {
-        "@meshagent/meshagent": "^0.36.3",
-        "@meshagent/meshagent-ts-auth": "^0.36.3",
+        "@meshagent/meshagent": "^0.37.2",
+        "@meshagent/meshagent-ts-auth": "^0.37.2",
         "@tanstack/react-query": "^5.95.2",
         "@tanstack/react-query-devtools": "^5.95.2",
         "react": "^19.1.8",
@@ -42,4 +44,4 @@
     "overrides": {
         "rollup": "4.52.5"
     }
-}
+}