Merge branch 'feature/ERP-7-mise-en-place-du-modular-monolith' into develop

# Conflicts:
#	docker-compose.yml

frontend/shared/composables/useApi.ts

@@ -0,0 +1,202 @@
+import type { FetchOptions , FetchError } from 'ofetch'
+import { $fetch } from 'ofetch'
+
+export type AnyObject = Record<string, unknown>
+
+export type ApiClient = {
+  get<T>(url: string, query?: AnyObject, options?: ApiFetchOptions<'json'>): Promise<T>
+  post<T>(url: string, body?: AnyObject, options?: ApiFetchOptions<'json'>): Promise<T>
+  put<T>(url: string, body?: AnyObject, options?: ApiFetchOptions<'json'>): Promise<T>
+  patch<T>(url: string, body?: AnyObject, options?: ApiFetchOptions<'json'>): Promise<T>
+  delete<T>(url: string, query?: AnyObject, options?: ApiFetchOptions<'json'>): Promise<T>
+}
+
+export type ApiFetchOptions<ResponseType extends 'json' | 'blob'> =
+  FetchOptions<ResponseType> & {
+    toast?: boolean
+    toastOn401?: boolean
+    toastTitle?: string
+    toastErrorMessage?: string
+    toastSuccessMessage?: string
+    toastErrorKey?: string
+    toastSuccessKey?: string
+  }
+
+let isHandlingUnauthorized = false
+
+export function useApi(): ApiClient {
+    const config = useRuntimeConfig()
+    const baseURL = config.public.apiBase || '/api'
+    const toast = useToast()
+    const auth = useAuthStore()
+    const nuxtApp = useNuxtApp()
+    const i18n = nuxtApp.$i18n as
+    | {
+        t: (key: string) => string
+        te?: (key: string) => boolean
+      }
+    | undefined
+    const t = (key: string) => (i18n?.t ? String(i18n.t(key)) : key)
+    const te = (key: string) => (i18n?.te ? i18n.te(key) : false)
+
+    function extractErrorMessage(error: unknown, responseData?: unknown): string {
+        const data = responseData ?? (error as FetchError)?.data
+
+        if (typeof data === 'string') {
+            return data
+        }
+
+        if (data && typeof data === 'object') {
+            const record = data as Record<string, unknown>
+            return (
+                (record['hydra:description'] as string) ||
+        (record.detail as string) ||
+        (record.message as string) ||
+        (record.error as string) ||
+        (record.title as string) ||
+        (record['hydra:title'] as string) ||
+        ''
+            )
+        }
+
+        return (error as FetchError)?.message ?? 'Erreur inconnue.'
+    }
+
+    const methodErrorKeys: Record<string, string> = {
+        GET: 'errors.http.get',
+        POST: 'errors.http.post',
+        PUT: 'errors.http.put',
+        PATCH: 'errors.http.patch',
+        DELETE: 'errors.http.delete'
+    }
+
+    const client = $fetch.create({
+        baseURL,
+        retry: 0,
+        credentials: 'include',
+        onResponse({ options, response }) {
+            const apiOptions = options as ApiFetchOptions<'json'>
+            if (apiOptions?.toast === false) {
+                return
+            }
+
+            if (response?.status && response.status >= 400) {
+                return
+            }
+
+            const successKey = apiOptions?.toastSuccessKey
+            const successMessage =
+        apiOptions?.toastSuccessMessage ||
+        (successKey ? (te(successKey) ? t(successKey) : successKey) : '')
+
+            if (successMessage) {
+                toast.success({
+                    title: 'Succes',
+                    message: successMessage
+                })
+            }
+        },
+        async onResponseError({ response, error, options }) {
+            const apiOptions = options as ApiFetchOptions<'json'>
+            if (response?.status === 401) {
+                const requestUrl = typeof options?.url === 'string' ? options.url : ''
+                const isLoginCheck = requestUrl.includes('/login_check')
+                const isLogout = requestUrl.includes('/logout')
+                const shouldToast401 = apiOptions?.toastOn401 === true && apiOptions?.toast !== false
+
+                if (shouldToast401) {
+                    const errorKey = apiOptions?.toastErrorKey
+                    const errorMessage =
+            errorKey ? (te(errorKey) ? t(errorKey) : errorKey) : ''
+                    const extractedMessage = extractErrorMessage(error, response?._data)
+                    const message =
+            apiOptions?.toastErrorMessage ||
+            errorMessage ||
+            extractedMessage ||
+            'Une erreur est survenue.'
+
+                    toast.error({
+                        title: apiOptions?.toastTitle ?? 'Erreur',
+                        message
+                    })
+                }
+
+                if (!isLoginCheck && !isLogout) {
+                    if (!isHandlingUnauthorized) {
+                        isHandlingUnauthorized = true
+                        auth.clearSession()
+                        await navigateTo('/login')
+                        isHandlingUnauthorized = false
+                    }
+                }
+
+                return
+            }
+
+            if (apiOptions?.toast === false) {
+                return
+            }
+
+            const method =
+        typeof options?.method === 'string' ? options.method.toUpperCase() : 'GET'
+            const defaultKey = methodErrorKeys[method]
+            const defaultMessage =
+        defaultKey && te(defaultKey) ? t(defaultKey) : ''
+            const errorKey = apiOptions?.toastErrorKey
+            const errorMessage =
+        errorKey ? (te(errorKey) ? t(errorKey) : errorKey) : ''
+            const extractedMessage = extractErrorMessage(error, response?._data)
+            const message =
+        apiOptions?.toastErrorMessage ||
+        errorMessage ||
+        defaultMessage ||
+        extractedMessage ||
+        'Une erreur est survenue.'
+
+            toast.error({
+                title: apiOptions?.toastTitle ?? 'Erreur',
+                message
+            })
+        }
+    })
+
+    function request<T>(
+        method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE',
+        url: string,
+        options: ApiFetchOptions<'json'> = {}
+    ) {
+        const needsJsonBody = method === 'POST' || method === 'PUT'
+        const needsMergePatch = method === 'PATCH'
+        const isFormData = typeof FormData !== 'undefined' && options.body instanceof FormData
+
+        const headers = new Headers(options.headers as HeadersInit | undefined)
+
+        if (!isFormData) {
+            if (needsMergePatch && !headers.has('Content-Type')) {
+                headers.set('Content-Type', 'application/merge-patch+json')
+            } else if (needsJsonBody && !headers.has('Content-Type')) {
+                headers.set('Content-Type', 'application/json')
+            }
+        }
+
+        return client<T>(url, { ...options, method, headers })
+    }
+
+    return {
+        get<T>(url: string, query: AnyObject = {}, options: ApiFetchOptions<'json'> = {}) {
+            return request<T>('GET', url, { ...options, query })
+        },
+        post<T>(url: string, body: AnyObject = {}, options: ApiFetchOptions<'json'> = {}) {
+            return request<T>('POST', url, { ...options, body })
+        },
+        put<T>(url: string, body: AnyObject = {}, options: ApiFetchOptions<'json'> = {}) {
+            return request<T>('PUT', url, { ...options, body })
+        },
+        patch<T>(url: string, body: AnyObject = {}, options: ApiFetchOptions<'json'> = {}) {
+            return request<T>('PATCH', url, { ...options, body })
+        },
+        delete<T>(url: string, query: AnyObject = {}, options: ApiFetchOptions<'json'> = {}) {
+            return request<T>('DELETE', url, { ...options, query })
+        }
+    }
+}

frontend/shared/composables/useAppVersion.ts

@@ -0,0 +1,15 @@
+const version = ref('')
+
+export function useAppVersion() {
+    async function load() {
+        try {
+            const api = useApi()
+            const data = await api.get<{ version: string }>('/version', {}, { toast: false })
+            version.value = data.version
+        } catch {
+            version.value = '?'
+        }
+    }
+
+    return { version, load }
+}

frontend/shared/composables/useSidebar.ts

@@ -0,0 +1,46 @@
+import type { SidebarSection } from '~/shared/types'
+
+const sections = ref<SidebarSection[]>([])
+const disabledRoutes = ref<string[]>([])
+const loaded = ref(false)
+
+export function useSidebar() {
+    async function loadSidebar() {
+        try {
+            const api = useApi()
+            const data = await api.get<{ sections: SidebarSection[]; disabledRoutes: string[] }>(
+                '/sidebar',
+                {},
+                { toast: false }
+            )
+            sections.value = data.sections ?? []
+            disabledRoutes.value = data.disabledRoutes ?? []
+            loaded.value = true
+        } catch {
+            sections.value = []
+            disabledRoutes.value = []
+            loaded.value = true
+        }
+    }
+
+    function isRouteDisabled(path: string): boolean {
+        return disabledRoutes.value.some(
+            disabled => path === disabled || path.startsWith(disabled + '/')
+        )
+    }
+
+    function resetSidebar() {
+        sections.value = []
+        disabledRoutes.value = []
+        loaded.value = false
+    }
+
+    return {
+        sections,
+        disabledRoutes,
+        loaded,
+        loadSidebar,
+        resetSidebar,
+        isRouteDisabled,
+    }
+}

frontend/shared/services/auth.ts

@@ -0,0 +1,22 @@
+import type { UserData } from '~/shared/types/user-data'
+
+export function getCurrentUser() {
+    const api = useApi()
+    return api.get<UserData>('/me', {}, { toastErrorKey: 'errors.auth.session' })
+}
+
+export function login(username: string, password: string) {
+    const api = useApi()
+    return api.post('/login_check', { username, password }, {
+        toastOn401: true,
+        toastErrorKey: 'errors.auth.login'
+    })
+}
+
+export function logout() {
+    const api = useApi()
+    return api.post('/logout', {}, {
+        toastErrorKey: 'errors.auth.logout',
+        toastSuccessKey: 'success.auth.logout'
+    })
+}

frontend/shared/stores/auth.ts

@@ -0,0 +1,71 @@
+import { defineStore } from 'pinia'
+import type { UserData } from '~/shared/types/user-data'
+import { getCurrentUser, login, logout } from '~/shared/services/auth'
+
+export const useAuthStore = defineStore('auth', {
+    state: () => ({
+        user: null as UserData | null,
+        isLoading: false,
+        checked: false
+    }),
+    getters: {
+        isAuthenticated: (state) => Boolean(state.user)
+    },
+    actions: {
+        clearSession() {
+            this.user = null
+            this.checked = true
+            this.isLoading = false
+        },
+        async ensureSession() {
+            if (this.checked) {
+                return this.user
+            }
+
+            this.checked = true
+
+            try {
+                const me = await getCurrentUser()
+                this.user = me
+                return me
+            } catch {
+                this.user = null
+                return null
+            }
+        },
+        async login(username: string, password: string) {
+            this.isLoading = true
+
+            try {
+                await login(username, password)
+                const me = await getCurrentUser()
+                this.user = me
+                this.checked = true
+                return me
+            } finally {
+                this.isLoading = false
+            }
+        },
+        async logout() {
+            this.isLoading = true
+
+            try {
+                await logout()
+            } catch {
+                // Ignore logout errors so we can still clear local auth state.
+            } finally {
+                this.user = null
+                this.checked = true
+                this.isLoading = false
+            }
+        },
+        async refreshUser() {
+            try {
+                const me = await getCurrentUser()
+                this.user = me
+            } catch {
+                // Silently fail — user session might have expired
+            }
+        }
+    }
+})

frontend/shared/stores/ui.ts

@@ -0,0 +1,19 @@
+import { defineStore } from 'pinia'
+
+export const useUiStore = defineStore('ui', {
+    state: () => ({
+        sidebarCollapsed: false,
+        sidebarOpen: false,
+    }),
+    actions: {
+        toggleSidebar() {
+            this.sidebarCollapsed = !this.sidebarCollapsed
+        },
+        openMobileSidebar() {
+            this.sidebarOpen = true
+        },
+        closeMobileSidebar() {
+            this.sidebarOpen = false
+        },
+    },
+})

frontend/shared/types/index.ts

@@ -0,0 +1,11 @@
+export interface SidebarItem {
+    label: string
+    to: string
+    icon: string
+}
+
+export interface SidebarSection {
+    label: string
+    icon: string
+    items: SidebarItem[]
+}

frontend/shared/types/user-data.ts

@@ -0,0 +1,5 @@
+export interface UserData {
+    id: number
+    username: string
+    roles: string[]
+}

frontend/shared/utils/api.ts

@@ -0,0 +1,8 @@
+export interface HydraCollection<T> {
+    'hydra:member': T[]
+    'hydra:totalItems': number
+}
+
+export function extractHydraMembers<T>(collection: HydraCollection<T>): T[] {
+    return collection['hydra:member'] ?? []
+}