academe-kit 0.5.8 → 0.6.1

package/dist/index.cjs

@@ -5772,6 +5772,54 @@ function createCourseService(apiClient) {
     };
 }
 
+function createStorageFileService(apiClient) {
+    return {
+        /**
+         * Upload a new file
+         * Note: This method requires FormData with a 'file' field
+         */
+        upload(file) {
+            const formData = new FormData();
+            formData.append("file", file);
+            // Note: Route not typed in OpenAPI yet, using type assertion
+            return apiClient.POST("/storage-files", {
+                body: formData,
+                bodySerializer: (body) => body,
+            });
+        },
+        /**
+         * List all storage files
+         */
+        getAll() {
+            // Note: Route not typed in OpenAPI yet, using type assertion
+            return apiClient.GET("/storage-files", {});
+        },
+        /**
+         * Get storage file by ID
+         */
+        getById(id) {
+            // Note: Route not typed in OpenAPI yet, using type assertion
+            return apiClient.GET(`/storage-files/${id}`, {});
+        },
+        /**
+         * Update storage file metadata
+         */
+        update(id, data) {
+            // Note: Route not typed in OpenAPI yet, using type assertion
+            return apiClient.PATCH(`/storage-files/${id}`, {
+                body: data,
+            });
+        },
+        /**
+         * Delete storage file
+         */
+        delete(id) {
+            // Note: Route not typed in OpenAPI yet, using type assertion
+            return apiClient.DELETE(`/storage-files/${id}`, {});
+        },
+    };
+}
+
 function createAcademeApiClient(baseUrl) {
     return createClient({ baseUrl });
 }
@@ -5793,6 +5841,7 @@ function createAcademeServices(apiClient) {
         certificateTemplate: createCertificateTemplateService(apiClient),
         seatCode: createSeatCodeService(apiClient),
         product: createProductService(apiClient),
+        storageFile: createStorageFileService(apiClient),
     };
 }
 
@@ -5823,6 +5872,7 @@ const AcademeAuthProvider = ({ realm, hubUrl, children, clientId, keycloakUrl, a
 const SecurityContext = React2.createContext({
     isInitialized: false,
     isTokenReady: false,
+    isMobileAuth: false,
     user: null,
     refreshUserData: async () => { },
     signOut: () => null,
@@ -5852,119 +5902,70 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
     const [currentUser, setCurrentUser] = React2.useState(null);
     const hasTriedSignInSilent = React2.useRef(false);
     const [isTokenReady, setIsTokenReady] = React2.useState(false);
+    const [isRefreshing, setIsRefreshing] = React2.useState(false);
+    // --- Estado para autenticação mobile ---
+    const [isMobileAuth, setIsMobileAuth] = React2.useState(false);
+    const [mobileToken, setMobileToken] = React2.useState(undefined);
+    const mobileInitializedRef = React2.useRef(false);
     // Ref para armazenar o resolver da Promise de token
     const tokenReadyResolverRef = React2.useRef(null);
     const tokenReadyPromiseRef = React2.useRef(null);
-    // Estados para controle de token injetado pelo mobile
-    const [mobileToken, setMobileToken] = React2.useState(undefined);
-    const [isMobileWebView, setIsMobileWebView] = React2.useState(false);
-    const [isMobileDetectionComplete, setIsMobileDetectionComplete] = React2.useState(false);
     // Extrair valores primitivos do auth para usar como dependências estáveis
     const isAuthenticated = auth.isAuthenticated;
     const isLoading = auth.isLoading;
     const activeNavigator = auth.activeNavigator;
-    const oidcAccessToken = auth.user?.access_token;
+    const accessToken = auth.user?.access_token;
     const userProfile = auth.user?.profile;
     const userProfileSub = auth.user?.profile?.sub;
-    // Token a ser usado: prioriza mobile, depois OIDC
-    const accessToken = isMobileWebView ? mobileToken : oidcAccessToken;
-    // --- 0. Detectar Mobile WebView e escutar eventos de token ---
+    // Ref para armazenar o token atual (acessível no middleware)
+    const currentTokenRef = React2.useRef(undefined);
+    // --- 0. Detecção de Token Mobile (ANTES do SSO check) ---
     React2.useEffect(() => {
+        // Só executa uma vez na inicialização
+        if (mobileInitializedRef.current)
+            return;
+        mobileInitializedRef.current = true;
         if (typeof window === "undefined")
             return;
-        let pollingInterval = null;
-        let pollingAttempts = 0;
-        // Detectar se estamos em um contexto de Mobile WebView
-        // Verificamos múltiplos indicadores porque no iOS o ReactNativeWebView pode ser injetado depois
-        const urlParams = new URLSearchParams(window.location.search);
-        const isEmbedded = urlParams.get('embedded') === 'true';
-        const hasReactNativeWebView = !!window.ReactNativeWebView;
-        const hasKeycloakConfig = !!window.keycloakConfig?.fromMobile;
-        const shouldCheckForMobileToken = isEmbedded || hasReactNativeWebView || hasKeycloakConfig;
-        console.log('[SecurityProvider] Verificação mobile:', {
-            isEmbedded,
-            hasReactNativeWebView,
-            hasKeycloakConfig,
-            shouldCheckForMobileToken
-        });
-        // Se não há indicadores de mobile, completa imediatamente
-        if (!shouldCheckForMobileToken) {
-            console.log('[SecurityProvider] Não é contexto mobile - pulando detecção');
-            setIsMobileDetectionComplete(true);
+        const keycloakConfig = window.keycloakConfig;
+        if (!keycloakConfig?.fromMobile || !keycloakConfig?.token) {
+            console.debug("[SecurityProvider] Modo web normal - sem token mobile");
             return;
         }
-        console.log('[SecurityProvider] Contexto mobile detectado - iniciando detecção de token...');
-        // Polling para mobile: 30 tentativas de 100ms = 3 segundos max
-        const MAX_POLLING_ATTEMPTS = 30;
-        const POLLING_INTERVAL_MS = 100;
-        // Função para verificar e configurar o token mobile
-        const checkAndSetMobileToken = () => {
-            if (window.keycloakConfig?.fromMobile && window.keycloakConfig?.token) {
-                console.log('[SecurityProvider] Token mobile detectado');
-                setIsMobileWebView(true);
-                setMobileToken(window.keycloakConfig.token);
-                setIsMobileDetectionComplete(true);
-                return true;
-            }
-            return false;
-        };
-        // 1. Verificação imediata
-        if (checkAndSetMobileToken()) {
-            console.log('[SecurityProvider] Token encontrado na verificação inicial');
+        // Validar e decodificar o token mobile
+        const decoded = decodeAccessToken(keycloakConfig.token);
+        if (!decoded) {
+            console.error("[SecurityProvider] Token mobile inválido - ignorando");
+            return;
         }
-        else {
-            // 2. Polling até encontrar o token ou atingir o limite
-            pollingInterval = setInterval(() => {
-                pollingAttempts++;
-                if (checkAndSetMobileToken()) {
-                    console.log(`[SecurityProvider] Token encontrado após ${pollingAttempts} tentativas (${pollingAttempts * POLLING_INTERVAL_MS}ms)`);
-                    if (pollingInterval) {
-                        clearInterval(pollingInterval);
-                        pollingInterval = null;
-                    }
-                }
-                else if (pollingAttempts >= MAX_POLLING_ATTEMPTS) {
-                    console.log('[SecurityProvider] Polling encerrado - token não encontrado após 3 segundos');
-                    setIsMobileDetectionComplete(true);
-                    if (pollingInterval) {
-                        clearInterval(pollingInterval);
-                        pollingInterval = null;
-                    }
-                }
-            }, POLLING_INTERVAL_MS);
+        // 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;
         }
-        // 3. Escutar evento de injeção (fallback)
-        const handleInjection = (event) => {
-            console.log('[SecurityProvider] Token recebido via evento keycloakConfigInjected');
-            setIsMobileWebView(true);
-            setMobileToken(event.detail.token);
-            setIsMobileDetectionComplete(true);
-            // Parar polling se ainda estiver rodando
-            if (pollingInterval) {
-                clearInterval(pollingInterval);
-                pollingInterval = null;
-            }
-        };
-        // 4. Escutar evento de refresh do token
-        const handleTokenRefresh = (event) => {
-            console.log('[SecurityProvider] Token atualizado via evento keycloakTokenRefreshed');
-            setMobileToken(event.detail.token);
-        };
-        window.addEventListener("keycloakConfigInjected", handleInjection);
-        window.addEventListener("keycloakTokenRefreshed", handleTokenRefresh);
-        return () => {
-            if (pollingInterval) {
-                clearInterval(pollingInterval);
-            }
-            window.removeEventListener("keycloakConfigInjected", handleInjection);
-            window.removeEventListener("keycloakTokenRefreshed", handleTokenRefresh);
-        };
+        console.log("[SecurityProvider] ✅ Token mobile detectado e válido");
+        // Ativar modo mobile
+        setMobileToken(keycloakConfig.token);
+        setIsMobileAuth(true);
+        // Sincronizar com window.accessToken e currentTokenRef
+        window.accessToken = keycloakConfig.token;
+        currentTokenRef.current = keycloakConfig.token;
+        // Marcar que já tentamos SSO (para pular o check)
+        hasTriedSignInSilent.current = true;
+        // Resolver promise de token imediatamente
+        if (tokenReadyResolverRef.current) {
+            tokenReadyResolverRef.current();
+        }
+        setIsTokenReady(true);
     }, []);
-    // --- 1. Silent Check Inicial (Check SSO) ---
+    // --- 1. Silent Check Inicial (Check SSO) - Pulado se mobile ---
     React2.useEffect(() => {
-        // Não tentar silent login no mobile WebView
-        if (isMobileWebView)
+        // Pular SSO check se já estamos em modo mobile
+        if (isMobileAuth) {
+            console.debug("[SecurityProvider] Modo mobile - pulando SSO check");
             return;
+        }
         if (!isAuthenticated &&
             !isLoading &&
             !activeNavigator &&
@@ -5975,10 +5976,8 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
             });
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [isAuthenticated, isLoading, activeNavigator, isMobileWebView]);
+    }, [isAuthenticated, isLoading, activeNavigator, isMobileAuth]);
     // --- 2. Configuração de API e Services ---
-    // Ref para armazenar o token atual (acessível no middleware)
-    const currentTokenRef = React2.useRef(undefined);
     const apiClient = React2.useMemo(() => {
         const client = createAcademeApiClient(apiBaseUrl);
         // Inicializa a Promise de token ready
@@ -6008,11 +6007,18 @@ 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 accessToken ? decodeAccessToken(accessToken) : null;
-    }, [accessToken]);
+        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;
@@ -6031,16 +6037,26 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
                 setIsTokenReady(true);
             }
         }
-    }, [accessToken, isLoading, isAuthenticated]);
+    }, [accessToken, isLoading, isAuthenticated, isMobileAuth]);
     // --- 3. Helpers de Usuário e Roles ---
     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
         };
-    }, [userProfile]);
+    }, [userProfile, isMobileAuth, decodedAccessToken]);
     const hasRealmRole = React2.useCallback((role) => {
         return decodedAccessToken?.realm_access?.roles?.includes(role) ?? false;
     }, [decodedAccessToken]);
@@ -6055,17 +6071,20 @@ 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 (isAuthenticated) {
+            if (effectiveIsAuthenticated) {
                 if (skipApiUserFetch) {
                     if (isMounted) {
                         const academeUser = {
                             keycloakUser: getKeycloakUser(),
                         };
-                        setCurrentUser({ ...academeUser, id: userProfileSub || "" });
+                        setCurrentUser({ ...academeUser, id: effectiveUserSub || "" });
                     }
                     return;
                 }
@@ -6083,7 +6102,7 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
                     console.error("[SecurityProvider] Error fetching user data:", error);
                 }
             }
-            else if (!isAuthenticated && !isLoading) {
+            else if (!effectiveIsAuthenticated && !isLoading && !isMobileAuth) {
                 if (isMounted) {
                     setCurrentUser(null);
                 }
@@ -6094,16 +6113,19 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
             isMounted = false;
         };
     }, [
-        isAuthenticated,
+        effectiveIsAuthenticated,
         isLoading,
         getKeycloakUser,
         services,
         skipApiUserFetch,
-        userProfileSub,
+        effectiveUserSub,
+        isMobileAuth,
     ]);
     const refreshUserData = React2.useCallback(async () => {
-        if (isAuthenticated) {
+        setIsRefreshing(true);
+        if (effectiveIsAuthenticated) {
             if (skipApiUserFetch) {
+                await auth.signinSilent();
                 const academeUser = {
                     keycloakUser: getKeycloakUser(),
                 };
@@ -6124,10 +6146,12 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
                 console.error("[SecurityProvider] Error refreshing user data:", error);
             }
         }
-    }, [isAuthenticated, getKeycloakUser, services, skipApiUserFetch]);
+        setIsRefreshing(false);
+    }, [effectiveIsAuthenticated, getKeycloakUser, services, skipApiUserFetch]);
     // --- 5. Ações de Auth ---
-    const signOut = React2.useCallback(() => {
-        console.log("[KC LOGOUT!]");
+    // SignOut para modo OIDC (web normal)
+    const signOutOidc = React2.useCallback(() => {
+        console.log("[KC LOGOUT - OIDC]");
         setCurrentUser(null);
         auth.removeUser();
         auth.signoutRedirect({
@@ -6135,6 +6159,32 @@ const SecurityProvider = ({ apiBaseUrl = "https://stg-api.academe.com.br", skipA
         });
         auth.clearStaleState();
     }, [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;
@@ -6142,44 +6192,45 @@ 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
-    // isInitialized só é true quando:
-    // 1. OIDC terminou de carregar (!isLoading)
-    // 2. E a detecção mobile completou (isMobileDetectionComplete)
     const contextValue = React2.useMemo(() => ({
-        isInitialized: !isLoading && isMobileDetectionComplete,
+        isInitialized: isMobileAuth ? true : (!isLoading || isRefreshing),
         isTokenReady,
+        isMobileAuth,
         user: currentUser,
         refreshUserData,
         signOut,
-        isAuthenticated: () => isMobileWebView ? !!mobileToken : isAuthenticated,
+        isAuthenticated: () => effectiveIsAuthenticated,
         hasSchool,
         goToLogin,
         hasRealmRole,
         hasClientRole,
-        accessToken,
+        accessToken: effectiveToken,
         apiClient,
         services,
     }), [
+        isMobileAuth,
         isLoading,
-        isMobileDetectionComplete,
         isTokenReady,
         currentUser,
         refreshUserData,
         signOut,
-        isAuthenticated,
+        effectiveIsAuthenticated,
         hasSchool,
         goToLogin,
         hasRealmRole,
         hasClientRole,
-        accessToken,
+        effectiveToken,
         apiClient,
         services,
-        isMobileWebView,
-        mobileToken,
     ]);
     return (jsxRuntime.jsx(SecurityContext.Provider, { value: contextValue, children: children }));
 };