@liorian/sdk 0.28.0-alpha.56010ca

package/src/infrastructure/stores/dataset.store.ts

@@ -0,0 +1,106 @@
+"use client"
+
+import * as React from "react";
+import {create, StoreApi, UseBoundStore} from "zustand";
+import { toast } from "sonner";
+
+export type DatesetPayload<T> = {
+    value: T;
+    required?: boolean;
+    key?: string;
+}
+
+// export type DatesetEntity<T> = Record<keyof T, DatesetPayload<T[keyof T]>>
+
+export type DatasetValidatorCallable<T> = (value: T) => string | null | undefined | boolean
+
+export interface DatasetInterface<T extends Object> {
+    dataset: T;
+    clear: () => void;
+    consolidate: () => T;
+    getter: <K extends keyof T>(key: K) => (T[K]) | undefined;
+    remove: <K extends keyof T>(key: K) => void;
+    setter: <K extends keyof T>(key: K, value: T[K]|undefined) => void;
+    setMany: (data: Partial<T>) => void;
+    validate: () => { valid: boolean; errors: Record<string, string> };
+    ensureValidAndToast: (mode?: "single" | "multiple" | "rich") => boolean;
+}
+
+export type DatasetInstanceType<T extends Object> =  UseBoundStore<StoreApi<DatasetInterface<T>>>
+
+export function createDataset<T extends Object>(defaultValues?: T, validators?: Partial<Record<keyof T, DatasetValidatorCallable<any>>>): DatasetInstanceType<T> {
+    return create<DatasetInterface<T>>((setState, getState) => ({
+        dataset: defaultValues || {} as T,
+        clear() {
+            setState({
+                dataset: {} as T
+            })
+        },
+        consolidate() {
+            const state = getState() as any;
+            // appeler la validation et afficher les erreurs via toast riche si nécessaire
+            if (typeof state.ensureValidAndToast === "function") {
+                state.ensureValidAndToast('rich');
+            }
+            return state.dataset || {};
+        },
+        getter<K extends keyof T>(key: K): (T[K]) | undefined {
+            return getState().dataset[key] || undefined;
+        },
+        remove<K extends keyof T>(key: K) {
+            const dataset: T = {} as T;
+            for (const [k, value] of Object.entries(getState().dataset)) {
+                if (k !== (key as string)) {
+                    (dataset as any)[k] = value as any;
+                }
+            }
+            return setState({dataset});
+        },
+        setter<K extends keyof T>(key: K, value: T[K]|undefined) {
+            return setState({dataset: {...getState().dataset, [key]: value}})
+        },
+        setMany(data: Partial<T>) {
+            setState({dataset: {...getState().dataset, ...data}})
+        },
+        validate() {
+            const errors: Record<string, string> = {};
+            if (validators) {
+                for (const [k, fn] of Object.entries(validators as Record<string, DatasetValidatorCallable<any>>)) {
+                    try {
+                        const value = (getState().dataset as any)[k];
+                        const res = fn?.(value);
+                        if (typeof res === "string" && res.length) errors[k] = res;
+                        else if (res === false) errors[k] = "Invalid value";
+                    } catch (err) {
+                        errors[k] = "Validation failed";
+                    }
+                }
+            }
+            return { valid: Object.keys(errors).length === 0, errors };
+        },
+        ensureValidAndToast(mode: "single" | "multiple" | "rich" = "single") {
+            const result = (getState() as any).validate() as { valid: boolean; errors: Record<string, string> };
+            if (!result.valid) {
+                if (mode === "multiple") {
+                    for (const [k, m] of Object.entries(result.errors)) {
+                        toast.error(`${k}: ${m}`);
+                    }
+                } else if (mode === "rich") {
+                    const items = Object.entries(result.errors).map(([k, m]) => React.createElement('li', { key: k }, `${k}: ${m}`));
+                    const content = React.createElement(
+                        'div',
+                        { style: { padding: 0 } },
+                        React.createElement('strong', null, 'Veuillez corriger les erreurs suivantes :'),
+                        React.createElement('ul', { style: { margin: '8px 0 0 16px' } }, ...items)
+                    );
+                    toast.error(content as any);
+                } else {
+                    const lines = Object.entries(result.errors).map(([k, m]) => `• ${k}: ${m}`);
+                    const message = ["Veuillez corriger les erreurs suivantes :", ...lines].join("\n");
+                    toast.error(message);
+                }
+            }
+            return result.valid;
+        }
+    }))
+}

package/src/infrastructure/stores/index.ts

@@ -0,0 +1,6 @@
+// @liorian/sdk/infrastructure/stores — zustand stores.
+export * from "./activity-lock.store";
+export * from "./auth-user-connected.store";
+export * from "./dataset.store";
+export * from "./module.store";
+export * from "./upload.store";

package/src/infrastructure/stores/module.store.ts

@@ -0,0 +1,266 @@
+"use client"
+
+import {create} from "zustand";
+import {persist} from "zustand/middleware";
+import {ModuleDeclarationInterface, ModuleInstanceInterface} from "../../domain/entities/module.interface";
+import {ModuleInstance} from "../../application/module-instance";
+import {ModuleActivationApiService} from "../../application/service/module-activation-api.service";
+import {StorefrontApiService} from "../../application/service/storefront-api.service";
+import {ModuleActivationInterface} from "../../domain/entities/module-activation.interface";
+import {ModuleStoreStateType} from "../../domain/entities/module-activation.interface";
+import {authUserConnectedStore} from "./auth-user-connected.store";
+
+interface ModuleState {
+    modules: ModuleDeclarationInterface[];
+    addModule: (module: ModuleDeclarationInterface) => void;
+    addModules: (modules: ModuleDeclarationInterface[]) => void;
+    toggleModule: (id: string) => void;
+    removeModule: (id: string) => void;
+    setModules: (modules: ModuleDeclarationInterface[]) => void;
+    selectedModule: ModuleDeclarationInterface | null;
+    selectModule: (idOrKeyOrIdentifier: string) => void;
+    construct: (idOrKeyOrIdentifier: string) => ModuleInstanceInterface | null;
+    verifyModules: () => Promise<void>;
+
+    // Module Store extensions
+    updateModuleState: (id: string, state: ModuleStoreStateType) => void;
+    updateModuleConfig: (id: string, config: Record<string, string>) => void;
+    setModuleInstalled: (id: string, installed: boolean) => void;
+    setModuleActivationExpiry: (id: string, expiresAt: string | null) => void;
+    getModuleByState: (state: ModuleStoreStateType) => ModuleDeclarationInterface[];
+    getModuleStoreStats: () => {
+        total: number;
+        installed: number;
+        enabled: number;
+        disabled: number;
+        available: number;
+        failed: number;
+    };
+}
+
+/**
+ * Une activation est valide si activée et non expirée (au niveau de l'activation
+ * elle-même et de sa clé sérielle).
+ */
+function isActivationActive(activation: ModuleActivationInterface): boolean {
+    if (!activation.isEnabled) return false;
+    const now = Date.now();
+    if (activation.expiredAt && new Date(activation.expiredAt).getTime() < now) return false;
+    if (activation.serialKey?.expiredAt && new Date(activation.serialKey.expiredAt).getTime() < now) return false;
+    return true;
+}
+
+interface ModuleVerification {
+    catalog: Set<string>;
+    allowed: Set<string>;
+}
+
+/**
+ * Récupère le catalogue des modules (ModuleStore) et les activations de
+ * l'organisation courante, puis calcule :
+ * - `catalog` : les identifiants existants dans le ModuleStore ;
+ * - `allowed` : les identifiants dont l'organisation a effectivement accès.
+ * Retourne `null` si l'organisation est inconnue ou si l'appel API échoue
+ * (dans ce cas, aucune vérification n'est appliquée).
+ */
+async function fetchModuleVerification(organizationId?: string | null): Promise<ModuleVerification | null> {
+    if (!organizationId) return null;
+
+    try {
+        const [catalogResponse, activationsResponse] = await Promise.all([
+            StorefrontApiService.getCatalogModules(),
+            ModuleActivationApiService.getOrganizationModules(organizationId),
+        ]);
+
+        const catalog = Array.isArray(catalogResponse?.data?.data) ? catalogResponse.data.data : [];
+        const activations = Array.isArray(activationsResponse?.data?.data) ? activationsResponse.data.data : [];
+
+        if (catalog.length === 0) return null;
+
+        const activeModuleIdentifiers = new Set(
+            activations.filter(isActivationActive).map(activation => activation.moduleIdentifier)
+        );
+
+        return {
+            catalog: new Set(catalog.map(module => module.identifier)),
+            allowed: new Set(
+                catalog
+                    .filter(module => activeModuleIdentifiers.has(module.identifier))
+                    .map(module => module.identifier)
+            ),
+        };
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Recherche un module du store par son identifiant technique (recommandé),
+ * en acceptant un repli sur sa clé courte.
+ */
+function findModule(
+    modules: ModuleDeclarationInterface[],
+    idOrKeyOrIdentifier: string,
+): ModuleDeclarationInterface | undefined {
+    return modules.find(m =>
+        m.identifier === idOrKeyOrIdentifier || m.key === idOrKeyOrIdentifier
+    );
+}
+
+export const useModuleStore = create<ModuleState>()(
+    // persist(
+    (setState, getState) => ({
+        modules: [],
+        selectedModule: null,
+        addModule: (module) => {
+            setState((state) => {
+                const persisted = state.modules.find(m => m.identifier === module.identifier);
+                return {
+                    modules: [...state.modules.filter(m => m.identifier !== module.identifier), {
+                        ...module,
+                        storeState: persisted?.storeState ?? module.storeState ?? (module.isEnabled ? 'enabled' : 'available'),
+                        storeConfig: persisted?.storeConfig ?? module.storeConfig,
+                        isInstalled: persisted?.isInstalled ?? module.isInstalled ?? false,
+                        activationExpiresAt: persisted?.activationExpiresAt ?? module.activationExpiresAt,
+                        lastSyncedAt: persisted?.lastSyncedAt ?? module.lastSyncedAt,
+                        isEnabled: persisted?.isEnabled ?? module.isEnabled,
+                    }]
+                };
+            });
+            void getState().verifyModules();
+        },
+        addModules: (newModules: ModuleDeclarationInterface[]) => {
+            setState((state) => {
+                // Fusionne les nouvelles déclarations (complètes) avec l'état
+                // (storeState, config, installation) des modules existants.
+                const existingByIdentifier = new Map(state.modules.map(m => [m.identifier, m]));
+                const merged = newModules.map((m) => {
+                    const persisted = existingByIdentifier.get(m.identifier);
+                    return {
+                        ...m,
+                        storeState: persisted?.storeState ?? m.storeState ?? (m.isEnabled ? 'enabled' : 'available'),
+                        storeConfig: persisted?.storeConfig ?? m.storeConfig,
+                        isInstalled: persisted?.isInstalled ?? m.isInstalled ?? false,
+                        activationExpiresAt: persisted?.activationExpiresAt ?? m.activationExpiresAt,
+                        lastSyncedAt: persisted?.lastSyncedAt ?? m.lastSyncedAt,
+                        isEnabled: persisted?.isEnabled ?? m.isEnabled,
+                    };
+                });
+                const newIds = new Set(merged.map(m => m.identifier));
+                const others = state.modules.filter(m => !newIds.has(m.identifier));
+                return {modules: [...others, ...merged]};
+            });
+            void getState().verifyModules();
+        },
+        toggleModule: (id) => setState((state) => ({
+            modules: state.modules.map((m) => {
+                if (m.identifier !== id || m.isDefault) return m;
+                const newEnabled = !m.isEnabled;
+                return {
+                    ...m,
+                    isEnabled: newEnabled,
+                    storeState: newEnabled ? 'enabled' as ModuleStoreStateType : 'disabled' as ModuleStoreStateType,
+                };
+            }),
+        })),
+        removeModule: (id) => setState((state) => ({
+            modules: state.modules.filter((m) => m.identifier !== id || m.isDefault),
+        })),
+        setModules: (modules) => setState({
+            modules: modules.map(m => ({
+                ...m,
+                storeState: m.storeState ?? (m.isEnabled ? 'enabled' : 'available'),
+            }))
+        }),
+        verifyModules: async () => {
+            const organizationId = authUserConnectedStore.getState().currentOrganization?.id;
+            const verification = await fetchModuleVerification(organizationId);
+            if (!verification) return;
+
+            setState((state) => ({
+                // Garde les modules hors catalogue (déclarés en local) et ceux
+                // autorisés pour l'organisation ; retire les modules du catalogue
+                // auxquels l'organisation n'a pas accès.
+                modules: state.modules.filter(
+                    (module) => !verification.catalog.has(module.identifier) || verification.allowed.has(module.identifier)
+                ),
+            }));
+        },
+        construct: (idOrKeyOrIdentifier: string) => {
+            const module = findModule(getState().modules, idOrKeyOrIdentifier);
+            return (module && module.key) ? new ModuleInstance(module.key) : null;
+        },
+        selectModule: (idOrKeyOrIdentifier: string) => {
+            const module = findModule(getState().modules, idOrKeyOrIdentifier);
+            if (module) {
+                setState({selectedModule: module});
+            }
+        },
+
+        // Module Store extensions
+        updateModuleState: (id, storeState) => setState((state) => ({
+            modules: state.modules.map((m) =>
+                m.identifier === id ? {
+                    ...m,
+                    storeState,
+                    isEnabled: storeState === 'enabled' || storeState === 'installed',
+                } : m
+            ),
+        })),
+
+        updateModuleConfig: (id, config) => setState((state) => ({
+            modules: state.modules.map((m) =>
+                m.identifier === id ? {...m, storeConfig: config} : m
+            ),
+        })),
+
+        setModuleInstalled: (id, installed) => setState((state) => ({
+            modules: state.modules.map((m) =>
+                m.identifier === id ? {
+                    ...m,
+                    isInstalled: installed,
+                    storeState: installed
+                        ? (m.isEnabled ? 'enabled' : 'installed') as ModuleStoreStateType
+                        : 'available' as ModuleStoreStateType,
+                } : m
+            ),
+        })),
+
+        setModuleActivationExpiry: (id, expiresAt) => setState((state) => ({
+            modules: state.modules.map((m) =>
+                m.identifier === id ? {...m, activationExpiresAt: expiresAt ?? undefined} : m
+            ),
+        })),
+
+        getModuleByState: (storeState) => {
+            return getState().modules.filter(m => m.storeState === storeState);
+        },
+
+        getModuleStoreStats: () => {
+            const modules = getState().modules;
+            return {
+                total: modules.length,
+                installed: modules.filter(m => m.isInstalled || m.storeState === 'installed' || m.storeState === 'enabled').length,
+                enabled: modules.filter(m => m.storeState === 'enabled').length,
+                disabled: modules.filter(m => m.storeState === 'disabled').length,
+                available: modules.filter(m => m.storeState === 'available').length,
+                failed: modules.filter(m => m.storeState === 'failed').length,
+            };
+        },
+    })
+    // {
+    //     name: "module-storage",
+    //     partialize: (state) => ({
+    //         modules: state.modules.map(m => ({
+    //             id: m.identifier,
+    //             storeState: m.storeState,
+    //             isInstalled: m.isInstalled,
+    //             storeConfig: m.storeConfig,
+    //             lastSyncedAt: m.lastSyncedAt,
+    //             activationExpiresAt: m.activationExpiresAt,
+    //             isEnabled: m.isEnabled,
+    //         })),
+    //     }),
+    // }
+    // )
+);

package/src/infrastructure/stores/upload.store.ts

@@ -0,0 +1,198 @@
+"use client"
+
+import { create } from "zustand"
+import { StorageApiService } from "../../application/service/storage-api-service"
+import type { MediaUploadOptions } from "../../domain/entities/media"
+import type { AxiosProgressEvent } from "axios"
+
+export type UploadStatus = "idle" | "uploading" | "done" | "error" | "cancelled"
+
+export interface UploadItem {
+    id: string
+    name: string
+    size: number
+    progress: number
+    speed: number
+    eta: number | null
+    status: UploadStatus
+    error?: string
+    result?: any
+}
+
+interface UploadStoreState {
+    uploads: UploadItem[]
+    isExpanded: boolean
+    hasActiveUploads: boolean
+    expand: () => void
+    collapse: () => void
+    toggle: () => void
+    addFiles: (files: File[], options?: MediaUploadOptions) => void
+    uploadFile: (file: File, options?: MediaUploadOptions, onProgress?: (event: AxiosProgressEvent) => void) => Promise<any>
+    removeFile: (id: string) => void
+    retryFile: (id: string) => void
+    cancelAll: () => void
+    clearCompleted: () => void
+}
+
+const filesById = new Map<string, File>()
+const optionsById = new Map<string, MediaUploadOptions>()
+const speedTrackers = new Map<string, { loaded: number; timestamp: number }>()
+const controllers = new Map<string, AbortController>()
+
+export const useUploadStore = create<UploadStoreState>((set, get) => {
+    const recomputeActive = (uploads: UploadItem[]) =>
+        uploads.some((u) => u.status === "uploading")
+
+    const updateUpload = (id: string, patch: Partial<UploadItem>) => {
+        const uploads = get().uploads.map((u) => (u.id === id ? { ...u, ...patch } : u))
+        set({ uploads, hasActiveUploads: recomputeActive(uploads) })
+    }
+
+    const trackProgress = (id: string, loaded: number) => {
+        const now = Date.now()
+        const prev = speedTrackers.get(id)
+        const speed = prev
+            ? (loaded - prev.loaded) / Math.max((now - prev.timestamp) / 1000, 0.001)
+            : 0
+        speedTrackers.set(id, { loaded, timestamp: now })
+        const item = get().uploads.find((u) => u.id === id)
+        if (!item) return
+        const remaining = item.size - loaded
+        const eta = speed > 0 ? remaining / speed : null
+        updateUpload(id, { speed, eta, progress: item.size ? (loaded / item.size) * 100 : 0 })
+    }
+
+    const startUpload = async (id: string, onProgress?: (event: AxiosProgressEvent) => void) => {
+        const file = filesById.get(id)
+        const item = get().uploads.find((u) => u.id === id)
+        const options = optionsById.get(id)
+        if (!file || !item) return
+
+        const controller = new AbortController()
+        controllers.set(id, controller)
+        updateUpload(id, { status: "uploading", progress: 0, speed: 0, eta: null, error: undefined })
+
+        try {
+            const response = await StorageApiService.uploadFile(file, options, (event) => {
+                trackProgress(id, event.loaded)
+                onProgress?.(event)
+            }, { signal: controller.signal })
+            const result = response.data?.data
+            updateUpload(id, { status: "done", progress: 100, eta: null, result })
+            return result
+        } catch (error: any) {
+            const cancelled = controller.signal.aborted
+            updateUpload(id, {
+                status: cancelled ? "cancelled" : "error",
+                eta: null,
+                error: cancelled
+                    ? undefined
+                    : error?.response?.data?.message || error?.message || "Une erreur est survenue",
+            })
+            throw error
+        } finally {
+            speedTrackers.delete(id)
+            controllers.delete(id)
+        }
+    }
+
+    const abortUpload = (id: string) => {
+        controllers.get(id)?.abort()
+    }
+
+    return {
+        uploads: [],
+        isExpanded: false,
+        hasActiveUploads: false,
+
+        expand: () => set({ isExpanded: true }),
+        collapse: () => set({ isExpanded: false }),
+        toggle: () => set((state) => ({ isExpanded: !state.isExpanded })),
+
+        addFiles: (files, options) => {
+            if (!files.length) return
+            const newUploads: UploadItem[] = files.map((file) => {
+                const id = crypto.randomUUID()
+                filesById.set(id, file)
+                if (options) optionsById.set(id, options)
+                return {
+                    id,
+                    name: file.name,
+                    size: file.size,
+                    progress: 0,
+                    speed: 0,
+                    eta: null,
+                    status: "idle",
+                }
+            })
+            set((state) => ({
+                uploads: [...state.uploads, ...newUploads],
+                isExpanded: true,
+                hasActiveUploads: true,
+            }))
+            newUploads.forEach((upload) => {
+                startUpload(upload.id).catch(() => {})
+            })
+        },
+
+        uploadFile: (file, options, onProgress) => {
+            const id = crypto.randomUUID()
+            filesById.set(id, file)
+            if (options) optionsById.set(id, options)
+            const newUpload: UploadItem = {
+                id,
+                name: file.name,
+                size: file.size,
+                progress: 0,
+                speed: 0,
+                eta: null,
+                status: "idle",
+            }
+            set((state) => ({
+                uploads: [...state.uploads, newUpload],
+                isExpanded: true,
+                hasActiveUploads: true,
+            }))
+            return startUpload(id, onProgress)
+        },
+
+        removeFile: (id) => {
+            abortUpload(id)
+            filesById.delete(id)
+            optionsById.delete(id)
+            speedTrackers.delete(id)
+            const uploads = get().uploads.filter((u) => u.id !== id)
+            set({ uploads, hasActiveUploads: recomputeActive(uploads) })
+        },
+
+        retryFile: (id) => {
+            if (!filesById.has(id)) return
+            updateUpload(id, { status: "idle", progress: 0, speed: 0, eta: null, error: undefined })
+            set({ hasActiveUploads: true })
+            startUpload(id).catch(() => {})
+        },
+
+        cancelAll: () => {
+            get().uploads.forEach((u) => abortUpload(u.id))
+            const uploads = get().uploads.map((u) =>
+                u.status === "uploading" || u.status === "idle"
+                    ? { ...u, status: "cancelled" as const, eta: null }
+                    : u
+            )
+            set({ uploads, hasActiveUploads: recomputeActive(uploads) })
+        },
+
+        clearCompleted: () => {
+            const uploads = get().uploads.filter(
+                (u) => u.status === "uploading" || u.status === "idle"
+            )
+            get().uploads.forEach((u) => {
+                if (u.status === "done" || u.status === "cancelled" || u.status === "error") {
+                    filesById.delete(u.id)
+                    optionsById.delete(u.id)
+                }
+            })
+            set({ uploads, hasActiveUploads: recomputeActive(uploads) })
+        },
+    }
+})