@liorian/sdk 0.28.0-alpha.56010ca

package/src/infrastructure/utilities/api-service.ts

@@ -0,0 +1,237 @@
+import axios, {AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosProgressEvent} from "axios";
+import {AppConfig} from "../../domain/config/app.config";
+import {AuthUserService} from "../../application/service/auth-user.service";
+import {redirect} from "next/navigation";
+import {AuthConfig} from "../../domain/config/auth.config";
+import {toast} from "sonner";
+import {useAuth} from "../hooks/use-auth";
+
+class RequestLock {
+    private pending = 0;
+    private readonly queue: Array<() => void> = [];
+    private lastRequestTime = 0;
+
+    constructor(
+        private readonly maxConcurrency: number = 3,
+        private readonly minInterval: number = 200,
+    ) {}
+
+    async acquire(): Promise<void> {
+        if (this.pending >= this.maxConcurrency) {
+            await new Promise<void>(resolve => this.queue.push(resolve));
+        }
+
+        const now = Date.now();
+        const elapsed = now - this.lastRequestTime;
+        if (elapsed < this.minInterval && this.lastRequestTime > 0) {
+            await new Promise<void>(resolve => setTimeout(resolve, this.minInterval - elapsed));
+        }
+
+        this.pending++;
+        this.lastRequestTime = Date.now();
+    }
+
+    release(): void {
+        this.pending--;
+        this.lastRequestTime = Date.now();
+        const next = this.queue.shift();
+        if (next) next();
+    }
+}
+
+const requestLock = new RequestLock(3, 200);
+
+export class ApiService {
+
+    protected static _instance: AxiosInstance | undefined;
+
+    protected static baseUrl: string = AppConfig.CORE_API_HOST as string;
+    protected static timeout: number = AppConfig.API_TIMEOUT;
+
+    static get instance() {
+        this._instance = this._instance || axios.create({
+            timeout: this.timeout,
+            headers: {
+                // "X-API-KEY": `${AppConfig.key}`,
+                // "X-API-TOKEN": `${AppConfig.token}`,
+                // "X-TIMESTAMP": Math.floor(Date.now()/1000).toString(),
+            },
+        })
+
+        // this._instance = this._instance || axios;
+
+        return this._instance;
+    }
+
+    protected static buildAuthHeaders(extra?: Record<string, string>): Record<string, string> {
+        const token = AuthUserService.getToken();
+        const device = AuthUserService.getDevice();
+        const apiKey = AuthUserService.getApiKey();
+        const organization = AuthUserService.getCurrentOrganization();
+        const csrfToken = ApiService.getCsrfToken();
+        return {
+            "X-timestamp": (new Date()).toString(),
+            "Content-Type": "application/json",
+            "Accept": "*",
+            ...(token ? {"Authorization": `Bearer ${token}`} : {}),
+            ...(device ? {"X-Device": device} : {}),
+            ...(apiKey ? {"X-API-KEY": apiKey} : {}),
+            ...(organization ? {"X-Organization-Id": organization.id} : {}),
+            ...(csrfToken ? {"X-CSRF-Token": csrfToken} : {}),
+            "X-Client-Type": "desktop",
+            ...extra,
+        }
+    }
+
+    private static getCsrfToken(): string | null {
+        if (typeof document === 'undefined') return null;
+        const match = document.cookie.match(/(?:^|;\s*)_csrf=([^;]*)/);
+        return match ? decodeURIComponent(match[1]) : null;
+    }
+
+    static async request<T>(method: string, uri: string, data?: Record<string, any>, config?: AxiosRequestConfig<any> | undefined): Promise<AxiosResponse<T, any, {}>> {
+        return this.executeWithRateLimit(async () => {
+            const isGetMethod = method.toLowerCase() === 'get'
+            const headers = this.buildAuthHeaders()
+
+            let url = `${this.baseUrl}${uri}`;
+
+            if (isGetMethod) {
+                let queryString = '';
+                if (data) {
+                    const params = Object.entries(data)
+                        .map(([key, value]) => value ? `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`: undefined)
+                        .filter(v => typeof v !== 'undefined')
+                        .join('&');
+                    if (params) {
+                        queryString = (url.includes('?') ? '&' : '?') + params;
+                    }
+                }
+                url = `${url}${queryString}`;
+                data = undefined;
+            }
+
+            try {
+                return await this.instance.request({method, data, url, headers, ...config});
+            } catch (error: any) {
+                if (axios.isAxiosError(error) && error.response)
+                    await this.checkUnAuthenticationError(error.response);
+                throw error;
+            }
+        });
+    }
+
+    private static isRetryableError(error: any): boolean {
+        return axios.isAxiosError(error) && (
+            error.response?.status === 429 ||
+            !error.response
+        );
+    }
+
+    private static async executeWithRateLimit<T>(fn: () => Promise<T>, retries: number = 3): Promise<T> {
+        await requestLock.acquire();
+        let lastError: any;
+        try {
+            for (let attempt = 0; attempt <= retries; attempt++) {
+                try {
+                    const result = await fn();
+                    return result;
+                } catch (error: any) {
+                    lastError = error;
+                    if (this.isRetryableError(error) && attempt < retries) {
+                        const delay = error.response?.status === 429
+                            ? (() => {
+                                const retryAfter = error.response.headers['retry-after'];
+                                return retryAfter
+                                    ? parseInt(retryAfter, 10) * 1000
+                                    : Math.min(1000 * Math.pow(2, attempt), 10000);
+                            })()
+                            : 500 * Math.pow(2, attempt);
+                        await new Promise<void>(resolve => setTimeout(resolve, delay));
+                        continue;
+                    }
+                    if (!this.isRetryableError(lastError)) {
+                        this.parseError(lastError);
+                    }
+                    throw lastError;
+                }
+            }
+            throw lastError;
+        } finally {
+            requestLock.release();
+        }
+    }
+
+    protected static async checkUnAuthenticationError<T extends AxiosResponse<any>>(responses: T): Promise<void> {
+        if (typeof responses === 'object') {
+            if (responses.status === 401 || responses.status === 403) {
+                toast.error(`Vous n'êtes pas authorisé à avoir acceder à cette ressource`);
+                // await authLogoutUtil();
+                // redirect(AuthConfig.routes.login);
+            }
+            // if (responses.status === 500) {
+            //     if ('errorCode' in responses.data) {
+            //         const errorCode = parseInt((responses.data['errorCode']).toString());
+            //         if (errorCode === 1001) {
+            //             toast.error(`Vous devez être connecté pour acceder à cette ressource`);
+            //             await authLogoutUtil();
+            //             console.log(`Vous devez être connecté pour acceder à cette ressource`);
+            //             redirect(AuthConfig.routes.login);
+            //         }
+            //     }
+            // }
+        }
+    }
+
+    static async upload<T = any>(uri: string, formData: FormData, onUploadProgress?: (progressEvent: AxiosProgressEvent) => void, config?: AxiosRequestConfig<any> | undefined): Promise<AxiosResponse<T, any, {}>> {
+        // Ne PAS forcer « Content-Type » : axios (transformRequest) laisse le header tel quel
+        // pour un FormData, et un multipart sans boundary fait attendre le parseur serveur.
+        // On retire donc le défaut JSON pour que le client HTTP pose le bon header + boundary.
+        const headers = this.buildAuthHeaders();
+        delete headers["Content-Type"];
+        const url = `${this.baseUrl}${uri}`;
+
+        return this.executeWithRateLimit(async () => {
+            try {
+                return await this.instance.post(url, formData, {
+                    headers,
+                    onUploadProgress,
+                    ...config,
+                });
+            } catch (error: any) {
+                if (axios.isAxiosError(error) && error.response)
+                    await this.checkUnAuthenticationError(error.response);
+                throw error;
+            }
+        });
+    }
+
+    static parseError(error: any, defaultMessage?: string) {
+        toast.error(
+            (axios.isAxiosError(error) && error.response)
+                ? error.response.data.message
+                : defaultMessage || error.message || "Une erreur est survenue pendant le traitement de la requête"
+        )
+    }
+
+    static async post<T = any>(uri: string, data?: Record<string, any>, config?: AxiosRequestConfig<any> | undefined): Promise<AxiosResponse<T, any, {}>> {
+        return await this.request<T>('post', `${uri}`, data, config);
+    }
+
+    static async get<T = any>(uri: string, data?: Record<string, any>, config?: AxiosRequestConfig<any> | undefined): Promise<AxiosResponse<T, any, {}>> {
+        return await this.request<T>('get', `${uri}`, data, config);
+    }
+
+    static async put<T = any>(uri: string, data?: Record<string, any>, config?: AxiosRequestConfig<any> | undefined): Promise<AxiosResponse<T, any, {}>> {
+        return await this.request<T>('put', `${uri}`, data, config);
+    }
+
+    static async patch<T = any>(uri: string, data?: Record<string, any>, config?: AxiosRequestConfig<any> | undefined): Promise<AxiosResponse<T, any, {}>> {
+        return await this.request<T>('patch', `${uri}`, data, config);
+    }
+
+    static async delete<T = any>(uri: string, data?: Record<string, any>, config?: AxiosRequestConfig<any> | undefined): Promise<AxiosResponse<T, any, {}>> {
+        return await this.request<T>('delete', `${uri}`, data, config);
+    }
+
+}

package/src/infrastructure/utilities/auth-logout.util.ts

@@ -0,0 +1,23 @@
+import {AuthUserService} from "../../application/service/auth-user.service";
+import {authUserConnectedStore} from "../stores/auth-user-connected.store";
+import {ApiService} from "./api-service";
+import {AuthConfig} from "../../domain/config/auth.config";
+
+export async function authLogoutUtil() {
+    const {setCurrentUser} = authUserConnectedStore.getState()
+
+    // 1. Marque au backend que cette application s'est déconnectée sur cet appareil
+    // (révocation de la session persistée, de l'appareil et des jetons OAuth).
+    await AuthUserService.ready();
+    try {
+        await ApiService.post('/auth/logout', {clientId: AuthConfig.sso.clientId});
+    } catch {
+        // best-effort : la suppression locale doit toujours avoir lieu,
+        // même si le backend est injoignable ou que la session est déjà expirée.
+    }
+
+    // 2. Suppression des informations locales (localStorage '@auth-session' + cookie 'token').
+    await AuthUserService.clear()
+    setCurrentUser(undefined)
+    return true;
+}

package/src/infrastructure/utilities/classname.util.ts

@@ -0,0 +1,7 @@
+
+
+export const CommonClassName = {
+    layer: 'backdrop-blur-2xl p-1.5 gap-2 bg-background/50 dark:bg-background-800/50 text-white text-white rounded-full border border-background-400/10',
+    glossyBorder: ""
+    // glossyBorder: "relative shadow-xs ring-1 ring-white/20 backdrop-blur-md border-1 border-primary/10 dark:border-primary/30"
+}

package/src/infrastructure/utilities/encryption.service.ts

@@ -0,0 +1,125 @@
+"use client"
+
+export class EncryptionService {
+    private static algorithm = { name: 'AES-GCM', length: 256 };
+    private static key: CryptoKey | null = null;
+    private static readonly ENCRYPTION_KEY = process.env.NEXT_PUBLIC_ENCRYPTION_KEY;
+
+    private static async getWebCrypto(): Promise<Crypto> {
+        if (typeof window !== 'undefined' && window.crypto?.subtle) {
+            return window.crypto;
+        }
+        if (typeof globalThis !== 'undefined' && globalThis.crypto?.subtle) {
+            return globalThis.crypto;
+        }
+        // For older Node.js environments if globalThis.crypto is not available
+        try {
+            const { webcrypto } = await import('node:crypto');
+            return webcrypto as unknown as Crypto;
+        } catch (e) {
+            throw new Error('Web Crypto API not available. Ensure the page is served over HTTPS or localhost (secure context).');
+        }
+    }
+
+    private static async getKey(): Promise<CryptoKey> {
+        if (this.key) return this.key;
+
+        if (!this.ENCRYPTION_KEY) {
+            throw new Error('NEXT_PUBLIC_ENCRYPTION_KEY is not defined');
+        }
+
+        const webCrypto = await this.getWebCrypto();
+        const encoder = new TextEncoder();
+        const keyData = encoder.encode(this.ENCRYPTION_KEY);
+        
+        // Hash the key to ensure it has the correct length for AES-GCM (256 bits)
+        const hash = await webCrypto.subtle.digest('SHA-256', keyData);
+
+        this.key = await webCrypto.subtle.importKey(
+            'raw',
+            hash,
+            this.algorithm,
+            false,
+            ['encrypt', 'decrypt']
+        );
+
+        return this.key;
+    }
+
+    private static arrayBufferToBase64(buffer: Uint8Array): string {
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(buffer).toString('base64');
+        }
+        return btoa(String.fromCharCode(...buffer));
+    }
+
+    private static base64ToArrayBuffer(base64: string): Uint8Array {
+        if (typeof Buffer !== 'undefined') {
+            return new Uint8Array(Buffer.from(base64, 'base64'));
+        }
+        const binaryString = atob(base64);
+        const bytes = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            bytes[i] = binaryString.charCodeAt(i);
+        }
+        return bytes;
+    }
+
+    static async encrypt(data: string): Promise<string> {
+        try {
+            const key = await this.getKey();
+            const webCrypto = await this.getWebCrypto();
+            const encoder = new TextEncoder();
+            const encodedData = encoder.encode(data);
+            
+            // Initialization vector (IV) - must be unique for each encryption
+            const iv = webCrypto.getRandomValues(new Uint8Array(12));
+            
+            const encryptedBuffer = await webCrypto.subtle.encrypt(
+                {
+                    name: this.algorithm.name,
+                    iv: iv
+                },
+                key,
+                encodedData
+            );
+
+            // Combine IV and encrypted data
+            const combined = new Uint8Array(iv.length + encryptedBuffer.byteLength);
+            combined.set(iv);
+            combined.set(new Uint8Array(encryptedBuffer), iv.length);
+
+            // Convert to base64 for storage
+            return this.arrayBufferToBase64(combined);
+        } catch (error) {
+            console.error('Encryption failed:', error);
+            throw error;
+        }
+    }
+
+    static async decrypt(encryptedData: string): Promise<string> {
+        try {
+            const key = await this.getKey();
+            const webCrypto = await this.getWebCrypto();
+            const combined = this.base64ToArrayBuffer(encryptedData);
+
+            const iv = combined.slice(0, 12);
+            const data = combined.slice(12);
+
+            const decryptedBuffer = await webCrypto.subtle.decrypt(
+                {
+                    name: this.algorithm.name,
+                    iv: iv
+                },
+                key,
+                data
+            );
+
+            const decoder = new TextDecoder();
+            return decoder.decode(decryptedBuffer);
+        } catch (error) {
+            console.error('Decryption failed:', error);
+            throw error;
+        }
+    }
+}