@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/utils/{OfflineClientManager.js → OfflineClientManager.ts}

@@ -1,31 +1,70 @@
-// OfflineClientManager.js
+// OfflineClientManager.ts
 import ApiClient from "../ApiClient.js";
 import { createDefaultOfflineStrategy } from "./createDefaultOfflineStrategy.js";
+import { OfflineQueueStorageStrategy } from "./OfflineQueueStorageStrategy.js";
+
+type OfflineQueueStorageStrategyAction = import("./OfflineQueueStorageStrategy.js").OfflineQueueStorageStrategy<OfflineAction>;
+
+/**
+ * Métadonnées nécessaires pour rejouer une action offline sur le bon serveur.
+ */
+interface OfflineActionMeta {
+  baseURL: string;
+  accessToken?: string | null;
+  refreshToken?: string | null;
+  timestamp: number; // Epoch ms de l'enfilement.
+}
+
+/**
+ * Options passées à l'appel de l'endpoint lors du replay.
+ */
+interface OfflineActionOptions {
+  transformResponseData?: boolean | ((...args: any[]) => any);
+  validateResponseSchema?: boolean;
+}
+
+/**
+ * Élément de la file d'attente offline.
+ */
+export interface OfflineAction {
+  constant: string; // Nom de l'endpoint à appeler.
+  data: unknown; // Payload d'entrée (forme dépendante de l'endpoint).
+  options?: OfflineActionOptions;
+  meta: OfflineActionMeta;
+}
+
+/**
+ * Options d'attache du gestionnaire offline.
+ */
+interface AttachOptions {
+  offlineStorageStrategy?: "auto" | "memory" | "localStorage" | "file";
+  disableOfflineMonitoring?: boolean;
+  interval?: number; // Intervalle de ping réseau (ms), relayé à startOfflineMonitoring.
+}
 
 export class OfflineClientManager {
-  /**
-   * Initialise un gestionnaire de mode offline pour un ApiClient donné.
-   * 
-   * @param {ApiClient} apiClient - Instance du client principal.
-   */
-  constructor(apiClient) {
-    if(!apiClient || !(apiClient instanceof ApiClient)) {
+  private _clients: Map<string, any>;
+  private _client: any;
+  private _offlineMode: boolean | undefined;
+  private _pingInterval: ReturnType<typeof setInterval> | undefined;
+  private _offlineQueueStorage: OfflineQueueStorageStrategyAction | undefined;
+  private _offlineQueue: OfflineAction[];
+  private _monitoringStarted: boolean | undefined;
+
+  constructor(apiClient: any) {
+    if (!apiClient || !(apiClient instanceof ApiClient)) {
       throw new Error("[OfflineClientManager] apiClient doit être une instance de ApiClient");
     }
     this._clients = new Map();
     this._client = apiClient;
+    this._offlineMode = undefined;
+    this._pingInterval = undefined;
+    this._offlineQueueStorage = undefined;
+    this._offlineQueue = [];
+    this._monitoringStarted = undefined;
   }
 
-  /**
-   * Attache le gestionnaire offline à une instance ApiClient.
-   * Configure la file d'attente offline, le monitoring réseau, et le ping serveur.
-   *
-   * @param {ApiClient} apiClient - L'instance du client à enrichir.
-   * @param {Object} options
-   * @param {Object} [options.offlineStorageStrategy] - Stratégie de stockage offline.
-   * @param {boolean} [options.disableOfflineMonitoring] - Si true, désactive le monitoring réseau.
-   */
-  static async attachTo(apiClient, options = {}) {
+  static async attachTo(apiClient: any, options: AttachOptions = {}): Promise<any> {
     apiClient._offlineClientManager = new OfflineClientManager(apiClient);
     const strategy = await createDefaultOfflineStrategy(options?.offlineStorageStrategy || "auto");
     await apiClient._offlineClientManager._initOfflineQueue(strategy);
@@ -34,14 +73,7 @@ export class OfflineClientManager {
     }
   }
 
-  /**
-   * Retourne un ApiClient configuré avec les bons tokens/baseURL pour rejouer une action offline.
-   * Met en cache l'instance pour éviter les recréations.
-   *
-   * @param {Object} meta - Métadonnées contenant baseURL et tokens.
-   * @returns {Promise<ApiClient>}
-   */
-  async getClient(meta) {
+  async getClient(meta: OfflineActionMeta): Promise<any> {
     const key = `${meta.baseURL}|${meta.accessToken}`;
     if (this._clients.has(key)) return this._clients.get(key);
 
@@ -56,16 +88,9 @@ export class OfflineClientManager {
     return client;
   }
 
-  /**
-   * Rejoue une action unique depuis la file offline.
-   * 
-   * @param {Object} action - Objet contenant constant, data, options et meta.
-   * @returns {Promise<any>}
-   */
-  async replayAction(action) {
+  async replayAction(action: OfflineAction): Promise<any> {
     const client = await this.getClient(action.meta);
     try {
-      
       const result = await client.callEndpoint(
         action.constant,
         action.data,
@@ -75,20 +100,12 @@ export class OfflineClientManager {
       this._client._logger.info(`[OfflineReplay] Succès ${action.constant} sur ${action.meta.baseURL}`);
       return result;
     } catch (err) {
-      this._client._logger.error(`[OfflineReplay] Échec ${action.constant}`, err.message);
+      this._client._logger.error(`[OfflineReplay] Échec ${action.constant}`, (err as Error).message);
       throw err;
     }
   }
 
-  /**
-   * Démarre la surveillance de l'état réseau.
-   * Basé sur navigator.onLine + un ping serveur régulier.
-   *
-   * @param {Object} [options]
-   * @param {number} [options.interval=30000] - Intervalle de vérification en ms.
-   * @param {boolean} [options.disableOfflineMonitoring=false] - Pour désactiver.
-   */
-  startOfflineMonitoring({ interval = 30000, disableOfflineMonitoring = false } = {}) {
+  startOfflineMonitoring({ interval = 30000, disableOfflineMonitoring = false }: Pick<AttachOptions, "interval" | "disableOfflineMonitoring"> = {}) {
     if (disableOfflineMonitoring || this._monitoringStarted) return;
   
     this._monitoringStarted = true;
@@ -102,27 +119,20 @@ export class OfflineClientManager {
     this._pingInterval = setInterval(async () => {
       const wasOffline = this._offlineMode;
       try {
-        await this._client._client.head("/api/cocolight/infoserver", { timeout: 5000 }); // ✅ utilise la fonction injectée
+        await this._client._client.head("/api/cocolight/infoserver", { timeout: 5000 });
         if (wasOffline) this.setOfflineMode(false);
        
-      // eslint-disable-next-line no-unused-vars
-      } catch (err) {
+      } catch {
         this._client._logger.error("[OfflineMonitor] ping() échoué → passage en offline");
         this.setOfflineMode(true);
       }
     }, interval);
   }
 
-  /**
-   * Change l'état offline et émet un événement si l'état change.
-   * Déclenche la relecture de la file si on revient online.
-   *
-   * @param {boolean} isOffline
-   */
-  setOfflineMode(isOffline) {
+  setOfflineMode(isOffline: boolean) {
     if (this._offlineMode === isOffline) return;
     this._offlineMode = isOffline;
-    if (typeof this._emit === "function") {
+    if (typeof this._client.emit === "function") {
       this._client.emit("offlineModeChanged", isOffline);
     }
     this._client._logger.info(`[ApiClient] Mode offline : ${isOffline} (set depuis monitoring)`);
@@ -132,33 +142,23 @@ export class OfflineClientManager {
     }
   }
 
-  /**
-   * Indique si le client est actuellement en mode offline.
-   *
-   * @returns {boolean}
-   */
-  isOffline() {
+  isOffline(): boolean {
     return !!this._offlineMode;
   }
 
-  /**
-   * Met une action API dans la file offline.
-   *
-   * @param {Object} params
-   * @param {string} params.constant - Le nom de l'endpoint.
-   * @param {Object} params.data - Données à envoyer.
-   * @param {Object} [params.options] - Options de transformation/validation.
-   */
-  async _enqueueOfflineAction({ constant, data, options = {} }) {
+  async _enqueueOfflineAction({ constant, data, options = {} }: { constant: string; data: unknown; options?: OfflineActionOptions }): Promise<any> {
+    if (!this._offlineQueueStorage) {
+      throw new Error("[OfflineClientManager] _offlineQueueStorage non initialisé");
+    }
     const hasToken = this._client.getToken() || this._client.getRefreshToken();
-    const endpoint = this._client._endpoints.find(e => e.constant === constant);
+    const endpoint = this._client._endpoints.find((e: any) => e.constant === constant);
     const authPolicy = endpoint?.authPolicy || (endpoint?.auth === "none" ? "none" : "required");
     if (authPolicy === "required" && !hasToken) {
       this._client._logger.warn(`[Offline] Action ignorée : token requis mais absent (${constant})`);
       return;
     }
 
-    const action = {
+    const action: OfflineAction = {
       constant,
       data,
       options,
@@ -175,17 +175,16 @@ export class OfflineClientManager {
     this._client._logger.info(`[Offline] Action mise en file : ${constant}`);
   }
 
-  /**
-   * Rejoue toutes les actions offline.
-   * Ré-insère celles qui échouent dans la file.
-   */
-  async _replayOfflineQueue() {
+  async _replayOfflineQueue(): Promise<any> {
+    if (!this._offlineQueueStorage) {
+      throw new Error("[OfflineClientManager] _offlineQueueStorage non initialisé");
+    }
     const queueCopy = [...this._offlineQueue];
     this._offlineQueue = [];
     await this._offlineQueueStorage.saveQueue([]);
 
     for (const action of queueCopy) {
-      const endpoint = this._client._endpoints.find(e => e.constant === action.constant);
+      const endpoint = this._client._endpoints.find((e: any) => e.constant === action.constant);
       const authPolicy = endpoint?.authPolicy || (endpoint?.auth === "none" ? "none" : "required");
       const hasToken = action.meta.accessToken || action.meta.refreshToken;
 
@@ -196,9 +195,8 @@ export class OfflineClientManager {
 
       try {
         await this.replayAction(action);
-       
       } catch (e) {
-        this._client._logger.error("[Offline] Relecture échouée :", e.message);
+        this._client._logger.error("[Offline] Relecture échouée :", (e as Error).message);
         this._offlineQueue.push(action); // requeue si erreur
       }
     }
@@ -206,12 +204,10 @@ export class OfflineClientManager {
     await this._offlineQueueStorage.saveQueue(this._offlineQueue);
   }
 
-  /**
-   * Initialise la stratégie de stockage offline et charge la file d’attente.
-   *
-   * @param {OfflineQueueStorageStrategy} storageStrategy
-   */
-  async _initOfflineQueue(storageStrategy) {
+  async _initOfflineQueue(storageStrategy: OfflineQueueStorageStrategyAction): Promise<any> {
+    if(!storageStrategy || !(storageStrategy instanceof OfflineQueueStorageStrategy)) {
+      throw new Error("[OfflineClientManager] storageStrategy doit être une instance de OfflineQueueStorageStrategy");
+    }
     this._offlineQueueStorage = storageStrategy;
     this._offlineQueue = await storageStrategy.loadQueue();
   }

package/src/utils/OfflineQueueStorageStrategy.ts

@@ -0,0 +1,47 @@
+export abstract class OfflineQueueStorageStrategy<T = any> {
+  abstract loadQueue(): Promise<T[]>;
+  abstract saveQueue(queue: T[]): Promise<void>;
+}
+
+export class MemoryOfflineStorage<T = any> extends OfflineQueueStorageStrategy<T> {
+  private _queue: T[] = [];
+
+  constructor() {
+    super();
+  }
+
+  async loadQueue(): Promise<T[]> {
+    return this._queue;
+  }
+
+  async saveQueue(queue: T[]): Promise<void> {
+    this._queue = [...queue];
+  }
+}
+
+export class LocalStorageOfflineStorage<T = any> extends OfflineQueueStorageStrategy<T> {
+  public readonly key: string;
+
+  constructor(key: string = "cocolight-api-offline-queue") {
+    super();
+    this.key = key;
+  }
+
+  async loadQueue(): Promise<T[]> {
+    try {
+      const raw = localStorage.getItem(this.key);
+      const parsed: T[] | null = raw ? JSON.parse(raw) : null;
+      return parsed ?? [];
+    } catch {
+      return [];
+    }
+  }
+
+  async saveQueue(queue: T[]): Promise<void> {
+    try {
+      localStorage.setItem(this.key, JSON.stringify(queue));
+    } catch (e) {
+      console.warn("[Offline] Échec du stockage localStorage", e);
+    }
+  }
+}

package/src/utils/TokenStorage.ts

@@ -0,0 +1,77 @@
+export abstract class TokenStorageStrategy {
+  abstract getAccessToken(): string | null;
+  abstract setAccessToken(token: string | null): void;
+  abstract getRefreshToken(): string | null;
+  abstract setRefreshToken(token: string | null): void;
+  abstract clear(): void;
+}
+
+export class MemoryStorageStrategy extends TokenStorageStrategy {
+  private _accessToken: string | null = null;
+  private _refreshToken: string | null = null;
+
+  constructor() {
+    super();
+  }
+
+  getAccessToken(): string | null {
+    return this._accessToken;
+  }
+
+  setAccessToken(token: string | null): void {
+    this._accessToken = token;
+  }
+
+  getRefreshToken(): string | null {
+    return this._refreshToken;
+  }
+
+  setRefreshToken(token: string | null): void {
+    this._refreshToken = token;
+  }
+
+  clear(): void {
+    this._accessToken = null;
+    this._refreshToken = null;
+  }
+}
+
+export class LocalStorageStrategy extends TokenStorageStrategy {
+  public readonly prefix: string;
+
+  constructor(prefix: string = "cocolight") {
+    super();
+    this.prefix = prefix;
+  }
+
+  getAccessToken(): string | null {
+    return typeof localStorage !== "undefined"
+      ? localStorage.getItem(`${this.prefix}_accessToken`)
+      : null;
+  }
+
+  setAccessToken(token: string | null): void {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(`${this.prefix}_accessToken`, token ?? "");
+    }
+  }
+
+  getRefreshToken(): string | null {
+    return typeof localStorage !== "undefined"
+      ? localStorage.getItem(`${this.prefix}_refreshToken`)
+      : null;
+  }
+
+  setRefreshToken(token: string | null): void {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(`${this.prefix}_refreshToken`, token ?? "");
+    }
+  }
+
+  clear(): void {
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(`${this.prefix}_accessToken`);
+      localStorage.removeItem(`${this.prefix}_refreshToken`);
+    }
+  }
+}

package/src/utils/compat.ts

@@ -0,0 +1,12 @@
+// utils/compat.ts - Compatibility layer for default imports
+const _def = <T>(m: T & { default?: any }): any => (m && m.default) ? m.default : m;
+
+import * as AjvNS from "ajv";
+import * as addFormatsNS from "ajv-formats";
+import * as EJSONNS from "ejson";
+import * as pinoNS from "pino";
+
+export const Ajv = _def(AjvNS);             // constructible
+export const addFormats = _def(addFormatsNS); // callable
+export const pino = _def(pinoNS);           // callable
+export const EJSON = _def(EJSONNS);         // default safe

package/src/utils/createDefaultMultiServerTokenStorageStrategy.ts

@@ -0,0 +1,35 @@
+import {
+  MultiServerMemoryStorageStrategy,
+  MultiServerLocalStorageStrategy,
+  type MultiServerTokenStorageStrategy,
+} from "./MultiServerTokenStorageStrategy.js";
+
+export async function createDefaultMultiServerTokenStorageStrategy(
+  strategyType: "memory" | "localStorage" | "file" | "auto" = "auto"
+): Promise<MultiServerTokenStorageStrategy> {
+  if (strategyType === "memory") {
+    return new MultiServerMemoryStorageStrategy();
+  }
+
+  if (strategyType === "localStorage") {
+    if (typeof window !== "undefined" && typeof window.localStorage !== "undefined") {
+      return new MultiServerLocalStorageStrategy();
+    }
+    throw new Error("localStorage n'est pas disponible dans cet environnement.");
+  }
+
+  if (strategyType === "file") {
+    if (typeof window !== "undefined" && typeof window.localStorage !== "undefined") {
+      throw new Error("Le stockage fichier n'est pas disponible côté navigateur.");
+    }
+    const { MultiServerFileStorageStrategy } = await import("./MultiServerFileStorageStrategy.node.js");
+    return new MultiServerFileStorageStrategy();
+  }
+
+  // auto
+  if (typeof window !== "undefined" && typeof window.localStorage !== "undefined") {
+    return new MultiServerLocalStorageStrategy();
+  }
+  const { MultiServerFileStorageStrategy } = await import("./MultiServerFileStorageStrategy.node.js");
+  return new MultiServerFileStorageStrategy();
+}

package/src/utils/{createDefaultOfflineStrategy.js → createDefaultOfflineStrategy.ts}

@@ -1,6 +1,8 @@
-import { LocalStorageOfflineStorage, MemoryOfflineStorage } from "./OfflineQueueStorageStrategy.js";
+import { LocalStorageOfflineStorage, MemoryOfflineStorage, type OfflineQueueStorageStrategy } from "./OfflineQueueStorageStrategy.js";
 
-export async function createDefaultOfflineStrategy(offlineStorageStrategy = "auto") {
+export async function createDefaultOfflineStrategy<T = any>(
+  offlineStorageStrategy: "auto" | "memory" | "localStorage" | "file" = "auto"
+): Promise<OfflineQueueStorageStrategy<T>> {
   if (offlineStorageStrategy === "memory") {
     return new MemoryOfflineStorage();
   }
@@ -26,4 +28,7 @@ export async function createDefaultOfflineStrategy(offlineStorageStrategy = "aut
       return new FileOfflineStorage();
     }
   }
-}
+  
+  // Handle unexpected strategy values
+  throw new Error(`Unsupported offline storage strategy: ${offlineStorageStrategy}`);
+}

package/src/utils/createDefaultTokenStorageStrategy.ts

@@ -0,0 +1,33 @@
+import { LocalStorageStrategy, MemoryStorageStrategy } from "./TokenStorage.js";
+
+import type { TokenStorageStrategy } from "./TokenStorage.js";
+
+export async function createDefaultTokenStorageStrategy(
+  tokenStorageStrategy: "memory" | "localStorage" | "file" | "auto" = "auto"
+): Promise<TokenStorageStrategy> {
+  if (tokenStorageStrategy === "memory") {
+    return new MemoryStorageStrategy();
+  }
+
+  if (tokenStorageStrategy === "localStorage") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return new LocalStorageStrategy();
+    }
+    throw new Error("localStorage is not available in this environment.");
+  }
+
+  if (tokenStorageStrategy === "file") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      throw new Error("file storage is not available in this environment.");
+    }
+    const { FileStorageStrategy } = await import("./FileStorageStrategy.node.js");
+    return new FileStorageStrategy();
+  }
+
+  // 'auto'
+  if (typeof window !== "undefined" && window.localStorage) {
+    return new LocalStorageStrategy();
+  }
+  const { FileStorageStrategy } = await import("./FileStorageStrategy.node.js");
+  return new FileStorageStrategy();
+}