academe-kit 0.1.6 → 0.1.8

package/dist/index.js

@@ -2,6 +2,7 @@
 
 var jsxRuntime = require('react/jsx-runtime');
 var React = require('react');
+var axios = require('axios');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -2250,66 +2251,250 @@ function isObject(input) {
     return typeof input === 'object' && input !== null;
 }
 
-const AcademeAuthProvider = ({ realm, hubUrl, children, clientId, keycloakUrl, }) => {
-    return (jsxRuntime.jsx(ReactKeycloakProvider, { authClient: new Keycloak({ clientId, realm, url: keycloakUrl }), children: jsxRuntime.jsx(SecurityProvider, { hubUrl: hubUrl, children: children }) }));
+/**
+ * User Service - Fetches complete user data from MongoDB
+ * This service interacts with the new unified users collection
+ */
+class UserService {
+    constructor(config) {
+        this.cachedUser = null;
+        this.cacheExpiry = 0;
+        this.getAccessToken = config.getAccessToken;
+        this.client = axios.create({
+            baseURL: config.apiBaseUrl,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+        // Add auth interceptor
+        this.client.interceptors.request.use((config) => {
+            const token = this.getAccessToken();
+            if (token) {
+                config.headers.Authorization = `Bearer ${token}`;
+            }
+            return config;
+        });
+        // Add response interceptor for error handling
+        this.client.interceptors.response.use((response) => response, (error) => {
+            if (error.response?.status === 401) {
+                // Clear cache on authentication error
+                this.clearCache();
+            }
+            return Promise.reject(error);
+        });
+    }
+    /**
+     * Get current user data from MongoDB
+     * Includes caching to reduce API calls
+     */
+    async getCurrentUser(forceRefresh = false) {
+        try {
+            // Check cache
+            if (!forceRefresh && this.cachedUser && Date.now() < this.cacheExpiry) {
+                return this.cachedUser;
+            }
+            const response = await this.client.get('/api/users/me');
+            if (response.data) {
+                // Cache for 5 minutes
+                this.cachedUser = response.data;
+                this.cacheExpiry = Date.now() + (5 * 60 * 1000);
+                return response.data;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error fetching current user:', error);
+            // If it's a 404, user doesn't exist in MongoDB yet
+            if (axios.isAxiosError(error) && error.response?.status === 404) {
+                // User will be auto-created on next API call
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Update current user data
+     */
+    async updateCurrentUser(data) {
+        try {
+            // First get current user to get the ID
+            const currentUser = await this.getCurrentUser();
+            if (!currentUser) {
+                throw new Error('User not found');
+            }
+            const response = await this.client.put(`/api/users/${currentUser.id}`, data);
+            if (response.data) {
+                // Update cache
+                this.cachedUser = response.data;
+                this.cacheExpiry = Date.now() + (5 * 60 * 1000);
+                return response.data;
+            }
+            return null;
+        }
+        catch (error) {
+            console.error('Error updating user:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear cached user data
+     */
+    clearCache() {
+        this.cachedUser = null;
+        this.cacheExpiry = 0;
+    }
+    /**
+     * Check if user has a specific role
+     */
+    hasRole(user, role) {
+        if (!user || !user.roles)
+            return false;
+        return user.roles.includes(role);
+    }
+    /**
+     * Check if user has access to a specific school
+     */
+    hasSchoolAccess(user, schoolId) {
+        if (!user)
+            return false;
+        // Admin has access to all schools
+        if (this.hasRole(user, 'admin_academe'))
+            return true;
+        // Check if user's school matches
+        return user.school_id === schoolId;
+    }
+    /**
+     * Check if user is a student (has student-specific data)
+     */
+    isStudent(user) {
+        if (!user)
+            return false;
+        return !!user.registration_number || this.hasRole(user, 'student');
+    }
+    /**
+     * Check if user has completed onboarding
+     */
+    hasCompletedOnboarding(user) {
+        if (!user)
+            return false;
+        return user.onboarding_completo;
+    }
+    /**
+     * Check if user has access enabled
+     */
+    hasAccessEnabled(user) {
+        if (!user)
+            return false;
+        return user.acesso_liberado && user.active;
+    }
+}
+// Export singleton instance creator
+const createUserService = (config) => {
+    return new UserService(config);
+};
+
+const AcademeAuthProvider = ({ realm, hubUrl, children, clientId, keycloakUrl, apiBaseUrl, }) => {
+    return (jsxRuntime.jsx(ReactKeycloakProvider, { authClient: new Keycloak({ clientId, realm, url: keycloakUrl }), children: jsxRuntime.jsx(SecurityProvider, { hubUrl: hubUrl, apiBaseUrl: apiBaseUrl, children: children }) }));
 };
 const SecurityContext = React.createContext({
     isInitialized: false,
-    getUser: () => ({
-        email: "",
-        name: "",
-        lastName: "",
-        attributes: {
-            school_ids: [],
-        },
-    }),
+    user: null,
+    refreshUserData: async () => { },
     signOut: () => null,
     goToLogin: () => null,
     hasSchool: () => false,
     hasRealmRole: () => false,
-    redirectToHub: () => null,
     hasClientRole: () => false,
     isAuthenticated: () => false,
 });
-const SecurityProvider = ({ hubUrl, children, }) => {
+const SecurityProvider = ({ apiBaseUrl = "https://api.academe.com.br", children, }) => {
     const [isInitialized, setIsInitialized] = React.useState(false);
+    const [currentUser, setCurrentUser] = React.useState(null);
     const { initialized, keycloak } = useKeycloak();
+    const userService = createUserService({
+        apiBaseUrl,
+        getAccessToken: () => keycloak?.token || null,
+    });
     React.useEffect(() => {
         setIsInitialized(initialized);
     }, [initialized]);
     React.useEffect(() => {
         window.accessToken = keycloak.token;
     }, [keycloak.token]);
-    const getUser = () => {
+    // Fetch user data from MongoDB when authenticated
+    React.useEffect(() => {
+        const fetchUserData = async () => {
+            if (initialized && keycloak?.authenticated && keycloak?.token) {
+                try {
+                    const mongoUser = await userService.getCurrentUser();
+                    if (mongoUser) {
+                        const academeUser = {
+                            ...mongoUser,
+                            keycloakUser: getKeycloakUser(),
+                        };
+                        setCurrentUser(academeUser);
+                    }
+                }
+                catch (error) {
+                    console.error("Error fetching user data:", error);
+                }
+            }
+            else if (!keycloak?.authenticated) {
+                // Clear user data when not authenticated
+                setCurrentUser(null);
+                userService.clearCache();
+            }
+        };
+        fetchUserData();
+    }, [initialized, keycloak?.authenticated, keycloak?.token]);
+    const getKeycloakUser = () => {
         const idTokenParsed = keycloak?.idTokenParsed || {};
         return {
-            email: keycloak?.idTokenParsed?.email || "",
-            name: keycloak?.idTokenParsed?.given_name || "",
-            lastName: keycloak?.idTokenParsed?.family_name || "",
-            attributes: {
-                school_ids: (idTokenParsed.school_ids || []),
-            },
+            email: idTokenParsed?.email || "",
+            name: idTokenParsed?.given_name || "",
+            lastName: idTokenParsed?.family_name || "",
         };
     };
-    const redirectToHub = (errorMessage) => {
-        window.location.replace(`${hubUrl}?errorMessage=${errorMessage}`);
-    };
+    const refreshUserData = React.useCallback(async () => {
+        if (keycloak?.authenticated) {
+            try {
+                const mongoUser = await userService.getCurrentUser(true); // Force refresh
+                if (mongoUser) {
+                    const academeUser = {
+                        ...mongoUser,
+                        keycloakUser: getKeycloakUser(),
+                    };
+                    setCurrentUser(academeUser);
+                }
+            }
+            catch (error) {
+                console.error("Error refreshing user data:", error);
+            }
+        }
+    }, [keycloak?.authenticated]);
     const signOut = () => {
+        userService.clearCache();
+        setCurrentUser(null);
         keycloak?.logout();
     };
     const isAuthenticated = () => {
         return (!!keycloak?.idTokenParsed?.email?.length && !!keycloak?.authenticated);
     };
     const hasSchool = (schoolId) => {
-        return getUser().attributes.school_ids.includes(schoolId);
+        if (currentUser?.school_id) {
+            return (currentUser.school_id === schoolId ||
+                userService.hasRole(currentUser, "admin_academe"));
+        }
+        // Fallback to Keycloak data
+        return false; // No school_id in Keycloak data
     };
     return (jsxRuntime.jsx(SecurityContext.Provider, { value: {
             isInitialized,
-            getUser,
+            user: currentUser,
+            refreshUserData,
             signOut,
-            redirectToHub,
             isAuthenticated,
-            hasSchool: hasSchool,
+            hasSchool,
             goToLogin: keycloak.login,
             hasRealmRole: keycloak?.hasRealmRole,
             hasClientRole: keycloak.hasResourceRole,
@@ -5400,8 +5585,8 @@ function Spinner({ className, ...props }) {
     return (jsxRuntime.jsx(LoaderCircle, { role: "status", "aria-label": "Loading", className: cn("size-10 animate-spin text-violet-500", className), ...props }));
 }
 
-const ProtectedApp = ({ children, unauthorizedMessage, requiredClientRoles, }) => {
-    const { isInitialized, goToLogin, hasClientRole, redirectToHub, isAuthenticated, } = useAcademeAuth();
+const ProtectedApp = ({ children, requiredClientRoles, }) => {
+    const { isInitialized, goToLogin, hasClientRole, isAuthenticated } = useAcademeAuth();
     if (!isInitialized) {
         return (jsxRuntime.jsx("div", { className: "flex w-screen h-screen items-center justify-center", children: jsxRuntime.jsx(Spinner, { className: "size-10 text-violet-500" }) }));
     }
@@ -5411,7 +5596,6 @@ const ProtectedApp = ({ children, unauthorizedMessage, requiredClientRoles, }) =
     }
     if (requiredClientRoles &&
         !requiredClientRoles?.some((role) => hasClientRole(role))) {
-        redirectToHub(unauthorizedMessage || "Unauthorized");
         return jsxRuntime.jsx(jsxRuntime.Fragment, {});
     }
     return children;
@@ -5479,5 +5663,6 @@ exports.ProtectedComponent = ProtectedComponent;
 exports.ProtectedRouter = ProtectedRouter;
 exports.Spinner = Spinner;
 exports.cn = cn;
+exports.createUserService = createUserService;
 exports.useAcademeAuth = useAcademeAuth;
 //# sourceMappingURL=index.js.map