@liorian/sdk 0.28.0-alpha.56010ca

package/src/application/service/user-preferences-api.service.ts

@@ -0,0 +1,57 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+
+export interface UserPreferenceInterface {
+    id: string;
+    user_id: string;
+    label: string | null;
+    value: string;
+}
+
+export class UserPreferencesApiService extends ApiService {
+
+    static async getByUserId(userId: string) {
+        return await this.get(`/user-preferences/user/${userId}`);
+    }
+
+    static async getValue(userId: string, label: string): Promise<string | undefined> {
+        const response = await this.getByUserId(userId);
+        const payload = response?.data;
+        const preferences = Array.isArray(payload)
+            ? (payload as UserPreferenceInterface[])
+            : Array.isArray(payload?.data) ? (payload.data as UserPreferenceInterface[]) : [];
+        if (!preferences.length) return undefined;
+        return preferences.find((preference) => preference.label === label)?.value;
+    }
+
+    static async setValue(userId: string, label: string, value: string): Promise<void> {
+        await this.post<UserPreferenceInterface>('/user-preferences', {
+            user_id: userId,
+            label,
+            value,
+        });
+    }
+
+    static async getRecentColors(userId: string): Promise<string[]> {
+        const response = await this.get(`/user-preferences/colors/recent`);
+        return this.parseRecentColors(response);
+    }
+
+    static async addRecentColor(userId: string, color: string): Promise<string[]> {
+        const response = await this.post(`/user-preferences/colors/recent`, { color });
+        return this.parseRecentColors(response);
+    }
+
+    private static parseRecentColors(response: unknown): string[] {
+        const body = (response as {data?: any} | undefined)?.data ?? response;
+        const colors = Array.isArray(body?.colors)
+            ? body.colors
+            : Array.isArray(body?.data?.colors)
+                ? body.data.colors
+                : [];
+        return colors.filter(
+            (color: unknown): color is string =>
+                typeof color === 'string' && /^#([0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(color)
+        );
+    }
+
+}

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

@@ -0,0 +1,35 @@
+/** Convertit une valeur d'environnement en durée (ms) strictement positive, sinon repli. */
+function toPositiveMilliseconds(value: unknown, fallback: number): number {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+export const AppConfig = {
+    APP_HOST: process.env.NEXT_PUBLIC_APP_HOST as unknown as string,
+    APP_SLUG: process.env.NEXT_PUBLIC_APP_SLUG as unknown as string,
+    APP_NAME: process.env.NEXT_PUBLIC_APP_NAME as unknown as string,
+    APP_VERSION: process.env.NEXT_PUBLIC_APP_VERSION as unknown as string,
+    APP_VERSION_NUMBER: process.env.NEXT_PUBLIC_APP_VERSION_NUMBER as unknown as number,
+    
+    UI_REFRESH_TIMEOUT: process.env.NEXT_PUBLIC_UI_REFRESH_TIMEOUT as unknown as number,
+    UI_ACTIVITY_TRACKER_TIMEOUT: toPositiveMilliseconds(process.env.NEXT_PUBLIC_UI_ACTIVITY_TRACKER_TIMEOUT, 3 * 60 * 1000),
+    APP_REFRESH_UI: toPositiveMilliseconds(process.env.NEXT_PUBLIC_APP_REFRESH_UI, 30 * 1000),
+
+    AUTH_HOST: process.env.NEXT_PUBLIC_AUTH_HOST as unknown as string,
+    CONNECT_HOST: process.env.NEXT_PUBLIC_CONNECT_HOST as unknown as string,
+    CONSOLE_HOST: process.env.NEXT_PUBLIC_CONSOLE_HOST as unknown as string,
+    MANAGER_HOST: process.env.NEXT_PUBLIC_MANAGER_HOST as unknown as string,
+    STORE_HOST: process.env.NEXT_PUBLIC_MANAGER_HOST as unknown as string,
+
+    CORE_API_HOST: process.env.NEXT_PUBLIC_CORE_API_HOST as unknown as string,
+    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,
+    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,
+    VAPID_PUBLIC_KEY: process.env.NEXT_PUBLIC_VAPID_PUBLIC_KEY as unknown as string,
+    AUTH_CHECK_SESSION_TIMEOUT: process.env.NEXT_PUBLIC_AUTH_CHECK_SESSION_TIMEOUT as unknown as number,
+    COPYRIGHT_YEAR: new Intl.DateTimeFormat('fr-FR', {year: 'numeric'}).format(new Date()),
+
+}

package/src/domain/config/auth.config.ts

@@ -0,0 +1,30 @@
+export const AuthConfig = {
+    storages: {
+        sessionKey: '@auth-session'
+    },
+    services: {
+        api: "AuthApiService"
+    },
+    routes: {
+        login: '/auth/sign-in',
+        logout: '/auth/disconnect',
+        register: '/auth/sign-up',
+        selectOrganization: '/auth/select-organization',
+        verifyPhone: '/auth/sign-up/check-phone',
+    },
+    sso: {
+        /**
+         * Identifiant OAuth réservé à l'application consommatrice auprès de
+         * Liorian Auth (ex. `liorian-socle`, `liorian-connect`).
+         * Chaque application doit déclarer `NEXT_PUBLIC_AUTH_CLIENT_ID`.
+         */
+        clientId: process.env.NEXT_PUBLIC_AUTH_CLIENT_ID || 'liorian-socle',
+        /** Chemin de rappel SSO de l'application (code + state). */
+        redirectPath: '/auth/callback',
+    },
+    excludes: [
+        '/auth',
+        '/intl',
+        '/pos/menu'
+    ]
+};

package/src/domain/config/index.ts

@@ -0,0 +1,4 @@
+// @liorian/sdk/domain/config — centralized configuration contracts.
+export * from "./app.config";
+export * from "./auth.config";
+export * from "./logo.config";

package/src/domain/config/logo.config.ts

@@ -0,0 +1,17 @@
+export const LogoConfig = {
+    icon: {
+        normal: '/assets/logo/icon.png',
+        white: '/assets/logo/icon-white.png',
+        black: '/assets/logo/icon-black.png',
+    },
+    banner: {
+        normal: '/assets/logo/banner.png',
+        white: '/assets/logo/banner-white.png',
+        black: '/assets/logo/banner-black.png',
+    },
+    square: {
+        normal: '/assets/logo/square.png',
+        white: '/assets/logo/square-white.png',
+        black: '/assets/logo/square-black.png',
+    },
+}

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

@@ -0,0 +1,18 @@
+import {UserInterface} from "./user.interface";
+
+export interface ActivityInterface {
+    id: string;
+    action: string;
+    module: string;
+    description?: string;
+    describe?: string;
+    details?: Record<string, any>;
+    ipAddress?: string;
+    userAgent?: string;
+    userId: string;
+    organizationId: string;
+    createdAt: string;
+    user?: UserInterface;
+}
+
+export type ActivitiesType = ActivityInterface[];

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

@@ -0,0 +1,96 @@
+import type {ModuleCategory} from "../enums/module-category.enum";
+
+/**
+ * Types du catalogue public (storefront).
+ *
+ * Le catalogue est porté par `liorian-api-store` (base `/catalog`). Une fiche
+ * référence l'identité canonique `identifier` (`mod.liorian.*`) définie par
+ * `liorian-api-core` (`ModuleDomain`), sans jamais de clé étrangère
+ * inter-service.
+ */
+
+export type CatalogModuleType = 'INTERNAL' | 'EXTERNAL';
+
+export interface CatalogCategoryInterface {
+    id: string;
+    code: string;
+    label: string;
+    description?: string | null;
+    icon?: string | null;
+    isDefault: boolean;
+    sortOrder: number;
+    status: boolean;
+    editorId?: string | null;
+    createdAt?: Date | string | null;
+    updatedAt?: Date | string | null;
+}
+
+export interface CatalogModuleInterface {
+    id: string;
+    identifier: string;
+    name: string;
+    description?: string | null;
+    icon?: string | null;
+    logoUrl?: string | null;
+    bannerUrl?: string | null;
+    url: string;
+    isEnabled: boolean;
+    isDefault: boolean;
+    type: CatalogModuleType;
+    categoryId?: string | null;
+    category?: keyof typeof ModuleCategory | null;
+    editorId?: string | null;
+    createdAt?: Date | string | null;
+    updatedAt?: Date | string | null;
+}
+
+export interface CreateCatalogModulePayloadInterface {
+    identifier: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    logoUrl?: string | null;
+    bannerUrl?: string | null;
+    url: string;
+    isEnabled?: boolean;
+    isDefault?: boolean;
+    type?: CatalogModuleType;
+    categoryId?: string | null;
+}
+
+export interface UpdateCatalogModulePayloadInterface {
+    identifier?: string;
+    name?: string;
+    description?: string;
+    icon?: string;
+    logoUrl?: string | null;
+    bannerUrl?: string | null;
+    url?: string;
+    isEnabled?: boolean;
+    isDefault?: boolean;
+    type?: CatalogModuleType;
+    categoryId?: string | null;
+}
+
+export interface CreateCatalogCategoryPayloadInterface {
+    code: string;
+    label: string;
+    description?: string;
+    icon?: string;
+    isDefault?: boolean;
+    sortOrder?: number;
+    status?: boolean;
+}
+
+export interface UpdateCatalogCategoryPayloadInterface {
+    code?: string;
+    label?: string;
+    description?: string;
+    icon?: string;
+    isDefault?: boolean;
+    sortOrder?: number;
+    status?: boolean;
+}
+
+/** Catégorie d'un module telle qu'exposée dans la fiche catalogue. */
+export type CatalogModuleCategory = keyof typeof ModuleCategory;

package/src/domain/entities/index.ts

@@ -0,0 +1,13 @@
+// @liorian/sdk/domain/entities — shared entity interfaces.
+export * from "./activities.interface";
+export * from "./media";
+export * from "./catalog.interface";
+export * from "./module-activation.interface";
+export * from "./module.interface";
+export * from "./notification.interface";
+export * from "./objectable.type";
+export * from "./organization.interface";
+export * from "./user-auth.interface";
+export * from "./user-phone.interface";
+export * from "./user-profile.interface";
+export * from "./user.interface";

package/src/domain/entities/media.ts

@@ -0,0 +1,22 @@
+export interface MediaStorageInterface {
+    id?: string;
+    filename: string;
+    type: string;
+    label: string;
+    metadata?: any;
+    organizationId: string;
+    status?: boolean;
+    deletedAt?: Date;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+
+export interface MediaUploadOptions {
+    section?: string;
+    module?: string;
+    type?: string;
+    isDocument?: boolean;
+}
+
+export const MEDIA_SECTIONS = ["document", "image", "video", "audio", "autre"] as const;
+export type MediaSection = (typeof MEDIA_SECTIONS)[number];

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

@@ -0,0 +1,173 @@
+import {ModuleCategory} from "../enums/module-category.enum";
+
+export interface ModuleSerialKeyInterface {
+    id: string;
+    moduleIdentifier: string;
+    serialKey: string;
+    expiredAt?: Date | string | null;
+}
+
+/**
+ * Activation d'un module pour une organisation.
+ *
+ * `moduleIdentifier` est l'identité canonique `mod.liorian.*` (dénormalisée,
+ * sans FK vers le catalogue). Le statut « au catalogue mais non activé »
+ * (`available`) est calculé côté client en comparant ce champ au catalogue.
+ */
+export interface ModuleActivationInterface {
+    id: string;
+    organizationId: string;
+    moduleIdentifier: string;
+    serialKeyId: string;
+    isEnabled: boolean;
+    isDefault: boolean;
+    activatedAt?: Date | string | null;
+    expiredAt?: Date | string | null;
+    serialKey?: ModuleSerialKeyInterface | null;
+}
+
+export interface ValidateActivationResponseInterface {
+    isValid: boolean;
+}
+
+export interface ActivateModulePayloadInterface {
+    moduleIdentifier: string;
+    serialKey: string;
+    auditId?: string;
+}
+
+export type ModuleConfigSettingsFieldType = 'TEXT' | 'NUMBER' | 'EMAIL' | 'PASSWORD' | 'URL' | 'TEL' | 'SELECT' | 'TOGGLE';
+
+export interface ModuleConfigSettingsFieldOption {
+    label: string;
+    value: string;
+}
+
+export interface ModuleConfigSettingsFieldInterface {
+    key: string;
+    label: string;
+    description?: string;
+    placeholder?: string;
+    type?: ModuleConfigSettingsFieldType;
+    required?: boolean;
+    defaultValue?: string;
+    options?: ModuleConfigSettingsFieldOption[];
+}
+
+// --- État local d'un module côté client (store state) ---
+
+export type ModuleStoreStateType =
+    | 'available'
+    | 'activating'
+    | 'downloading'
+    | 'verifying'
+    | 'installing'
+    | 'installed'
+    | 'resolved'
+    | 'enabled'
+    | 'disabled'
+    | 'update_available'
+    | 'expired'
+    | 'revoked'
+    | 'incompatible'
+    | 'platform_unsupported'
+    | 'corrupted'
+    | 'uninstalled'
+    | 'failed';
+
+export interface ModuleStoreActivationResultInterface {
+    moduleId: string;
+    version?: string;
+    activationId?: string;
+    installationToken?: string;
+    downloadUrl?: string;
+    manifestUrl?: string;
+    checksum?: string;
+    signature?: string;
+    signatureKeyId?: string;
+    expiresAt?: string;
+}
+
+export interface ModuleStoreSyncPayloadInterface {
+    deviceId?: string;
+    managerVersion?: string;
+    runtime?: string;
+    modules: {
+        id: string;
+        version?: string;
+        enabled: boolean;
+        checksum?: string;
+        type?: string;
+    }[];
+}
+
+export interface ModuleStoreSyncResultInterface {
+    modules: {
+        id: string;
+        version?: string;
+        status: string;
+        updateAvailable?: boolean;
+        latestVersion?: string;
+        revoked?: boolean;
+        expired?: boolean;
+        updateRequired?: boolean;
+        platformSupported?: boolean;
+    }[];
+}
+
+export interface ModuleStoreConfigInterface {
+    moduleId: string;
+    organizationId: string;
+    settings: Record<string, string>;
+    updatedAt?: string;
+}
+
+export interface ModuleUsageRecordPayloadInterface {
+    moduleId: string;
+    moduleName?: string;
+    usageTimeMs: number;
+    useCount?: number;
+}
+
+export interface ModuleUsageAnalyticsItemInterface {
+    moduleId: string;
+    moduleName?: string | null;
+    usageTimeMs: number;
+    usagePercent: number;
+    useCount: number;
+    frequencyPercent: number;
+}
+
+export interface ModuleUsageAnalyticsInterface {
+    consent: boolean;
+    scope: 'organization' | 'user';
+    modules: ModuleUsageAnalyticsItemInterface[];
+}
+
+export interface ModuleRegistryEntryInterface {
+    schemaVersion: number;
+    deviceId?: string;
+    managerVersion?: string;
+    runtime?: string;
+    installedModules: ModuleRegistryInstalledModuleInterface[];
+}
+
+export interface ModuleRegistryInstalledModuleInterface {
+    id: string;
+    key?: string;
+    name: string;
+    version: string;
+    type: 'INTERNAL' | 'EXTERNAL';
+    category?: keyof typeof ModuleCategory;
+    enabled: boolean;
+    state: ModuleStoreStateType;
+    path?: string;
+    url?: string;
+    checksum?: string;
+    signature?: string;
+    signatureKeyId?: string;
+    installedAt?: string;
+    lastValidatedAt?: string;
+    activationExpiresAt?: string;
+    configSettings?: Record<string, string>;
+}

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

@@ -0,0 +1,101 @@
+import React from "react";
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {IconKey} from "../../presentation/icons/types";
+import {RoutineInterface} from "../typing/routine.types";
+import {AppRouterInstance} from "next/dist/shared/lib/app-router-context.shared-runtime";
+import {ModuleStoreStateType, ModuleConfigSettingsFieldInterface} from "./module-activation.interface";
+import {ModuleCategory} from "../enums/module-category.enum";
+
+export type ModuleType = 'INTERNAL' | 'EXTERNAL';
+
+export interface ModuleWidgetsInterface {
+    [K: string]: React.ComponentType<any>;
+}
+
+export interface ModuleInstanceInterface {
+    readonly identifier: string;
+
+    get options(): ModuleDeclarationInterface;
+
+    getOption<K extends keyof ModuleDeclarationInterface>(key: K): ModuleDeclarationInterface[K];
+
+    setOption<K extends keyof ModuleDeclarationInterface>(key: K, value: ModuleDeclarationInterface[K]): this;
+}
+
+export interface ModuleDeclarationServicesInterface {
+    fetch?: ApiService
+}
+
+export interface ModuleDeclarationProvidersInterface {
+    layout?: React.FC;
+}
+
+export interface ModuleDeclarationInterface {
+    identifier: string;
+    key?: string;
+    version?: string;
+    name: string;
+    description: string;
+    icon: IconKey;
+    logo?: string;
+    banner?: string;
+    routines?: RoutineInterface<any>[];
+    widgets?: ModuleWidgetsInterface;
+    service?: ModuleDeclarationServicesInterface;
+    uri: string; // URL de base pour la navigation
+    isEnabled?: boolean;
+    isDefault?: boolean; // Si true, ne peut pas être désactivé ou déplacé
+    type: ModuleType;
+    menu?: ModuleNavigationMenu;
+    requirements?: Record<string, string>; // Modules nécessaires pour fonctionner. Ex: 'nom-du-module' : 'version'
+    optionalRequirements?: Record<string, string>; // Modules nécessaires pour fonctionner. Ex: 'nom-du-module' : 'version'
+    dependencies?: Record<string, string>; // Dépendence de package npm nécessaires pour fonctionner. Ex: 'nom-du-module' : 'version'
+    devDependencies?: Record<string, string>; // Dépendence de package npm nécessaires pour fonctionner en mode dev. Ex: 'nom-du-module' : 'version'
+
+    // Module Store extensions
+    storeState?: ModuleStoreStateType; // État du module dans le store
+    configSettings?: ModuleConfigSettingsFieldInterface[]; // Paramètres configurables du module
+    storeConfig?: Record<string, string>; // Valeurs de configuration sauvegardées
+    isInstalled?: boolean; // Si le module est installé localement
+    lastSyncedAt?: string; // Dernière synchronisation avec le backend
+    activationExpiresAt?: string; // Date d'expiration de l'activation
+
+    // Catégorie du module (filtrage & regroupement dans le Module Store)
+    category?: keyof typeof ModuleCategory;
+
+    providers?: ModuleDeclarationProvidersInterface;
+}
+
+export interface ModuleNavigationDropdownInterface {
+    type: 'mega' | 'default' | 'mini';
+    side?: 'left' | 'right' | 'top' | 'bottom';
+    component: (module: ModuleNavigationInterface) => React.ReactNode;
+}
+
+export interface ModuleNavigationInterface {
+    id: string;
+    label: string;
+    description?: string;
+    icon?: IconKey;
+    url: string;
+    useOnlyIcon?: boolean;
+    dropdown?: ModuleNavigationDropdownInterface
+}
+
+
+export interface ModuleNavigationMenuItem {
+    label: string;
+    description?: string;
+    icon?: IconKey;
+    url?: string;
+    action?: (() => void | Promise<void>) | ((router: AppRouterInstance) => void);
+    items?: (ModuleNavigationMenuItem | ModuleNavigationMenuSeparator)[];
+}
+
+export interface ModuleNavigationMenuSeparator {
+    separator: boolean;
+}
+
+export interface ModuleNavigationMenu {
+    items: ModuleNavigationMenuItem[];
+}

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

@@ -0,0 +1,23 @@
+export enum NotificationTypeEnum {
+    ALERT = "ALERT",
+    INFORMATION = "INFORMATION",
+    CONFIRMATION = "CONFIRMATION",
+    REMINDER = "REMINDER",
+    SECURITY = "SECURITY",
+}
+
+export interface NotificationInterface {
+    id: string;
+    title?: string;
+    subject?: string;
+    body?: string;
+    message?: string;
+    content?: string;
+    type?: NotificationTypeEnum | string;
+    // isRead?: boolean;
+    // read?: boolean;
+    readAt?: string | null;
+    organizationId?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+}

package/src/domain/entities/objectable.type.ts

@@ -0,0 +1,3 @@
+
+
+export type ObjectableType = Record<string|number|symbol, any>;

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

@@ -0,0 +1,81 @@
+import {ModuleEnum} from "../enums/module.enum";
+import {MediaStorageInterface} from "./media";
+
+export interface OrganizationInterface {
+    id: string;
+    name: string;
+    description?: string | null;
+    logoId?: string | null;
+    logo?: MediaStorageInterface | null;
+    enabledModules: ModuleEnum[] | string[];
+    status: boolean;
+    deletedAt?: Date | string | null;
+    ownerId?: string;
+    auditId: string;
+    createdAt?: Date | string;
+    updatedAt?: Date | string;
+}
+
+export interface OrganizationMemberInterface {
+    id: string;
+    userId: string;
+    organizationId: string;
+    auditId: string;
+    isFounder: boolean;
+    status?: boolean;
+    deletedAt?: Date | string | null;
+    user?: {
+        id?: string;
+        username?: string;
+        email?: string;
+        avatar?: MediaStorageInterface | null;
+        userData?: {
+            firstname?: string;
+            lastname?: string;
+        };
+    } | null;
+}
+
+export interface OrganizationApiAccessKeyInterface {
+    id: string;
+    public: string;
+    secret: string;
+    organizationId: string;
+    expiredAt?: Date | string | null;
+    status: boolean;
+    deletedAt?: Date | string | null;
+    auditId: string;
+}
+
+export interface OrganizationApiAccessResponseInterface {
+    id: string;
+    publicKeys: string[];
+}
+
+export interface CreateOrganizationPayload {
+    name: string;
+    description?: string;
+    logoId?: string;
+    enabledModules?: ModuleEnum[];
+    auditId?: string;
+}
+
+export interface UpdateOrganizationPayload {
+    name?: string;
+    description?: string;
+    logoId?: string;
+    enabledModules?: ModuleEnum[];
+    status?: boolean;
+    auditId?: string;
+}
+
+export interface AddMemberPayload {
+    userId: string;
+    auditId?: string;
+}
+
+export interface CreateApiKeyPayload {
+    organizationId: string;
+    expiredAt?: Date | string | null;
+    auditId?: string;
+}