@communecter/cocolight-api-client 1.0.17 → 1.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.17",
+    "version": "1.0.18",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",

package/src/ApiClient.js

@@ -12,6 +12,7 @@ import pino from "pino";
 import MongoID from "./EJSONType.js";
 import endpointsJson from "./endpoints.module.js";
 import { ApiClientError, ApiResponseError, ApiValidationError, CircuitBreakerError } from "./error.js";
+import { MultiServerTokenStorageStrategy } from "./utils/MultiServerTokenStorageStrategy.js";
 import { MemoryStorageStrategy } from "./utils/TokenStorage.js";
 
 
@@ -150,6 +151,10 @@ export default class ApiClient extends EventEmitter {
     this._accessToken = null;
     this._refreshToken = null;
 
+    if (tokenStorageStrategy instanceof MultiServerTokenStorageStrategy) {
+      tokenStorageStrategy.use(this._baseURL);
+    }
+    
     this._tokenStorage = tokenStorageStrategy || new MemoryStorageStrategy();
 
     if (

package/src/api/User.js

@@ -491,6 +491,7 @@ export class User {
     this.#initialDraftData = JSON.parse(JSON.stringify(this.#draftData));
   }
 
+  // TODO: ne fonctionne pas
   hasChanges() {
     return JSON.stringify(this.#draftData) !== JSON.stringify(this.#initialDraftData);
   }

package/src/index.js

@@ -1,8 +1,10 @@
 import Api from "./Api.js";
 import ApiClient from "./ApiClient.js";
 import * as error from "./error.js";
+import { createDefaultMultiServerTokenStorageStrategy } from "./utils/createDefaultMultiServerTokenStorageStrategy.js";
 import { createDefaultTokenStorageStrategy } from "./utils/createDefaultTokenStorageStrategy.js";
+import { MultiServerTokenStorageStrategy } from "./utils/MultiServerTokenStorageStrategy.js";
 import OfflineClientManager from "./utils/OfflineClientManager.js";
 import { TokenStorageStrategy } from "./utils/TokenStorage.js";
 
-export default { ApiClient, Api, error, tokenStorageStrategy: { createDefaultTokenStorageStrategy, TokenStorageStrategy }, OfflineClientManager };
+export default { ApiClient, Api, error, tokenStorageStrategy: { createDefaultTokenStorageStrategy, TokenStorageStrategy, createDefaultMultiServerTokenStorageStrategy, MultiServerTokenStorageStrategy }, OfflineClientManager };

package/src/utils/MultiServerFileStorageStrategy.node.js

@@ -0,0 +1,65 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+import { MultiServerTokenStorageStrategy } from "./MultiServerTokenStorageStrategy.js";
+
+export class MultiServerFileStorageStrategy extends MultiServerTokenStorageStrategy {
+  constructor(filename = "tokens.json", dir = path.join(os.homedir(), ".config", "cocolight")) {
+    super();
+    this.filePath = path.join(dir, filename);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  }
+
+  _readFile() {
+    if (!fs.existsSync(this.filePath)) return {};
+    try {
+      return JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+
+  _writeFile(data) {
+    fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf8");
+  }
+
+  getAccessToken() {
+    this._ensureContext();
+    return this._readFile()[this._currentBaseURL]?.accessToken || null;
+  }
+
+  setAccessToken(token) {
+    this._ensureContext();
+    const all = this._readFile();
+    all[this._currentBaseURL] = { ...(all[this._currentBaseURL] || {}), accessToken: token };
+    this._writeFile(all);
+  }
+
+  getRefreshToken() {
+    this._ensureContext();
+    return this._readFile()[this._currentBaseURL]?.refreshToken || null;
+  }
+
+  setRefreshToken(token) {
+    this._ensureContext();
+    const all = this._readFile();
+    all[this._currentBaseURL] = { ...(all[this._currentBaseURL] || {}), refreshToken: token };
+    this._writeFile(all);
+  }
+
+  clear() {
+    this._ensureContext();
+    const all = this._readFile();
+    delete all[this._currentBaseURL];
+    this._writeFile(all);
+  }
+
+  getServers() {
+    return Object.keys(this._readFile());
+  }
+
+  exportAll() {
+    return this._readFile();
+  }
+}

package/src/utils/MultiServerTokenStorageStrategy.js

@@ -0,0 +1,131 @@
+// MultiServerTokenStorageStrategy.js
+import { TokenStorageStrategy } from "./TokenStorage.js";
+
+export class MultiServerTokenStorageStrategy extends TokenStorageStrategy {
+  constructor() {
+    super();
+    this._currentBaseURL = null;
+  }
+
+  use(baseURL) {
+    if (!baseURL) throw new Error("baseURL est requis");
+    this._currentBaseURL = baseURL.replace(/\/+$/, "");
+  }
+
+  _ensureContext() {
+    if (!this._currentBaseURL) throw new Error("baseURL non défini. Appelez use(baseURL)");
+  }
+
+  getServers() {
+    throw new Error("getServers() doit être implémenté");
+  }
+
+  exportAll() {
+    throw new Error("exportAll() doit être implémenté");
+  }
+}
+
+// Mémoire
+export class MultiServerMemoryStorageStrategy extends MultiServerTokenStorageStrategy {
+  constructor() {
+    super();
+    this._storage = new Map();
+  }
+  
+  getAccessToken() {
+    this._ensureContext();
+    return this._storage.get(this._currentBaseURL)?.accessToken || null;
+  }
+  
+  setAccessToken(token) {
+    this._ensureContext();
+    const current = this._storage.get(this._currentBaseURL) || {};
+    this._storage.set(this._currentBaseURL, { ...current, accessToken: token });
+  }
+  
+  getRefreshToken() {
+    this._ensureContext();
+    return this._storage.get(this._currentBaseURL)?.refreshToken || null;
+  }
+  
+  setRefreshToken(token) {
+    this._ensureContext();
+    const current = this._storage.get(this._currentBaseURL) || {};
+    this._storage.set(this._currentBaseURL, { ...current, refreshToken: token });
+  }
+  
+  clear() {
+    this._ensureContext();
+    this._storage.delete(this._currentBaseURL);
+  }
+  
+  getServers() {
+    return [...this._storage.keys()];
+  }
+  
+  exportAll() {
+    return Object.fromEntries(this._storage.entries());
+  }
+}
+  
+// Navigateur (localStorage)
+export class MultiServerLocalStorageStrategy extends MultiServerTokenStorageStrategy {
+  constructor(prefix = "cocolight") {
+    super();
+    this.prefix = prefix;
+  }
+  
+  _key(baseURL) {
+    return `${this.prefix}_tokens_${baseURL}`;
+  }
+  
+  _getData() {
+    this._ensureContext();
+    const raw = localStorage.getItem(this._key(this._currentBaseURL));
+    return raw ? JSON.parse(raw) : {};
+  }
+  
+  _setData(data) {
+    localStorage.setItem(this._key(this._currentBaseURL), JSON.stringify(data));
+  }
+  
+  getAccessToken() {
+    return this._getData().accessToken || null;
+  }
+  
+  setAccessToken(token) {
+    const data = this._getData();
+    data.accessToken = token;
+    this._setData(data);
+  }
+  
+  getRefreshToken() {
+    return this._getData().refreshToken || null;
+  }
+  
+  setRefreshToken(token) {
+    const data = this._getData();
+    data.refreshToken = token;
+    this._setData(data);
+  }
+  
+  clear() {
+    localStorage.removeItem(this._key(this._currentBaseURL));
+  }
+  
+  getServers() {
+    const keys = Object.keys(localStorage);
+    return keys
+      .filter(k => k.startsWith(`${this.prefix}_tokens_`))
+      .map(k => k.replace(`${this.prefix}_tokens_`, ""));
+  }
+  
+  exportAll() {
+    const result = {};
+    for (const baseURL of this.getServers()) {
+      const raw = localStorage.getItem(this._key(baseURL));
+      if (raw) result[baseURL] = JSON.parse(raw);
+    }
+    return result;
+  }
+}

package/src/utils/createDefaultMultiServerTokenStorageStrategy.js

@@ -0,0 +1,45 @@
+import {
+  MultiServerMemoryStorageStrategy,
+  MultiServerLocalStorageStrategy,
+} from "./MultiServerTokenStorageStrategy.js";
+  
+/**
+   * Crée une stratégie de stockage de tokens multi-serveurs adaptée à l’environnement.
+   *
+   * @param {string} [strategyType="auto"] - Type de stockage souhaité :
+   *   - "memory" : en mémoire (non persistant)
+   *   - "localStorage" : navigateur uniquement
+   *   - "file" : Node.js uniquement
+   *   - "auto" : choisit automatiquement selon l’environnement
+   * @returns {Promise<MultiServerTokenStorageStrategy>}
+   */
+export async function createDefaultMultiServerTokenStorageStrategy(strategyType = "auto") {
+  if (strategyType === "memory") {
+    return new MultiServerMemoryStorageStrategy();
+  }
+  
+  if (strategyType === "localStorage") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return new MultiServerLocalStorageStrategy();
+    } else {
+      throw new Error("localStorage n’est pas disponible dans cet environnement.");
+    }
+  }
+  
+  if (strategyType === "file") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      throw new Error("Le stockage fichier n’est pas disponible côté navigateur.");
+    }
+    const { MultiServerFileStorageStrategy } = await import("./MultiServerFileStorageStrategy.node.js");
+    return new MultiServerFileStorageStrategy();
+  }
+  
+  // stratégie "auto"
+  if (typeof window !== "undefined" && window.localStorage) {
+    return new MultiServerLocalStorageStrategy();
+  } else {
+    const { MultiServerFileStorageStrategy } = await import("./MultiServerTokenStorageStrategy.js");
+    return new MultiServerFileStorageStrategy();
+  }
+}
+  

package/src/utils/createDefaultTokenStorageStrategy.js

@@ -1,7 +1,5 @@
 import { LocalStorageStrategy, MemoryStorageStrategy } from "./TokenStorage.js";
 
-// src/utils/createDefaultTokenStorageStrategy.js
-
 /**
  * Crée une stratégie de stockage de jetons par défaut en fonction de l'option fournie.
  *