@communecter/cocolight-api-client 1.0.155 → 1.0.157

package/src/utils/MultiServerTokenStorageStrategy.ts

@@ -1,139 +0,0 @@
-import { TokenStorageStrategy } from "./TokenStorage.js";
-
-export abstract class MultiServerTokenStorageStrategy extends TokenStorageStrategy {
-  protected _currentBaseURL: string | null = null;
-
-  constructor() {
-    super();
-  }
-
-  use(baseURL: string): void {
-    if (!baseURL) throw new Error("baseURL est requis");
-    this._currentBaseURL = baseURL.replace(/\/+$/, "");
-  }
-
-  protected _ensureContext(): void {
-    if (!this._currentBaseURL) throw new Error("baseURL non défini. Appelez use(baseURL)");
-  }
-
-  protected _requireBaseURL(): string {
-    this._ensureContext();
-    return this._currentBaseURL!;
-  }
-
-  abstract getServers(): string[];
-  abstract exportAll(): Record<string, { accessToken?: string | null; refreshToken?: string | null }>;
-
-}
-
-export class MultiServerMemoryStorageStrategy extends MultiServerTokenStorageStrategy {
-  private _storage = new Map<string, { accessToken?: string | null; refreshToken?: string | null }>();
-
-  constructor() {
-    super();
-  }
-
-  getAccessToken(): string | null {
-    const base = this._requireBaseURL();
-    return this._storage.get(base)?.accessToken ?? null;
-  }
-
-  setAccessToken(token: string | null): void {
-    const base = this._requireBaseURL();
-    const current = this._storage.get(base) || {};
-    this._storage.set(base, { ...current, accessToken: token });
-  }
-
-  getRefreshToken(): string | null {
-    const base = this._requireBaseURL();
-    return this._storage.get(base)?.refreshToken ?? null;
-  }
-
-  setRefreshToken(token: string | null): void {
-    const base = this._requireBaseURL();
-    const current = this._storage.get(base) || {};
-    this._storage.set(base, { ...current, refreshToken: token });
-  }
-
-  clear(): void {
-    const base = this._requireBaseURL();
-    this._storage.delete(base);
-  }
-
-  getServers(): string[] {
-    return Array.from(this._storage.keys());
-  }
-
-  exportAll(): Record<string, { accessToken?: string | null; refreshToken?: string | null }> {
-    return Object.fromEntries(this._storage.entries());
-  }
-}
-
-export class MultiServerLocalStorageStrategy extends MultiServerTokenStorageStrategy {
-  public readonly prefix: string;
-
-  constructor(prefix: string = "cocolight") {
-    super();
-    this.prefix = prefix;
-  }
-
-  private _key(baseURL: string): string {
-    return `${this.prefix}_tokens_${baseURL}`;
-  }
-
-  private _getData(): any {
-    this._ensureContext();
-    if (typeof localStorage === "undefined") return {};
-    const raw = localStorage.getItem(this._key(this._currentBaseURL!));
-    return raw ? JSON.parse(raw) : {};
-  }
-
-  private _setData(data: any): void {
-    if (typeof localStorage === "undefined") return;
-    localStorage.setItem(this._key(this._currentBaseURL!), JSON.stringify(data));
-  }
-
-  getAccessToken(): string | null {
-    return this._getData().accessToken ?? null;
-  }
-
-  setAccessToken(token: string | null): void {
-    const data = this._getData();
-    data.accessToken = token;
-    this._setData(data);
-  }
-
-  getRefreshToken(): string | null {
-    return this._getData().refreshToken ?? null;
-  }
-
-  setRefreshToken(token: string | null): void {
-    const data = this._getData();
-    data.refreshToken = token;
-    this._setData(data);
-  }
-
-  clear(): void {
-    if (typeof localStorage === "undefined") return;
-    localStorage.removeItem(this._key(this._currentBaseURL!));
-  }
-
-  getServers(): string[] {
-    if (typeof localStorage === "undefined") return [];
-    const keys = Object.keys(localStorage);
-    return keys
-      .filter(k => k.startsWith(`${this.prefix}_tokens_`))
-      .map(k => k.replace(`${this.prefix}_tokens_`, ""));
-  }
-
-  exportAll(): Record<string, { accessToken?: string | null; refreshToken?: string | null }> {
-    const result: Record<string, { accessToken?: string | null; refreshToken?: string | null }> = {};
-
-    for (const baseURL of this.getServers()) {
-      const key = this._key(baseURL);
-      const raw = typeof localStorage !== "undefined" ? localStorage.getItem(key) : null;
-      if (raw) result[baseURL] = JSON.parse(raw);
-    }
-    return result;
-  }
-}

package/src/utils/OfflineClientManager.ts

@@ -1,216 +0,0 @@
-// 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 {
-  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;
-  }
-
-  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);
-    if (!options?.disableOfflineMonitoring) {
-      apiClient._offlineClientManager.startOfflineMonitoring(options);
-    }
-  }
-
-  async getClient(meta: OfflineActionMeta): Promise<any> {
-    const key = `${meta.baseURL}|${meta.accessToken}`;
-    if (this._clients.has(key)) return this._clients.get(key);
-
-    const client = new ApiClient({
-      baseURL: meta.baseURL,
-      accessToken: meta.accessToken,
-      refreshToken: meta.refreshToken,
-      debug: this._client._debug,
-    });
-
-    this._clients.set(key, client);
-    return client;
-  }
-
-  async replayAction(action: OfflineAction): Promise<any> {
-    const client = await this.getClient(action.meta);
-    try {
-      const result = await client.callEndpoint(
-        action.constant,
-        action.data,
-        action.options?.transformResponseData ?? true,
-        action.options?.validateResponseSchema ?? true
-      );
-      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 as Error).message);
-      throw err;
-    }
-  }
-
-  startOfflineMonitoring({ interval = 30000, disableOfflineMonitoring = false }: Pick<AttachOptions, "interval" | "disableOfflineMonitoring"> = {}) {
-    if (disableOfflineMonitoring || this._monitoringStarted) return;
-  
-    this._monitoringStarted = true;
-    this._offlineMode = typeof window !== "undefined" && typeof navigator !== "undefined" && !navigator.onLine;
-  
-    if (typeof window !== "undefined") {
-      window.addEventListener("online", () => this.setOfflineMode(false));
-      window.addEventListener("offline", () => this.setOfflineMode(true));
-    }
-  
-    this._pingInterval = setInterval(async () => {
-      const wasOffline = this._offlineMode;
-      try {
-        await this._client._client.head("/api/cocolight/infoserver", { timeout: 5000 });
-        if (wasOffline) this.setOfflineMode(false);
-       
-      } catch {
-        this._client._logger.error("[OfflineMonitor] ping() échoué → passage en offline");
-        this.setOfflineMode(true);
-      }
-    }, interval);
-  }
-
-  setOfflineMode(isOffline: boolean) {
-    if (this._offlineMode === isOffline) return;
-    this._offlineMode = isOffline;
-    if (typeof this._client.emit === "function") {
-      this._client.emit("offlineModeChanged", isOffline);
-    }
-    this._client._logger.info(`[ApiClient] Mode offline : ${isOffline} (set depuis monitoring)`);
-
-    if (!isOffline && typeof this._replayOfflineQueue === "function") {
-      this._replayOfflineQueue();
-    }
-  }
-
-  isOffline(): boolean {
-    return !!this._offlineMode;
-  }
-
-  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: 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: OfflineAction = {
-      constant,
-      data,
-      options,
-      meta: {
-        baseURL: this._client._baseURL,
-        accessToken: this._client.getToken(),
-        refreshToken: this._client.getRefreshToken(),
-        timestamp: Date.now()
-      }
-    };
-
-    this._offlineQueue.push(action);
-    await this._offlineQueueStorage.saveQueue(this._offlineQueue);
-    this._client._logger.info(`[Offline] Action mise en file : ${constant}`);
-  }
-
-  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: any) => e.constant === action.constant);
-      const authPolicy = endpoint?.authPolicy || (endpoint?.auth === "none" ? "none" : "required");
-      const hasToken = action.meta.accessToken || action.meta.refreshToken;
-
-      if (authPolicy === "required" && !hasToken) {
-        this._client._logger.warn(`[Offline] Rejetée : token requis manquant (${action.constant})`);
-        continue;
-      }
-
-      try {
-        await this.replayAction(action);
-      } catch (e) {
-        this._client._logger.error("[Offline] Relecture échouée :", (e as Error).message);
-        this._offlineQueue.push(action); // requeue si erreur
-      }
-    }
-
-    await this._offlineQueueStorage.saveQueue(this._offlineQueue);
-  }
-
-  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();
-  }
-}
-
-export default OfflineClientManager;

package/src/utils/OfflineQueueStorageStrategy.ts

@@ -1,47 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,12 +0,0 @@
-// 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

@@ -1,35 +0,0 @@
-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.ts

@@ -1,34 +0,0 @@
-import { LocalStorageOfflineStorage, MemoryOfflineStorage, type OfflineQueueStorageStrategy } from "./OfflineQueueStorageStrategy.js";
-
-export async function createDefaultOfflineStrategy<T = any>(
-  offlineStorageStrategy: "auto" | "memory" | "localStorage" | "file" = "auto"
-): Promise<OfflineQueueStorageStrategy<T>> {
-  if (offlineStorageStrategy === "memory") {
-    return new MemoryOfflineStorage();
-  }
-  if (offlineStorageStrategy === "localStorage") {
-    if (typeof window !== "undefined" && window.localStorage) {
-      return new LocalStorageOfflineStorage();
-    } else {
-      throw new Error("localStorage is not available in this environment.");
-    }
-  }
-  if (offlineStorageStrategy === "file") {
-    if (typeof window !== "undefined" && window.localStorage) {
-      throw new Error("file storage is not available in this environment.");
-    }
-    const { FileOfflineStorage } = await import("./FileOfflineStorageStrategy.node.js");
-    return new FileOfflineStorage();
-  }
-  if (offlineStorageStrategy === "auto") {
-    if (typeof window !== "undefined" && window.localStorage) {
-      return new LocalStorageOfflineStorage();
-    } else {
-      const { FileOfflineStorage } = await import("./FileOfflineStorageStrategy.node.js");
-      return new FileOfflineStorage();
-    }
-  }
-  
-  // Handle unexpected strategy values
-  throw new Error(`Unsupported offline storage strategy: ${offlineStorageStrategy}`);
-}

package/src/utils/createDefaultTokenStorageStrategy.ts

@@ -1,33 +0,0 @@
-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();
-}