@liorian/sdk 0.31.0-alpha.61fe5c2 → 0.38.0-alpha.7aa2e5b

package/README.md

@@ -3,8 +3,8 @@
 Design system, shell applicatif et socle partagé du monorepo **Liorian**.
 
 Le package concentre l'ensemble des briques réutilisables utilisées par les hôtes frontend du
-monorepo (`frontend/liorian-socle`, `frontend/liorian-auth`, `frontend/liorian-connect`,
-`frontend/liorian-console`, `frontend/liorian-store`) ainsi que par les modules externes
+monorepo (`apps/liorian-socle`, `apps/liorian-auth`, `apps/liorian-connect`,
+`apps/liorian-console`, `apps/liorian-store`) ainsi que par les modules externes
 déclarés par les applications : primitives UI (style shadcn), thème **Katon**, composants
 composés (`DataGrid`, modales, sheets, lecteur multimédia…), providers, hooks, stores zustand,
 routines, services API, domaines, enums et utilitaires.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@liorian/sdk",
-  "version": "0.31.0-alpha.61fe5c2",
-  "description": "Core package for the Liorian (application shell, domain, infrastructure, UI design system).",
+  "version": "0.38.0-alpha.7aa2e5b",
+  "description": "Core package for the Liora (application shell, domain, infrastructure, UI design system).",
   "type": "module",
   "license": "MIT",
   "publishConfig": {

package/schemas/module.schema.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "$id": "module-manifest.schema.json",
-  "$comment": "Schéma canonique du manifest.json des modules Liorian (@liorian/sdk). Référencé par les modules du socle (frontend/liorian-socle/src/modules/*) et les modules externes (frontend/liorian-socle/library/modules/*).",
+  "$comment": "Schéma canonique du manifest.json des modules Liorian (@liorian/sdk). Référencé par les modules du socle (apps/liorian-socle/src/modules/*) et les modules externes (apps/liorian-socle/library/modules/*).",
   "title": "Module Manifest (Liorian)",
   "description": "Manifeste d'installation et de déclaration d'un module Liorian. Ce fichier décrit l'identité du module, sa compatibilité (plateformes, versions socle/API), ses permissions, ses scopes OAuth, ses capacités Tauri et ses prérequis fonctionnels (requirements/optionalRequirements). Les dépendances npm d'exécution et de développement sont portées par le `package.json` du module. Il est la source de vérité des métadonnées techniques d'un module, consommée par le Module Store et l'outillage de distribution.",
   "type": "object",

package/src/application/service/auth-user.service.ts

@@ -7,6 +7,10 @@ import {UserInterface} from "../../domain/entities/user.interface";
 import {UserAuthResponseInterface} from "../../domain/entities/user-auth.interface";
 import {OrganizationInterface} from "../../domain/entities/organization.interface";
 import {AuthConfig} from "../../domain/config/auth.config";
+import {ActivityLockService} from "../../infrastructure/utilities/activity-lock.service";
+import {emitSessionExpired} from "../../infrastructure/utilities/session-events";
+import {getTokenExpiration, isTokenExpired} from "../../infrastructure/utilities/jwt.util";
+import {LocalDataPurgeService} from "../../infrastructure/utilities/local-data-purge.util";
 
 const instance = new CacheStorageCapability<AuthCacheInterface>(AuthConfig.storages.sessionKey, CacheStorageType.LOCAL);
 
@@ -54,8 +58,35 @@ export class AuthUserService {
         return instance.get('apiKey') ?? null;
     }
 
+    /**
+     * Timestamp d'expiration du jeton courant, ou `null` si le jeton est absent
+     * ou ne porte pas d'`exp` lisible. Permet de savoir *quand* la session
+     * expirera au lieu de le découvrir par une série de 401.
+     */
+    static getTokenExpiration(): number | null {
+        return getTokenExpiration(this.getToken());
+    }
+
+    /**
+     * Vrai si un jeton est présent **et** non expiré.
+     *
+     * L'expiration est évaluée localement sur la claim `exp` du JWT : sans
+     * cela, un jeton expiré depuis des heures reste considéré comme
+     * « connecté » jusqu'au prochain appel à l'API — l'application traverse
+     * alors une fenêtre où elle s'affiche connectée mais ne peut plus rien
+     * faire, et l'écran de connexion peut se retrouver dans un état
+     * incohérent.
+     *
+     * Un jeton non-JSON (opaque) n'est jamais considéré expiré ici : seule
+     * l'API peut trancher.
+     */
+    static isTokenValid(): boolean {
+        const token = this.getToken();
+        return !!token && !isTokenExpired(token);
+    }
+
     static isAuthenticated(): boolean {
-        return !!this.getToken();
+        return this.isTokenValid();
     }
 
     static async setUser(user: UserInterface) {
@@ -83,21 +114,100 @@ export class AuthUserService {
         await instance.set('apiKey', apiKey).save();
     }
 
+    /**
+     * Installe une session neuve (connexion directe ou échange du code OAuth).
+     *
+     * Effets de bord :
+     *  - l'organisation courante et la clé d'API de la session précédente sont
+     *    purgées : elles portent sur l'identité et le périmètre de l'ancienne
+     *    session et seraient sinon renvoyées avec le **nouveau** jeton
+     *    (`X-Organization-Id`, `X-API-KEY`), ce qui est à la fois inutile et
+     *    faussé ;
+     *  - le verrou d'inactivité, **persisté** dans `localStorage`, est levé.
+     *    Sans cela, un verrou laissé actif survit à la reconnexion :
+     *    `AuthProvider`/`AuthGuard` ré-affichent alors immédiatement l'écran de
+     *    verrouillage et l'utilisateur reste bloqué sur l'écran de connexion
+     *    malgré une session parfaitement valide.
+     */
     static async setSession(payload: UserAuthResponseInterface) {
+        // Purge préalable des traces du compte précédent : sans cela, les
+        // données locales (modules activés, panier, notifications lues,
+        // brouillons…) survivent et corrompent la session qui s'installe —
+        // éventuellement au profit d'un autre utilisateur sur le même
+        // navigateur. La purge est sélective (préférences d'appareil
+        // conservées) et best-effort : elle ne bloque jamais l'installation.
+        // Les secrets PKCE lus avant l'échange ont déjà été copiés en mémoire
+        // par l'appelant, leur suppression ici est donc sans danger.
+        try {
+            await LocalDataPurgeService.purge('new-session');
+        } catch {
+            // Best-effort : l'installation de la session prime.
+        }
+
         const {user, token, device, organizations} = payload;
         instance
             .set('user', user)
             .set('token', token)
             .set('device', device)
-            .set('organizations', organizations);
+            .set('organizations', organizations)
+            .set('currentOrganization', null)
+            .set('apiKey', null);
 
         await instance.save();
         setCookie('token', token);
-    }
 
-    static async clear() {
+        // S'authentifier, c'est déverrouiller : la nouvelle session prend le
+        // pas sur tout verrou d'inactivité résiduel.
+        ActivityLockService.unlock();
+    }
+
+    /**
+     * Purge **totale** des données locales rattachées au compte.
+     *
+     * Unique point de sortie de la session locale, emprunté par la déconnexion
+     * comme par l'expiration. Au-delà de la session chiffrée et du cookie
+     * `token`, elle délègue à {@link LocalDataPurgeService} l'effacement de
+     * toutes les autres traces du compte :
+     *
+     *  - `localStorage` : verrou d'inactivité, modules activés, état
+     *    d'installation, secrets PKCE OAuth, notifications lues, modules récents ;
+     *  - `sessionStorage` : brouillon des formulaires en cours de saisie ;
+     *  - cookies rattachés au compte ;
+     *  - mémoire : cache React Query, magasins Zustand (via les hooks
+     *    enregistrés par leurs auteurs).
+     *
+     * Sans cela, ces données survivent à la fin de session et réapparaissent à la
+     * connexion suivante — éventuellement au profit d'un autre utilisateur sur le
+     * même navigateur.
+     */
+    static async clear(reason: string = "unknown") {
         await instance.clear().save();
         deleteCookie('token');
+        ActivityLockService.unlock();
+        await LocalDataPurgeService.purge(reason);
+    }
+
+    /**
+     * Point d'entrée unique d'invalidation de session.
+     *
+     * Purge la session locale puis notifie les abonnés (`AuthProvider`) afin
+     * que l'interface passe en écran de connexion. L'opération est
+     * **idempotente** : une rafale de 401 simultanées n'émet qu'un seul
+     * événement, et une application déjà déconnectée n'émet rien.
+     *
+     * @returns `true` si une session a effectivement été invalidée.
+     */
+    static async invalidate(source: string = 'unknown'): Promise<boolean> {
+        // Attend le déchiffrement du stockage : sans cela, une 401 reçue avant
+        // la fin de l'hydratation verrait une session « absente » et
+        // n'émettrait aucune invalidation.
+        await this.ready();
+
+        if (!instance.get('token')) return false;
+
+        await this.clear(source);
+        emitSessionExpired({source});
+        return true;
     }
 
     static getCsrfToken(): string | null {

package/src/application/service/config-module-api.service.ts

@@ -0,0 +1,95 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {FetchResponseInterface} from "../../domain/typing/response";
+
+/**
+ * Service API du CRUD auto-généré des modules `CONFIGURATION`
+ * (T-504/S-028, FR-026) — cible `liorian-api-core` `/config-modules`.
+ *
+ * L'organisation est portée par l'en-tête `X-Organization-Id` (middleware
+ * `OrganizationApiKeyMiddleware`) ; le jeton proxy scopé d'un module iframe
+ * est attaché par la couche HTTP du socle (T-506).
+ */
+
+export interface ConfigModuleRecord {
+    id: string;
+    data: Record<string, any>;
+    createdAt: string | null;
+    updatedAt: string | null;
+}
+
+export interface ConfigModuleListResponse {
+    rows: ConfigModuleRecord[];
+    total: number;
+}
+
+export interface ConfigModuleAggregatePayload {
+    fn?: "count" | "sum" | "mean";
+    /** Champ agrégé — omitir pour `__count`. */
+    field?: string;
+    /** Clé de regroupement (charts) — produit `rows: [{key, value}]`. */
+    groupBy?: string;
+}
+
+export interface ConfigModuleAggregateScalar {
+    value: number;
+    field: string;
+    fn: string;
+}
+
+export interface ConfigModuleAggregateGrouped {
+    fn: string;
+    field: string;
+    groupBy: string;
+    rows: Array<{key: string; value: number}>;
+}
+
+export type ConfigModuleAggregateResponse = ConfigModuleAggregateScalar | ConfigModuleAggregateGrouped;
+
+export class ConfigModuleApiService extends ApiService {
+
+    /** Lister les enregistrements d'une ressource (`?search=`). */
+    static async list(moduleIdentifier: string, resource: string, options?: {search?: string}) {
+        return await this.get<FetchResponseInterface<ConfigModuleListResponse>>(
+            `/config-modules/${moduleIdentifier}/${resource}`,
+            options?.search ? {search: options.search} : undefined,
+        );
+    }
+
+    /** Obtenir un enregistrement. */
+    static async findOne(moduleIdentifier: string, resource: string, recordId: string) {
+        return await this.get<FetchResponseInterface<ConfigModuleRecord>>(
+            `/config-modules/${moduleIdentifier}/${resource}/${recordId}`,
+        );
+    }
+
+    /** Créer un enregistrement. */
+    static async create(moduleIdentifier: string, resource: string, data: Record<string, any>) {
+        return await this.post<FetchResponseInterface<ConfigModuleRecord>>(
+            `/config-modules/${moduleIdentifier}/${resource}`,
+            data,
+        );
+    }
+
+    /** Mettre à jour un enregistrement. */
+    static async update(moduleIdentifier: string, resource: string, recordId: string, data: Record<string, any>) {
+        return await this.put<FetchResponseInterface<ConfigModuleRecord>>(
+            `/config-modules/${moduleIdentifier}/${resource}/${recordId}`,
+            data,
+        );
+    }
+
+    /** Supprimer (soft-delete) un enregistrement. */
+    static async remove(moduleIdentifier: string, resource: string, recordId: string) {
+        return await this.delete<FetchResponseInterface<unknown>>(
+            `/config-modules/${moduleIdentifier}/${resource}/${recordId}`,
+        );
+    }
+
+    /** Agrégat générique — `kpi` (scalaire) ou `chart` (groupé via `groupBy`). */
+    static async aggregate(moduleIdentifier: string, resource: string, payload: ConfigModuleAggregatePayload = {}) {
+        return await this.post<FetchResponseInterface<ConfigModuleAggregateResponse>>(
+            `/config-modules/${moduleIdentifier}/${resource}/_aggregate`,
+            payload,
+        );
+    }
+}

package/src/application/service/module-installation-api.service.ts

@@ -0,0 +1,118 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {FetchResponseInterface} from "../../domain/typing/response";
+import type {
+    InstallModulePayloadInterface,
+    ModuleAssetTokenInterface,
+    ModuleInstallationItemInterface,
+    ModuleRegistryItemInterface,
+    ModuleResolutionResponseInterface,
+    ResolveModulePayloadInterface,
+    SyncInstallationsPayloadInterface,
+    SyncInstallationsResultInterface,
+} from "../../domain/entities/module-installation.interface";
+
+/**
+ * Service API du domaine `module-installation` (T-403).
+ *
+ * Cible `liorian-api-core` (base `/module-installation`) : résolution,
+ * installation, cycle de vie, sync et jetons d'artefacts.
+ */
+export class ModuleInstallationApiService extends ApiService {
+
+    private static org(organizationId: string) {
+        return `/module-installation/organizations/${organizationId}`;
+    }
+
+    /** Étape 2 — Résoudre la version compatible (T-301). */
+    static async resolveModule(organizationId: string, payload: ResolveModulePayloadInterface) {
+        return await this.post<FetchResponseInterface<ModuleResolutionResponseInterface>>(
+            `${this.org(organizationId)}/resolve`,
+            payload,
+        );
+    }
+
+    /** Étape 5 — Installer la version résolue (jeton mono-usage, ⚠️ AdminOrAbove). */
+    static async installModule(organizationId: string, payload: InstallModulePayloadInterface) {
+        return await this.post<FetchResponseInterface<ModuleInstallationItemInterface>>(
+            `${this.org(organizationId)}/installations`,
+            payload,
+        );
+    }
+
+    /** Liste des installations (filtres `state`). */
+    static async listInstallations(organizationId: string, states?: string[]) {
+        const search = states && states.length ? `?state=${encodeURIComponent(states.join(','))}` : '';
+        return await this.get<FetchResponseInterface<ModuleInstallationItemInterface[]>>(
+            `${this.org(organizationId)}/installations${search}`,
+        );
+    }
+
+    /** Détail d'une installation. */
+    static async getInstallation(organizationId: string, moduleIdentifier: string) {
+        return await this.get<FetchResponseInterface<ModuleInstallationItemInterface>>(
+            `${this.org(organizationId)}/installations/${moduleIdentifier}`,
+        );
+    }
+
+    /** Registre pour le cache de rendu (ADR-006 : le core fait autorité). */
+    static async getRegistry(organizationId: string) {
+        return await this.get<FetchResponseInterface<ModuleRegistryItemInterface>>(
+            `${this.org(organizationId)}/installations/registry`,
+        );
+    }
+
+    /** Activer un module installé (⚠️). */
+    static async enableInstallation(organizationId: string, moduleIdentifier: string) {
+        return await this.post<FetchResponseInterface<ModuleInstallationItemInterface>>(
+            `${this.org(organizationId)}/installations/${moduleIdentifier}/enable`,
+            {},
+        );
+    }
+
+    /** Désactiver un module installé (⚠️). */
+    static async disableInstallation(organizationId: string, moduleIdentifier: string, reason?: string) {
+        return await this.post<FetchResponseInterface<ModuleInstallationItemInterface>>(
+            `${this.org(organizationId)}/installations/${moduleIdentifier}/disable`,
+            {reason},
+        );
+    }
+
+    /** Rollback vers la version précédente (⚠️). */
+    static async rollbackInstallation(organizationId: string, moduleIdentifier: string, targetVersion?: string) {
+        return await this.post<FetchResponseInterface<ModuleInstallationItemInterface>>(
+            `${this.org(organizationId)}/installations/${moduleIdentifier}/rollback`,
+            {targetVersion},
+        );
+    }
+
+    /** Désinstaller + purge disque (⚠️). */
+    static async uninstallInstallation(organizationId: string, moduleIdentifier: string) {
+        return await this.delete<FetchResponseInterface<unknown>>(
+            `${this.org(organizationId)}/installations/${moduleIdentifier}`,
+        );
+    }
+
+    /** Revalidation hors-ligne → en ligne. */
+    static async validateInstallation(organizationId: string, moduleIdentifier: string) {
+        return await this.post<FetchResponseInterface<ModuleInstallationItemInterface>>(
+            `${this.org(organizationId)}/installations/${moduleIdentifier}/validate`,
+            {},
+        );
+    }
+
+    /** Sync bidirectionnel (FR-023 : corrige V7). */
+    static async syncInstallations(organizationId: string, payload: SyncInstallationsPayloadInterface) {
+        return await this.post<FetchResponseInterface<SyncInstallationsResultInterface>>(
+            `${this.org(organizationId)}/installations/sync`,
+            payload,
+        );
+    }
+
+    /** Jeton d'accès iframe (TTL 24 h, T-310). */
+    static async issueAssetToken(organizationId: string, moduleIdentifier: string, version: string, deviceId?: string) {
+        return await this.post<FetchResponseInterface<ModuleAssetTokenInterface>>(
+            `/module-installation/artifacts/${moduleIdentifier}/${version}/assets-token`,
+            {deviceId},
+        );
+    }
+}

package/src/application/service/notifications-push.service.ts

@@ -2,6 +2,7 @@
 
 import {AppConfig} from "../../domain/config/app.config";
 import {ActivityTrackerService} from "../../infrastructure/utilities/activity-tracker.service";
+import {LocalDataPurgeService} from "../../infrastructure/utilities/local-data-purge.util";
 import {isTauri} from "../../infrastructure/utilities/tauri.util";
 import {NotificationsApiService} from "./notifications-api-service";
 import {NotificationsSocketService} from "./notifications-socket-service";
@@ -158,6 +159,17 @@ export class NotificationsPushService {
         notifications.forEach((notification) => this.seenNotificationIds.add(notification.id));
     }
 
+    /**
+     * Vide l'état local (notifications déjà vues) en fin de session.
+     *
+     * La clé `localStorage` est purgée par `LocalDataPurgeService` ; ce hook vide
+     * le `Set` en mémoire, qui se repeuplerait à la lecture — et se
+     * réenregistrerait — avec les notifications du compte suivant.
+     */
+    static resetSeenIds(): void {
+        this.seenNotificationIds = new Set<string>();
+    }
+
     protected static async poll(): Promise<void> {
         try {
             const notifications = await this.fetchUnreadNotifications();
@@ -297,3 +309,5 @@ export class NotificationsPushService {
     }
 
 }
+
+LocalDataPurgeService.onMemoryPurge(() => NotificationsPushService.resetSeenIds());

package/src/application/service/organizations-api-service.ts

@@ -85,6 +85,14 @@ export class OrganizationsApiService extends ApiService {
         return await this.delete(`/organization-preferences/${id}`);
     }
 
+    static async getConsoleConsent() {
+        return await this.get('/organization-consent');
+    }
+
+    static async setConsoleConsent(granted: boolean) {
+        return await this.put('/organization-consent', {granted});
+    }
+
     // Organization Document Types
     static async createDocumentType(payload: any) {
         return await this.post('/organization-document-types/', payload);

package/src/domain/config/app.config.ts

@@ -32,6 +32,7 @@ export const AppConfig = {
     CORE_SOCKET_HOST: process.env.NEXT_PUBLIC_CORE_SOCKET_HOST as unknown as string,
     CONNECT_API_HOST: process.env.NEXT_PUBLIC_CONNECT_API_HOST as unknown as string,
     STORE_API_HOST: process.env.NEXT_PUBLIC_STORE_API_HOST as unknown as string,
+    CONSOLE_API_HOST: process.env.NEXT_PUBLIC_CONSOLE_API_HOST as unknown as string,
     STORAGE_API_HOST: process.env.NEXT_PUBLIC_STORAGE_API_HOST as unknown as string,
 
     API_TIMEOUT: process.env.NEXT_PUBLIC_API_TIMEOUT as unknown as number,

package/src/domain/entities/catalog.interface.ts

@@ -39,6 +39,7 @@ export interface CatalogModuleInterface {
     isDefault: boolean;
     type: CatalogModuleType;
     external: boolean;
+    requiresActivationKey: boolean;
     categoryId?: string | null;
     category?: keyof typeof ModuleCategory | null;
     editorId?: string | null;
@@ -58,6 +59,7 @@ export interface CreateCatalogModulePayloadInterface {
     isDefault?: boolean;
     type?: CatalogModuleType;
     external?: boolean;
+    requiresActivationKey?: boolean;
     categoryId?: string | null;
 }
 
@@ -73,6 +75,7 @@ export interface UpdateCatalogModulePayloadInterface {
     isDefault?: boolean;
     type?: CatalogModuleType;
     external?: boolean;
+    requiresActivationKey?: boolean;
     categoryId?: string | null;
 }
 

package/src/domain/entities/index.ts

@@ -3,6 +3,7 @@ export * from "./activities.interface";
 export * from "./media";
 export * from "./catalog.interface";
 export * from "./module-activation.interface";
+export * from "./module-configuration.interface";
 export * from "./module.interface";
 export * from "./notification.interface";
 export * from "./objectable.type";

package/src/domain/entities/module-configuration.interface.ts

@@ -0,0 +1,68 @@
+import type React from "react";
+import type {IconKey} from "../../presentation/icons/types";
+import type {ModuleDeclarationInterface} from "./module.interface";
+
+/**
+ * Données partagées entre les steps du modal `ModuleConfiguration`.
+ */
+export interface ModuleConfigurationDataInterface {
+    /** Clé d'activation saisie (uniquement si le module requiert une activation). */
+    serialKey?: string;
+    /** Valeurs libres collectées par les steps de configuration. */
+    settings: Record<string, any>;
+}
+
+/**
+ * Props injectées à chaque composant de step déclaré par un module.
+ * Le développeur doit rendre réutilisable la section/le formulaire de la page
+ * de paramètres correspondante en acceptant ces props.
+ */
+export interface ModuleConfigurationStepPropsInterface<T extends Record<string, any> = Record<string, any>> {
+    /** Module en cours de configuration. */
+    module: ModuleDeclarationInterface;
+    /** Données courantes du stepper. */
+    data: Partial<T>;
+    /** Met à jour (merge) les données du stepper. */
+    updateData: (data: Partial<T>) => void;
+    /** Passe à l'étape suivante (déclenche les validateurs). */
+    next: () => void;
+    /** Revient à l'étape précédente. */
+    prev: () => void;
+}
+
+/**
+ * Déclaration d'une étape de configuration d'un module.
+ * Chaque étape correspond à une page/section du menu « Paramètres » du module.
+ */
+export interface ModuleConfigurationStepInterface<T extends Record<string, any> = Record<string, any>> {
+    /** Identifiant unique de l'étape. */
+    id: string;
+    /** Titre affiché dans le stepper. */
+    title: string;
+    /** Description optionnelle affichée sous le titre. */
+    description?: string;
+    /** Icône optionnelle. */
+    icon?: IconKey;
+    /** Si vrai, la navigation valide les champs HTML `required` de l'étape. */
+    required?: boolean;
+    /** Composant React réutilisable rendant la section/le formulaire. */
+    component: React.ComponentType<ModuleConfigurationStepPropsInterface<T>>;
+    /** Validateur optionnel de l'étape (peut rediriger vers une autre étape). */
+    validation?: (
+        data: Partial<T>,
+        updateData: (data: Partial<T>) => void,
+    ) => Promise<number | string | { step: number | string; lockNavigation?: boolean } | void>;
+}
+
+/**
+ * Configuration initiale d'un module, exécutée avant sa première ouverture.
+ */
+export interface ModuleConfigurationInterface {
+    /**
+     * Si vrai, une étape d'activation par clé série est ajoutée en première position
+     * (également affichée tant que le module n'est pas activé pour l'organisation).
+     */
+    requiresActivationKey?: boolean;
+    /** Étapes de configuration (une par page/section du menu Paramètres). */
+    steps?: ModuleConfigurationStepInterface[];
+}