initial: bootstrap from BukidBountyApp base

resources/js/composables/Core/useAuth.js

@@ -0,0 +1,147 @@
+import { ref, computed, onMounted } from 'vue';
+import axios from 'axios';
+import { UserTypes } from '../../utils/UserTypes.js';
+import { useUserStore } from '../../stores/user.js';
+
+// Global reactive state to persist throughout the SPA session
+const globalRole = ref(sessionStorage.getItem('user_acct_type') || UserTypes.PUBLIC);
+const isFetching = ref(false);
+
+/**
+ * Fetches the user account type from the server.
+ * Ensures only one request is made per session.
+ */
+async function fetchRole() {
+    if (isFetching.value) return;
+
+    // If we already have a specialized role in sessionStorage, don't fetch again
+    const cached = sessionStorage.getItem('user_acct_type');
+    if (cached && cached !== UserTypes.PUBLIC) {
+        return;
+    }
+
+    isFetching.value = true;
+    try {
+        const response = await axios.get('/get/user/acct-type');
+        let acctType = response.data?.acct_type;
+
+        // Handle case where acct_type might be an object (Enum serialization)
+        if (acctType && typeof acctType === 'object' && acctType.value) {
+            acctType = acctType.value;
+        }
+
+        if (acctType) {
+            globalRole.value = acctType;
+            sessionStorage.setItem('user_acct_type', acctType);
+        }
+    } catch (error) {
+        // If 401, we are likely a guest
+        if (error.response?.status === 401) {
+            globalRole.value = UserTypes.PUBLIC;
+            sessionStorage.setItem('user_acct_type', UserTypes.PUBLIC);
+        } else {
+            console.warn('Failed to fetch user acct type from server:', error);
+        }
+    } finally {
+        isFetching.value = false;
+    }
+}
+
+// Initial fetch attempt if we don't have a definitive role
+if (!sessionStorage.getItem('user_acct_type') || sessionStorage.getItem('user_acct_type') === UserTypes.PUBLIC) {
+    fetchRole();
+}
+
+export function resetRole() {
+    globalRole.value = UserTypes.PUBLIC;
+    isFetching.value = false;
+    sessionStorage.removeItem('user_acct_type');
+}
+
+/**
+ * Composable for managing user roles and permissions in the frontend.
+ * @param {Object} [user] - Optional user object for legacy support or specific overrides
+ */
+export function useAuth(user = null) {
+    const userStore = useUserStore();
+    
+    // Priority: Explicitly passed user prop > user store > sessionStorage fallback
+    const currentUser = computed(() => {
+        if (user?.value ?? user) return user?.value ?? user;
+        const storeUser = userStore.user;
+        if (storeUser && Object.keys(storeUser).length > 0) return storeUser;
+        
+        try {
+            const stored = sessionStorage.getItem('currentUser');
+            return stored ? JSON.parse(stored) : null;
+        } catch (e) {
+            return null;
+        }
+    });
+
+    const role = computed(() => {
+        // Priority 1: User object passed directly or from store
+        const localRole = userStore.acctType || currentUser.value?.acct_type;
+        if (localRole) {
+            if (typeof localRole === 'object' && localRole.value) return localRole.value;
+            return localRole;
+        }
+
+        // Priority 2: Global fetched role
+        return globalRole.value;
+    });
+
+    const hasRole = (targetRole) => {
+        if (Array.isArray(targetRole)) {
+            return targetRole.some(r => role.value === r);
+        }
+        return role.value === targetRole;
+    };
+
+    // Role-specific helpers
+    const isUltimate = computed(() => role.value === UserTypes.ULTIMATE);
+    const isSuperOperator = computed(() => role.value === UserTypes.SUPER_OPERATOR);
+    const isOperator = computed(() => role.value === UserTypes.OPERATOR);
+    const isCoordinator = computed(() => role.value === UserTypes.COORDINATOR);
+    const isStoreOwner = computed(() => role.value === UserTypes.STORE_OWNER);
+    const isStoreManager = computed(() => role.value === UserTypes.STORE_MANAGER);
+    const isRider = computed(() => role.value === UserTypes.RIDER);
+    const isSupplier = computed(() => role.value === UserTypes.SUPPLIER);
+    const isSupplierOverseer = computed(() => role.value === UserTypes.SUPPLIER_OVERSEER);
+    const isWholesaleBuyer = computed(() => role.value === UserTypes.WHOLESALE_BUYER);
+    const isAudit = computed(() => role.value === UserTypes.AUDIT);
+    const isUser = computed(() => role.value === UserTypes.USER);
+    const isCoopOfficer = computed(() => role.value === UserTypes.COOP_OFFICER);
+    const isCoopMember = computed(() => role.value === UserTypes.COOP_MEMBER);
+    const isPOSTerminal = computed(() => role.value === UserTypes.POS_TERMINAL);
+    const isPublic = computed(() => role.value === UserTypes.PUBLIC || !userStore.isLoggedIn);
+    const isLoggedIn = computed(() => userStore.isLoggedIn);
+
+    return {
+        user: currentUser,
+        role,
+        hasRole,
+        isUltimate,
+        isSuperOperator,
+        isOperator,
+        isCoordinator,
+        isStoreOwner,
+        isStoreManager,
+        isRider,
+        isSupplier,
+        isSupplierOverseer,
+        isWholesaleBuyer,
+        isAudit,
+        isUser,
+        isCoopOfficer,
+        isCoopMember,
+        isPOSTerminal,
+        isPublic,
+        isLoggedIn,
+        UserTypes,
+        refreshRole: fetchRole,
+        // Expose the user store for direct access to user data
+        userStore
+    };
+}
+