@communecter/cocolight-api-client 1.0.17 → 1.0.19

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.
  *

package/src/mixin/NewsMixin.js

@@ -1,42 +0,0 @@
-import { ApiResponseError } from "../error.js";
-
-// NewsMixin.js
-export const NewsMixin = {
-  /**
-   * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
-   * Constant : GET_NEWS
-   * @param {Object} data - Les données à envoyer.
-   * @param {number} data.dateLimit - Limite de date timestamp ou 0 (default: 0)
-   * @param {object} data.search - data.search
-   * @param {string} data.search.name - Nom ou terme recherché (default: "")
-   * @param {number} data.indexStep - Nombre de résultats par page (default: 12)
-   * @returns {Promise<Object>} - Les données de réponse.
-   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
-   * @throws {Error} - En cas d'erreur inattendue.
-   */
-  async getNews(data = {}) {
-    data.pathParams = { type: this.getEntityType(), id: this.id };
-    const arrayObjetNews =  await this.endpointApi.getNews(data);
-    if(!Array.isArray(arrayObjetNews)){
-      throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjetNews);
-    }
-    const rawNewsList = arrayObjetNews.map((newsData) =>
-      this.deps.News.fromServerData(newsData, this, { User : this.deps.User, EndpointApi: this.deps.EndpointApi })
-    );
-    return this._createFilteredProxy(rawNewsList);
-  },
-
-  async news(newsData) {
-    try {
-      const news = new this.deps.News(this, newsData, { User: this.deps.User, EndpointApi : this.deps.EndpointApi });
-      if (newsData.id) {
-        await news.get();
-      }
-      return news;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.getEntityType()}.news] Erreur lors de la création d'une instance news :`, error.message);
-      throw error;
-    }
-  }
-};
-