@liorian/sdk 0.28.0-alpha.56010ca

package/src/infrastructure/utilities/form-snapshot.service.ts

@@ -0,0 +1,304 @@
+"use client"
+
+/** Évènement window émis juste avant le verrouillage (le DOM des formulaires est encore monté). */
+export const ACTIVITY_LOCK_EVENT = "liorian:activity-lock";
+
+/** Évènement window émis juste après le déverrouillage (les formulaires sont remontés ensuite). */
+export const ACTIVITY_UNLOCK_EVENT = "liorian:activity-unlock";
+
+/** Clé sessionStorage du brouillon de formulaire : survit au rafraîchissement pendant le verrou. */
+export const ACTIVITY_LOCK_FORM_DRAFT_KEY = "@liorian-activity-lock-form-draft";
+
+export interface ActivityLockFormField {
+    /** Sélecteur/chemin unique permettant de retrouver le champ à la restauration. */
+    key: string;
+    tagName: "INPUT" | "SELECT" | "TEXTAREA";
+    /** Type de l'élément (utile pour les checkbox/radio). */
+    type?: string;
+    value?: string;
+    /** Valeurs sélectionnées pour les `<select multiple>`. */
+    values?: string[];
+    checked?: boolean;
+}
+
+export interface ActivityLockFormSnapshot {
+    capturedAt: number;
+    fields: ActivityLockFormField[];
+    /** Clé du champ qui avait le focus au moment du verrouillage. */
+    focusKey?: string;
+}
+
+/**
+ * Sauvegarde et restauration automatique de l'état des formulaires lors d'un
+ * verrouillage d'activité.
+ *
+ * - `FormSnapshotService.bind()` écoute les évènements de verrouillage/déverrouillage
+ *   émis par `ActivityLockService` et, sans configuration, sauvegarde tous les champs
+ *   montés (`input`, `select`, `textarea` - hors `password`, `file`, `hidden` et champs
+ *   désactivés) avant l'affichage de l'écran de verrouillage, puis les restaure à la
+ *   réouverture de l'interface (valeur + focus du champ précédemment édité).
+ * - Les champs sont retrouvés par clé stable (id → name scoped au formulaire → attribut
+ *   descriptif → chemin structurel) ; la restauration utilise le setter natif + un
+ *   évènement `input`/`change` pour être compatible avec les champs contrôlés React.
+ * - Le brouillon est stocké dans le `sessionStorage` : il survit au rafraîchissement
+ *   de la page pendant que l'écran reste verrouillé.
+ */
+export class FormSnapshotService {
+
+    protected static bound = false;
+
+    /**
+     * (R)attache les écouteurs de verrouillage/déverrouillage (idempotent).
+     * Appelé automatiquement par `ActivityLockService.start()`.
+     */
+    static bind(): void {
+        if (typeof window === "undefined" || this.bound) return;
+        this.bound = true;
+
+        const onLock = () => {
+            this.save();
+        };
+        const onUnlock = () => {
+            this.restoreAfterUnlock();
+        };
+
+        window.addEventListener(ACTIVITY_LOCK_EVENT, onLock);
+        window.addEventListener(ACTIVITY_UNLOCK_EVENT, onUnlock);
+    }
+
+    /** Sauvegarde l'état courant des formulaires montés dans le `sessionStorage`. */
+    static save(): boolean {
+        if (typeof document === "undefined" || typeof window === "undefined") return false;
+
+        const fields = this.collectControls();
+        const snapshot: ActivityLockFormSnapshot = {
+            capturedAt: Date.now(),
+            fields,
+            focusKey: this.elementKey(document.activeElement),
+        };
+
+        try {
+            window.sessionStorage.setItem(ACTIVITY_LOCK_FORM_DRAFT_KEY, JSON.stringify(snapshot));
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /** Restaure une seule fois le brouillon (si présent) puis l'efface. */
+    static restore(): boolean {
+        if (typeof document === "undefined" || typeof window === "undefined") return false;
+
+        const snapshot = this.read();
+        if (!snapshot) return false;
+
+        for (const field of snapshot.fields) {
+            const element = this.findByKey(field.key);
+            if (element) this.applyField(element, field);
+        }
+
+        if (snapshot.focusKey) {
+            const element = this.findByKey(snapshot.focusKey);
+            if (element instanceof HTMLElement) {
+                element.focus({preventScroll: true});
+                element.scrollIntoView({block: "center", behavior: "auto"});
+            }
+        }
+
+        try {
+            window.sessionStorage.removeItem(ACTIVITY_LOCK_FORM_DRAFT_KEY);
+        } catch {
+            // Stockage indisponible : on ignore.
+        }
+        return true;
+    }
+
+    /**
+     * Restaure le brouillon après le déverrouillage. Les champs cibles sont remontés
+     * de façon asynchrone par React, on tente donc de les retrouver pendant un court
+     * laps de temps avant d'appliquer le brouillon.
+     */
+    static restoreAfterUnlock(maxAttempts = 50, intervalMs = 40): void {
+        if (typeof window === "undefined") return;
+        const snapshot = this.read();
+        if (!snapshot || snapshot.fields.length === 0) return;
+
+        let attempts = 0;
+        const attempt = (): void => {
+            attempts += 1;
+            const ready = snapshot.fields.every((field) => this.findByKey(field.key));
+            if (ready || attempts >= maxAttempts) {
+                this.restore();
+            } else {
+                window.setTimeout(attempt, intervalMs);
+            }
+        };
+        window.setTimeout(attempt, intervalMs);
+    }
+
+    protected static collectControls(): ActivityLockFormField[] {
+        const fields: ActivityLockFormField[] = [];
+        const nodes = document.querySelectorAll<HTMLElement>("input, select, textarea");
+
+        nodes.forEach((el) => {
+            if (el instanceof HTMLInputElement) {
+                if (el.disabled || el.readOnly || el.type === "hidden" || el.type === "password" || el.type === "file") {
+                    return;
+                }
+            } else if (el instanceof HTMLSelectElement) {
+                if (el.disabled) return;
+            } else if (el instanceof HTMLTextAreaElement) {
+                if (el.disabled || el.readOnly) return;
+            }
+            const key = this.elementKey(el);
+            if (!key) return;
+
+            if (el instanceof HTMLInputElement) {
+                fields.push({key, tagName: "INPUT", type: el.type, value: el.value, checked: el.checked});
+            } else if (el instanceof HTMLSelectElement) {
+                fields.push({
+                    key,
+                    tagName: "SELECT",
+                    value: el.value,
+                    values: el.multiple ? Array.from(el.selectedOptions).map((option) => option.value) : undefined,
+                });
+            } else if (el instanceof HTMLTextAreaElement) {
+                fields.push({key, tagName: "TEXTAREA", value: el.value});
+            }
+        });
+
+        return fields;
+    }
+
+    protected static read(): ActivityLockFormSnapshot | undefined {
+        try {
+            const raw = window.sessionStorage.getItem(ACTIVITY_LOCK_FORM_DRAFT_KEY);
+            if (!raw) return undefined;
+            const snapshot = JSON.parse(raw) as ActivityLockFormSnapshot;
+            return Array.isArray(snapshot?.fields) ? snapshot : undefined;
+        } catch {
+            return undefined;
+        }
+    }
+
+    /** Construit une clé stable (id → name→ attribut descriptif → chemin structurel). */
+    protected static elementKey(element: Element | null): string | undefined {
+        if (!element) return undefined;
+        if (!(element instanceof HTMLInputElement)
+            && !(element instanceof HTMLSelectElement)
+            && !(element instanceof HTMLTextAreaElement)) {
+            return undefined;
+        }
+
+        const tag = element.tagName.toLowerCase();
+        const form = element.closest("form");
+        const formRef = form && form instanceof HTMLFormElement
+            ? form.id
+                ? `form[id="${this.escape(form.id)}"]`
+                : form.name
+                    ? `form[name="${this.escape(form.name)}"]`
+                    : undefined
+            : undefined;
+
+        if (element.id) {
+            return `${tag}[id="${this.escape(element.id)}"]`;
+        }
+        if (element.name) {
+            const fieldRef = `${tag}[name="${this.escape(element.name)}"]`;
+            return formRef ? `${formRef} > ${fieldRef}` : fieldRef;
+        }
+        for (const attr of ["aria-label", "data-testid", "placeholder"] as const) {
+            const value = element.getAttribute(attr);
+            if (value) {
+                const fieldRef = `${tag}[${attr}="${this.escape(value)}"]`;
+                return formRef ? `${formRef} > ${fieldRef}` : fieldRef;
+            }
+        }
+        return this.structuralKey(element);
+    }
+
+    /** Chemin structurel (nth-child) lorsqu'aucun attribut fiable n'est disponible. */
+    protected static structuralKey(element: Element): string | undefined {
+        const segments: string[] = [];
+        let current: Element | null = element;
+        let root: Element | null = element.closest("form");
+
+        while (current && current !== document.body) {
+            const host: HTMLElement | null = current.parentElement;
+            if (!host) return undefined;
+            const index = Array.from(host.children).indexOf(current);
+            if (index < 0) return undefined;
+            segments.unshift(`${current.tagName.toLowerCase()}:nth-child(${index + 1})`);
+            if (host === root || host === document.body) break;
+            current = host;
+        }
+
+        if (root && root !== document.body && root instanceof HTMLFormElement) {
+            const rootRef = root.id
+                ? `form[id="${this.escape(root.id)}"]`
+                : root.name
+                    ? `form[name="${this.escape(root.name)}"]`
+                    : "form";
+            return `${rootRef} > ${segments.join(" > ")}`;
+        }
+        return `body > ${segments.join(" > ")}`;
+    }
+
+    protected static findByKey(key: string): Element | null {
+        if (typeof document === "undefined") return null;
+        try {
+            return document.querySelector(key);
+        } catch {
+            return null;
+        }
+    }
+
+    /** Applique la valeur sauvegardée de façon compatible avec les champs contrôlés React. */
+    protected static applyField(element: Element, field: ActivityLockFormField): void {
+        if (element instanceof HTMLInputElement) {
+            if (field.type === "checkbox" || field.type === "radio") {
+                if (element.checked !== !!field.checked) element.click();
+                return;
+            }
+            this.setNativeValue(element, field.value ?? "");
+            return;
+        }
+        if (element instanceof HTMLTextAreaElement) {
+            this.setNativeValue(element, field.value ?? "");
+            return;
+        }
+        if (element instanceof HTMLSelectElement) {
+            if (element.multiple && field.values) {
+                Array.from(element.options).forEach((option) => {
+                    option.selected = field.values?.includes(option.value) ?? false;
+                });
+            } else {
+                element.value = field.value ?? "";
+            }
+            element.dispatchEvent(new Event("input", {bubbles: true}));
+            element.dispatchEvent(new Event("change", {bubbles: true}));
+        }
+    }
+
+    /** Set le contrôle via le setter natif puis déclenche `input`/`change` (gère React). */
+    protected static setNativeValue(
+        element: HTMLInputElement | HTMLTextAreaElement,
+        value: string
+    ): void {
+        const prototype = element instanceof HTMLTextAreaElement
+            ? HTMLTextAreaElement.prototype
+            : HTMLInputElement.prototype;
+        const setter = Object.getOwnPropertyDescriptor(prototype, "value")?.set;
+        if (setter) {
+            setter.call(element, value);
+        } else {
+            element.value = value;
+        }
+        element.dispatchEvent(new Event("input", {bubbles: true}));
+        element.dispatchEvent(new Event("change", {bubbles: true}));
+    }
+
+    protected static escape(value: string): string {
+        return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    }
+}

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

@@ -0,0 +1,40 @@
+export function formatAmount(value: number, currency: string = 'XOF', locale: string = 'fr-FR'): string {
+    return `${Math.round(value).toLocaleString(locale)} ${currency}`;
+}
+
+export function formatFileSize(bytes: number): string {
+    if (isNaN(bytes) || bytes === null || typeof bytes === 'undefined') return '0 o';
+    const units = ['o', 'Ko', 'Mo', 'Go', 'To'];
+    let i = 0;
+    let value = bytes;
+    while (value >= 1024 && i < units.length - 1) {
+        value /= 1024;
+        i++;
+    }
+    const decimals = i === 0 ? 0 : value >= 100 ? 0 : value >= 10 ? 1 : 2;
+    return `${value.toFixed(decimals)} ${units[i]}`;
+}
+
+export function formatBytesPerSecond(bytesPerSecond: number): string {
+    return `${formatFileSize(bytesPerSecond)}/s`;
+}
+
+export function formatEta(seconds: number | null | undefined): string {
+    if (!seconds || isNaN(seconds) || seconds <= 0 || !isFinite(seconds)) return '—';
+    if (seconds < 60) return `${Math.ceil(seconds)}s restantes`;
+    const minutes = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    if (minutes < 60) return `${minutes}m ${secs}s restantes`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${minutes % 60}m restantes`;
+}
+
+export function formatDuration(seconds: number | null | undefined): string {
+    if (!seconds || isNaN(seconds) || seconds <= 0 || !isFinite(seconds)) return '—';
+    if (seconds < 60) return `${Math.ceil(seconds)}s`;
+    const minutes = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    if (minutes < 60) return `${minutes}m ${secs.toString().padStart(2, '0')}s`;
+    const hours = Math.floor(minutes / 60);
+    return `${hours}h ${(minutes % 60).toString().padStart(2, '0')}m`;
+}

package/src/infrastructure/utilities/index.tsx

@@ -0,0 +1,23 @@
+// @liorian/sdk/infrastructure/utilities — shared utilities & services.
+export * from "./access-label.util";
+export * from "./activities.util";
+export * from "./activity-lock.service";
+export * from "./activity-tracker.service";
+export * from "./api-service";
+export * from "./auth-logout.util";
+export * from "./classname.util";
+export * from "./encryption.service";
+export * from "./form-snapshot.service";
+export * from "./format.util";
+export * from "./media-label.service";
+export * from "./modules";
+export * from "./permission.util";
+export * from "./push-permission.util";
+export * from "./route-access";
+export * from "./socket-service";
+export * from "./sso-auth.util";
+export * from "./stringable.util";
+export * from "./strings.util";
+export * from "./tauri.util";
+export * from "./utils";
+export * from "./values";

package/src/infrastructure/utilities/media-label.service.ts

@@ -0,0 +1,47 @@
+import type {MediaSection, MediaUploadOptions} from "../../domain/entities/media";
+
+type SectionSource = string | { mime?: string; extension?: string };
+
+const IMAGE_EXTENSIONS = ["jpg", "jpeg", "png", "gif", "webp", "svg", "bmp", "avif"];
+const VIDEO_EXTENSIONS = ["mp4", "webm", "mov", "avi", "mkv", "m4v"];
+const AUDIO_EXTENSIONS = ["mp3", "wav", "ogg", "flac", "aac", "m4a"];
+const DOCUMENT_EXTENSIONS = ["pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "txt", "csv", "rtf", "odt"];
+
+export class MediaLabelService {
+    static sectionFor(source: SectionSource): MediaSection {
+        const mime = typeof source === "string" ? source.toLowerCase() : source?.mime?.toLowerCase();
+        const extension = typeof source === "string"
+            ? ""
+            : source?.extension?.toLowerCase().replace(/^\./, "") ?? "";
+
+        if (mime) {
+            if (mime.startsWith("image/")) return "image";
+            if (mime.startsWith("video/")) return "video";
+            if (mime.startsWith("audio/")) return "audio";
+            if (mime === "application/pdf" || mime.startsWith("text/") || mime.includes("document")) return "document";
+        }
+
+        if (extension) {
+            if (IMAGE_EXTENSIONS.includes(extension)) return "image";
+            if (VIDEO_EXTENSIONS.includes(extension)) return "video";
+            if (AUDIO_EXTENSIONS.includes(extension)) return "audio";
+            if (DOCUMENT_EXTENSIONS.includes(extension)) return "document";
+        }
+
+        return "autre";
+    }
+
+    static build(module: string, section: MediaSection, type?: string): string {
+        const label = `${module.toLowerCase()}:${section.toLowerCase()}`;
+        return type ? `${label}.${type.toLowerCase()}` : label;
+    }
+
+    static resolve(module: string, options: MediaUploadOptions, type?: string): string {
+        const section = options.section
+            ? options.section.toLowerCase()
+            : options.isDocument
+                ? "document"
+                : this.sectionFor(options.type ?? options.module ?? "");
+        return this.build(module, section as MediaSection, type);
+    }
+}

package/src/infrastructure/utilities/modules.ts

@@ -0,0 +1,11 @@
+import {useModuleStore} from "../stores/module.store";
+import {ModuleDeclarationInterface} from "../../domain/entities/module.interface";
+
+export function retrieveModule(module?: string): ModuleDeclarationInterface | undefined {
+    return useModuleStore.getState().modules
+        .filter((m: ModuleDeclarationInterface) => {
+            const normalized = module?.replace(/-/g, '_').toLowerCase();
+            return m.key?.toLowerCase() === normalized
+                || m.identifier?.toLowerCase() === module?.toLowerCase();
+        })[0] || undefined;
+}

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

@@ -0,0 +1,22 @@
+import {type UserInterface, type UserPermissionCapabilities} from "../../domain/entities/user.interface";
+import {DomainsEnum} from "../../domain/enums/domains.enum";
+
+export function hasPermissions(capabilities: UserPermissionCapabilities, domains: DomainsEnum | DomainsEnum[], strict: boolean = true): boolean {
+    const entries = Object.keys(capabilities)
+    return (Array.isArray(domains) ? domains : [domains])
+        [strict ? 'every' : 'some'](domain => entries.includes(domain))
+}
+
+/** Niveau hiérarchique minimal pour administrer une organisation (Admin = 80) */
+export const ADMIN_ROLE_LEVEL = 80;
+
+const ADMIN_ROLE_NAMES = ['root', 'superadmin', 'admin'];
+
+export function isAdminOrAbove(user?: UserInterface | null, organizationId?: string | null): boolean {
+    return (user?.roles ?? []).some(role => {
+        if (organizationId && role.organizationId && role.organizationId !== organizationId) return false
+        const name = role.name?.toLowerCase().replace(/[\s_-]/g, '')
+        if (name && ADMIN_ROLE_NAMES.includes(name)) return true
+        return typeof role.level === 'number' && role.level >= ADMIN_ROLE_LEVEL
+    })
+}

package/src/infrastructure/utilities/push-permission.util.ts

@@ -0,0 +1,43 @@
+import {isTauri} from "./tauri.util";
+
+export type PushPermissionState = "granted" | "denied" | "unsupported";
+
+/**
+ * Demande l'autorisation d'afficher des notifications push.
+ * - Dans une application Tauri : via tauri-plugin-notification
+ * - Dans le navigateur : via l'API Notification standard
+ */
+export async function requestPushPermission(): Promise<PushPermissionState> {
+    if (isTauri()) {
+        try {
+            const plugin = await import("@tauri-apps/plugin-notification");
+            let granted = await plugin.isPermissionGranted();
+            if (!granted) {
+                const permission = await plugin.requestPermission();
+                granted = permission === "granted";
+            }
+            return granted ? "granted" : "denied";
+        } catch {
+            return "unsupported";
+        }
+    }
+
+    if (typeof window === "undefined" || !("Notification" in window)) {
+        return "unsupported";
+    }
+
+    if (Notification.permission === "granted") {
+        return "granted";
+    }
+
+    if (Notification.permission === "denied") {
+        return "denied";
+    }
+
+    try {
+        const permission = await Notification.requestPermission();
+        return permission === "granted" ? "granted" : "denied";
+    } catch {
+        return "denied";
+    }
+}

package/src/infrastructure/utilities/route-access.ts

@@ -0,0 +1,38 @@
+export type RouteAccessValidator = (route: string) => boolean
+
+export class RouteAccess {
+    protected static readonly entries: Map<string, RouteAccessValidator | undefined> = new Map()
+
+    public static add(route: string, validator?: RouteAccessValidator) {
+        this.entries.set(route, validator)
+    }
+
+    public static exists(route: string): boolean {
+        return this.entries.has(route)
+    }
+
+    public static getValidator(route: string): RouteAccessValidator | undefined {
+        return this.entries.get(route)
+    }
+
+    public static clear() {
+        this.entries.clear()
+    }
+
+    public static delete(route: string) {
+        this.entries.delete(route)
+    }
+
+    public static count(): number {
+        return this.entries.size
+    }
+
+    public static routes(): string[] {
+        return [...this.entries.keys()]
+    }
+}
+
+
+export class PublicRouteAccess extends RouteAccess {
+
+}

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

@@ -0,0 +1,123 @@
+import {AppConfig} from "../../domain/config/app.config";
+import {AuthUserService} from "../../application/service/auth-user.service";
+
+export type SocketEvent = "open" | "message" | "error" | "close";
+export type SocketEventHandler = (payload: any) => void;
+
+export class SocketService {
+
+    protected static _instance: WebSocket | undefined;
+    protected static _listeners: Map<SocketEvent, Set<SocketEventHandler>> = new Map();
+    protected static _reconnectAttempts: number = 0;
+    protected static _reconnectTimeout: ReturnType<typeof setTimeout> | undefined;
+    protected static _shouldReconnect: boolean = true;
+
+    protected static get baseUrl(): string {
+        const apiHost = AppConfig.CORE_SOCKET_HOST as string;
+        return apiHost.replace(/^https?:\/\//, (protocol) => protocol === "https://" ? "wss://" : "ws://");
+    }
+
+    static get instance(): WebSocket | undefined {
+        return this._instance;
+    }
+
+    static get isConnected(): boolean {
+        return !!this._instance && this._instance.readyState === WebSocket.OPEN;
+    }
+
+    static connect(path?: string): WebSocket {
+        if (this.isConnected) return this._instance!;
+
+        const url = this.buildUrl(path);
+        const socket = new WebSocket(url);
+
+        this._instance = socket;
+        this._shouldReconnect = true;
+        this._reconnectAttempts = 0;
+
+        socket.onopen = () => {
+            this._reconnectAttempts = 0;
+            this.dispatch("open", undefined);
+        };
+
+        socket.onmessage = (event: MessageEvent) => {
+            let payload: any = event.data;
+            try {
+                payload = JSON.parse(event.data);
+            } catch {
+            }
+            this.dispatch("message", payload);
+        };
+
+        socket.onerror = (event: Event) => {
+            this.dispatch("error", event);
+        };
+
+        socket.onclose = (event: CloseEvent) => {
+            this._instance = undefined;
+            this.dispatch("close", event);
+            this.scheduleReconnect();
+        };
+
+        return socket;
+    }
+
+    static disconnect(): void {
+        this._shouldReconnect = false;
+        if (this._reconnectTimeout) clearTimeout(this._reconnectTimeout);
+        if (this._instance) this._instance.close();
+        this._instance = undefined;
+    }
+
+    static send<T = any>(data: T | string): void {
+        if (!this.isConnected) return;
+        const payload = typeof data === "string" ? data : JSON.stringify(data);
+        this._instance!.send(payload);
+    }
+
+    static on(event: SocketEvent, handler: SocketEventHandler): () => void {
+        const listeners = this._listeners.get(event) ?? new Set();
+        listeners.add(handler);
+        this._listeners.set(event, listeners);
+        return () => this.off(event, handler);
+    }
+
+    static off(event: SocketEvent, handler: SocketEventHandler): void {
+        this._listeners.get(event)?.delete(handler);
+    }
+
+    protected static dispatch(event: SocketEvent, payload: any): void {
+        this._listeners.get(event)?.forEach((handler) => handler(payload));
+    }
+
+    protected static scheduleReconnect(): void {
+        if (!this._shouldReconnect) return;
+
+        const attempts = Math.min(this._reconnectAttempts, 5);
+        const delay = Math.min(1000 * (2 ** attempts), 30000);
+
+        this._reconnectTimeout = setTimeout(() => {
+            this._reconnectAttempts++;
+            if (!this.isConnected) this.connect();
+        }, delay);
+    }
+
+    protected static buildUrl(path?: string): string {
+        const token = AuthUserService.getToken();
+        const device = AuthUserService.getDevice();
+        const apiKey = AuthUserService.getApiKey();
+        const organization = AuthUserService.getCurrentOrganization();
+
+        const params: Record<string, string> = {};
+        if (token) params["token"] = token;
+        if (device) params["device"] = device;
+        if (apiKey) params["apiKey"] = apiKey;
+        if (organization) params["organizationId"] = organization.id;
+
+        const query = new URLSearchParams(params).toString();
+        const base = `${this.baseUrl}${path ?? ""}`;
+
+        return query ? `${base}${base.includes("?") ? "&" : "?"}${query}` : base;
+    }
+
+}