academe-kit 0.6.7 → 0.7.0

package/dist/index.cjs

@@ -5984,37 +5984,20 @@ exports.GLOBAL_ROLES = void 0;
     GLOBAL_ROLES["GUARDIAN"] = "guardian";
 })(exports.GLOBAL_ROLES || (exports.GLOBAL_ROLES = {}));
 
-function detectMobileTokenSync() {
-    if (typeof window === "undefined") {
-        return { token: undefined, isMobile: false, decoded: null };
-    }
-    const keycloakConfig = window.keycloakConfig;
-    if (!keycloakConfig?.fromMobile || !keycloakConfig?.token) {
-        return { token: undefined, isMobile: false, decoded: null };
-    }
-    // Validar e decodificar o token mobile
-    try {
-        const decoded = jwtDecode(keycloakConfig.token);
-        if (!decoded) {
-            console.error("[SecurityProvider] Token mobile inválido - ignorando");
-            return { token: undefined, isMobile: false, decoded: null };
-        }
-        // Verificar se o token não está expirado
-        const now = Math.floor(Date.now() / 1000);
-        if (decoded.exp && decoded.exp < now) {
-            console.error("[SecurityProvider] Token mobile expirado - ignorando");
-            return { token: undefined, isMobile: false, decoded: null };
-        }
-        console.log("[SecurityProvider] ✅ Token mobile detectado síncronamente");
-        return { token: keycloakConfig.token, isMobile: true, decoded };
-    }
-    catch (error) {
-        console.error("[SecurityProvider] Erro ao decodificar token mobile:", error);
-        return { token: undefined, isMobile: false, decoded: null };
+const getCookie = (name) => {
+    if (typeof window === "undefined")
+        return null;
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+        return parts.pop()?.split(";").shift() || null;
     }
-}
-// Detecta o token mobile UMA VEZ no carregamento do módulo
-const initialMobileState = detectMobileTokenSync();
+    return null;
+};
+const getAccessTokenFromCookies = () => {
+    const token = getCookie("KC_FORCE_AUTH_TOKEN");
+    return token || undefined;
+};
 const AcademeAuthProvider = ({ realm, hubUrl, children, clientId, keycloakUrl, apiBaseUrl, skipApiUserFetch, }) => {
     const oidcConfig = {
         authority: `${keycloakUrl}/realms/${realm}`,
@@ -6033,7 +6016,6 @@ const AcademeAuthProvider = ({ realm, hubUrl, children, clientId, keycloakUrl, a
 const SecurityContext = React2.createContext({
     isInitialized: false,
     isTokenReady: false,
-    isMobileAuth: false,
     user: null,
     refreshUserData: async () => { },
     signOut: () => null,
@@ -6062,35 +6044,53 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
     const auth = useAuth();
     const [currentUser, setCurrentUser] = React2.useState(null);
     const [isRefreshing, setIsRefreshing] = React2.useState(false);
-    // CRÍTICO: Inicializar estados com valores do token mobile detectado síncronamente
-    // Isso garante que no primeiro render já temos os valores corretos
-    const hasTriedSignInSilent = React2.useRef(initialMobileState.isMobile);
-    const [isTokenReady, setIsTokenReady] = React2.useState(initialMobileState.isMobile);
-    // --- Estado para autenticação mobile (inicializado com detecção síncrona) ---
-    const [isMobileAuth, setIsMobileAuth] = React2.useState(initialMobileState.isMobile);
-    const [mobileToken, setMobileToken] = React2.useState(initialMobileState.token);
-    // Ref para armazenar o resolver da Promise de token
+    const hasTriedSignInSilent = React2.useRef(false);
+    const [isTokenReady, setIsTokenReady] = React2.useState(false);
     const tokenReadyResolverRef = React2.useRef(null);
     const tokenReadyPromiseRef = React2.useRef(null);
-    // Extrair valores primitivos do auth para usar como dependências estáveis
-    const isAuthenticated = auth.isAuthenticated;
+    const [accessToken, setAccessToken] = React2.useState(() => {
+        const cookieToken = getAccessTokenFromCookies();
+        return cookieToken || auth.user?.access_token;
+    });
+    const decodedAccessToken = React2.useMemo(() => {
+        return accessToken ? decodeAccessToken(accessToken) : null;
+    }, [accessToken]);
+    const userProfileSub = auth.user?.profile?.sub || decodedAccessToken?.sub;
+    const isAuthenticated = auth.isAuthenticated || !!accessToken;
     const isLoading = auth.isLoading;
     const activeNavigator = auth.activeNavigator;
-    const accessToken = auth.user?.access_token;
     const userProfile = auth.user?.profile;
-    const userProfileSub = auth.user?.profile?.sub;
-    // CRÍTICO: Inicializar currentTokenRef com o token mobile detectado síncronamente
-    // Isso garante que o middleware do apiClient já tenha o token no primeiro request
-    const currentTokenRef = React2.useRef(initialMobileState.token);
-    // Sincronizar window.accessToken se tivermos token mobile (executa síncronamente)
-    if (initialMobileState.token && typeof window !== "undefined" && !window.accessToken) {
-        window.accessToken = initialMobileState.token;
-    }
-    // --- 1. Silent Check Inicial (Check SSO) - Pulado se mobile ---
+    console.log(">> isAuthenticated:", isAuthenticated);
+    console.log(">> accessToken:", accessToken);
+    const currentTokenRef = React2.useRef(undefined);
+    // Efeito para sincronizar o token do auth com o state
+    // e também verificar cookies periodicamente
+    React2.useEffect(() => {
+        const cookieToken = getAccessTokenFromCookies();
+        const authToken = auth.user?.access_token;
+        // Prioridade: Cookie > Auth token
+        const newToken = cookieToken || authToken;
+        if (newToken && newToken !== accessToken) {
+            setAccessToken(newToken);
+        }
+    }, [auth.user?.access_token, accessToken]);
+    // Efeito opcional: verificar cookies em intervalos (útil se o cookie pode mudar externamente)
     React2.useEffect(() => {
-        // Pular SSO check se já estamos em modo mobile
-        if (isMobileAuth) {
-            console.debug("[SecurityProvider] Modo mobile - pulando SSO check");
+        const checkCookieToken = () => {
+            const cookieToken = getAccessTokenFromCookies();
+            if (cookieToken && cookieToken !== accessToken) {
+                setAccessToken(cookieToken);
+            }
+        };
+        // Verifica a cada 5 segundos (ajuste conforme necessário)
+        const interval = setInterval(checkCookieToken, 5000);
+        return () => clearInterval(interval);
+    }, [accessToken]);
+    // --- 1. Silent Check Inicial (Check SSO) ---
+    React2.useEffect(() => {
+        // Se já temos um token do cookie, não precisamos fazer silent check
+        if (accessToken) {
+            hasTriedSignInSilent.current = true;
             return;
         }
         if (!isAuthenticated &&
@@ -6103,31 +6103,19 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
             });
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isAuthenticated, isLoading, activeNavigator, isMobileAuth]);
+    }, [isAuthenticated, isLoading, activeNavigator, accessToken]);
     // --- 2. Configuração de API e Services ---
     const apiClient = React2.useMemo(() => {
         const client = createAcademeApiClient(apiBaseUrl);
-        // CRÍTICO: Se já temos token mobile, criar Promise já resolvida
-        // Isso evita que o middleware aguarde uma Promise que nunca será resolvida
-        if (initialMobileState.token) {
-            tokenReadyPromiseRef.current = Promise.resolve();
-            tokenReadyResolverRef.current = () => { };
-        }
-        else {
-            // Inicializa a Promise de token ready para modo OIDC
-            tokenReadyPromiseRef.current = new Promise((resolve) => {
-                tokenReadyResolverRef.current = resolve;
-            });
-        }
-        // Middleware que aguarda o token estar disponível antes de fazer requests
+        tokenReadyPromiseRef.current = new Promise((resolve) => {
+            tokenReadyResolverRef.current = resolve;
+        });
         client.use({
             async onRequest({ request }) {
-                // Se já tem token, usa imediatamente
                 if (currentTokenRef.current) {
                     request.headers.set("Authorization", `Bearer ${currentTokenRef.current}`);
                     return request;
                 }
-                // Se ainda está carregando a auth, aguarda o token ficar pronto
                 if (tokenReadyPromiseRef.current) {
                     await tokenReadyPromiseRef.current;
                     if (currentTokenRef.current) {
@@ -6142,56 +6130,33 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
     const services = React2.useMemo(() => {
         return createAcademeServices(apiClient);
     }, [apiClient]);
-    // Token efetivo: prioriza mobile, depois OIDC
-    const effectiveToken = mobileToken || accessToken;
-    const decodedAccessToken = React2.useMemo(() => {
-        return effectiveToken ? decodeAccessToken(effectiveToken) : null;
-    }, [effectiveToken]);
-    // Atualização do Token e resolução da Promise
-    // Não sobrescreve se estamos em modo mobile
     React2.useEffect(() => {
-        // Se estamos em modo mobile, o token já foi configurado
-        if (isMobileAuth) {
-            return;
-        }
         currentTokenRef.current = accessToken;
         if (typeof window !== "undefined") {
             window.accessToken = accessToken;
         }
         if (accessToken) {
-            // Resolve a promise indicando que o token está pronto
             if (tokenReadyResolverRef.current) {
                 tokenReadyResolverRef.current();
                 setIsTokenReady(true);
             }
         }
         else if (!isLoading && !isAuthenticated) {
-            // Usuário não autenticado - resolve a promise para não bloquear requests públicas
             if (tokenReadyResolverRef.current) {
                 tokenReadyResolverRef.current();
                 setIsTokenReady(true);
             }
         }
-    }, [accessToken, isLoading, isAuthenticated, isMobileAuth]);
-    // --- 3. Helpers de Usuário e Roles ---
+    }, [accessToken, isLoading, isAuthenticated]);
     const getKeycloakUser = React2.useCallback(() => {
-        // Se estamos em modo mobile, extrair do token decodificado
-        if (isMobileAuth && decodedAccessToken) {
-            return {
-                email: decodedAccessToken.email || "",
-                name: decodedAccessToken.given_name || "",
-                lastName: decodedAccessToken.family_name || "",
-            };
-        }
-        // Modo OIDC normal
         const profile = userProfile;
         return {
-            email: profile?.email || "",
-            name: profile?.given_name || "",
-            lastName: profile?.family_name || "",
-            avatar_url: decodedAccessToken?.avatar_url
+            email: profile?.email || decodedAccessToken?.email || "",
+            name: profile?.given_name || decodedAccessToken?.given_name || "",
+            lastName: profile?.family_name || decodedAccessToken?.family_name || "",
+            avatar_url: decodedAccessToken?.avatar_url,
         };
-    }, [userProfile, isMobileAuth, decodedAccessToken]);
+    }, [userProfile, decodedAccessToken]);
     const hasRealmRole = React2.useCallback((role) => {
         return decodedAccessToken?.realm_access?.roles?.includes(role) ?? false;
     }, [decodedAccessToken]);
@@ -6206,20 +6171,17 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
         }
         return Object.values(decodedAccessToken.resource_access).some((resource) => resource.roles?.includes(role));
     }, [decodedAccessToken]);
-    // Autenticação efetiva: mobile ou OIDC
-    const effectiveIsAuthenticated = isMobileAuth || isAuthenticated;
-    const effectiveUserSub = isMobileAuth ? decodedAccessToken?.sub : userProfileSub;
     // --- 4. Fetch de Dados do Usuário (Backend) ---
     React2.useEffect(() => {
         let isMounted = true;
         const fetchUserData = async () => {
-            if (effectiveIsAuthenticated) {
+            if (isAuthenticated) {
                 if (skipApiUserFetch) {
                     if (isMounted) {
                         const academeUser = {
                             keycloakUser: getKeycloakUser(),
                         };
-                        setCurrentUser({ ...academeUser, id: effectiveUserSub || "" });
+                        setCurrentUser({ ...academeUser, id: userProfileSub || "" });
                     }
                     return;
                 }
@@ -6237,7 +6199,7 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
                     console.error("[SecurityProvider] Error fetching user data:", error);
                 }
             }
-            else if (!effectiveIsAuthenticated && !isLoading && !isMobileAuth) {
+            else if (!isAuthenticated && !isLoading) {
                 if (isMounted) {
                     setCurrentUser(null);
                 }
@@ -6248,17 +6210,16 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
             isMounted = false;
         };
     }, [
-        effectiveIsAuthenticated,
+        isAuthenticated,
         isLoading,
         getKeycloakUser,
         services,
         skipApiUserFetch,
-        effectiveUserSub,
-        isMobileAuth,
+        userProfileSub,
     ]);
     const refreshUserData = React2.useCallback(async () => {
         setIsRefreshing(true);
-        if (effectiveIsAuthenticated) {
+        if (isAuthenticated) {
             if (skipApiUserFetch) {
                 await auth.signinSilent();
                 const academeUser = {
@@ -6282,47 +6243,17 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
             }
         }
         setIsRefreshing(false);
-    }, [effectiveIsAuthenticated, getKeycloakUser, services, skipApiUserFetch]);
+    }, [getKeycloakUser, services, skipApiUserFetch]);
     // --- 5. Ações de Auth ---
-    // SignOut para modo OIDC (web normal)
-    const signOutOidc = React2.useCallback(() => {
-        console.log("[KC LOGOUT - OIDC]");
+    const signOut = React2.useCallback(() => {
+        console.log("[KC LOGOUT!]");
         setCurrentUser(null);
         auth.removeUser();
-        auth.signoutSilent({
+        auth.signoutRedirect({
             id_token_hint: auth.user?.id_token,
         });
         auth.clearStaleState();
-        setTimeout(() => {
-            window.location.reload();
-        }, 500);
     }, [auth]);
-    // SignOut para modo mobile
-    const signOutMobile = React2.useCallback(() => {
-        console.log("[KC LOGOUT - Mobile]");
-        setCurrentUser(null);
-        setMobileToken(undefined);
-        setIsMobileAuth(false);
-        // Limpar tokens globais
-        if (typeof window !== "undefined") {
-            window.accessToken = undefined;
-            window.keycloakConfig = undefined;
-        }
-        currentTokenRef.current = undefined;
-        // Notificar o app mobile para fazer logout
-        if (window.ReactNativeWebView) {
-            window.ReactNativeWebView.postMessage(JSON.stringify({ type: "LOGOUT_REQUESTED" }));
-        }
-    }, []);
-    // SignOut unificado: escolhe automaticamente baseado no modo
-    const signOut = React2.useCallback(() => {
-        if (isMobileAuth) {
-            signOutMobile();
-        }
-        else {
-            signOutOidc();
-        }
-    }, [isMobileAuth, signOutMobile, signOutOidc]);
     const hasSchool = React2.useCallback((schoolId) => {
         if (hasRealmRole(exports.GLOBAL_ROLES.ADMIN_ACADEME)) {
             return true;
@@ -6330,43 +6261,36 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
         return (currentUser?.institutionRegistrations?.some((registration) => registration.institutionId === schoolId) ?? false);
     }, [hasRealmRole, currentUser?.institutionRegistrations]);
     const goToLogin = React2.useCallback(() => {
-        // Em modo mobile, notificar o app para fazer login
-        if (isMobileAuth && window.ReactNativeWebView) {
-            window.ReactNativeWebView.postMessage(JSON.stringify({ type: "LOGIN_REQUESTED" }));
-            return Promise.resolve();
-        }
         return auth.signinRedirect();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isMobileAuth]);
+    }, []);
     // Memoizar o value do context para evitar re-renders desnecessários
     const contextValue = React2.useMemo(() => ({
-        isInitialized: isMobileAuth ? true : (!isLoading || isRefreshing),
+        isInitialized: !isLoading || isRefreshing,
         isTokenReady,
-        isMobileAuth,
         user: currentUser,
         refreshUserData,
         signOut,
-        isAuthenticated: () => effectiveIsAuthenticated,
+        isAuthenticated: () => isAuthenticated,
         hasSchool,
         goToLogin,
         hasRealmRole,
         hasClientRole,
-        accessToken: effectiveToken,
+        accessToken,
         apiClient,
         services,
     }), [
-        isMobileAuth,
         isLoading,
         isTokenReady,
         currentUser,
         refreshUserData,
         signOut,
-        effectiveIsAuthenticated,
+        isAuthenticated,
         hasSchool,
         goToLogin,
         hasRealmRole,
         hasClientRole,
-        effectiveToken,
+        accessToken,
         apiClient,
         services,
     ]);