@communecter/cocolight-api-client 1.0.10 → 1.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.10",
+    "version": "1.0.12",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",
@@ -10,8 +10,11 @@
     "main": "./dist/cocolight-api-client.cjs",
     "browser": "./dist/cocolight-api-client.browser.js",
     "exports": {
-        "import": "./dist/cocolight-api-client.mjs.js",
-        "require": "./dist/cocolight-api-client.cjs"
+        ".": {
+            "import": "./dist/cocolight-api-client.mjs.js",
+            "require": "./dist/cocolight-api-client.cjs"
+        },
+        "./mjs": "./dist/cocolight-api-client.mjs.js"
     },
     "type": "module",
     "scripts": {
@@ -33,7 +36,8 @@
         "generate:reponses": "node ./scripts/generate-constant-response-200.js",
         "generate:methodeapi": "node ./scripts/generate-methode-api.js",
         "generate:ajv-standalone": "node ./scripts/generate-validate-function-ajv.js",
-        "generate:entities": "node scripts/generate-entities.js"
+        "generate:entities": "node scripts/generate-entities.js",
+        "generate:all-properties-schema": "node scripts/generate-all-properties-schema.js"
     },
     "keywords": [
         "communecter",

package/src/Api.js

@@ -5,7 +5,7 @@ import { Organization } from "./api/Organization.js";
 import { Project } from "./api/Project.js";
 import { User } from "./api/User.js";
 import { UserApi } from "./api/UserApi.js";
-import { ApiAuthenticationError, ApiClientError } from "./error.js";
+import { ApiAuthenticationError, ApiClientError, ApiError } from "./error.js";
 
 export default class Api {
   /**
@@ -51,8 +51,27 @@ export default class Api {
      */
   static async userApiLogin(userApi, email, password) {
     try {
-      const loggedUser = await userApi.login(email, password);
-      return new Api(loggedUser, userApi.client);
+
+      if (!userApi) {
+        throw new ApiError("userApi is not defined");
+      }
+      if(!userApi.client) {
+        throw new ApiError("userApi.client is not defined");
+      }
+
+      if(userApi.client.isConnected) {
+        // Si l'utilisateur est déjà connecté, on le récupère
+        // et on ne fait pas de login
+        const loggedUser = await userApi.meIsconnected();
+        return new Api(loggedUser, userApi.client);
+      } else {
+        if (!email || !password) {
+          throw new ApiError("email and password are required");
+        }
+        const loggedUser = await userApi.login(email, password);
+        return new Api(loggedUser, userApi.client);
+      }
+
     } catch (error) {
       if(error instanceof ApiClientError) {
         if(error?.details?.error) {
@@ -170,5 +189,11 @@ export default class Api {
   get endpointApi() {
     return new EndpointApi(this._client);
   }
+
+  logout () {
+    this.loggedUser = null;
+    this._client.resetSession();
+    this._client._logger.info("UserApi: User logged out");
+  }
   
 }

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 { MemoryStorageStrategy } from "./utils/TokenStorage.js";
 
 EJSON.addType("oid", value => {
   return new MongoID.ObjectID(value);
@@ -31,6 +32,7 @@ export default class ApiClient extends EventEmitter {
    * @param {number}  [options.circuitBreakerThreshold=5] - Nb d'erreurs avant de bloquer
    * @param {number}  [options.circuitBreakerResetTime=60000] - Ms avant de reset le breaker
    * @param {boolean} [options.fromJSONValue=true] - Si true, les données sont transformées en EJSON
+   * @param {TokenStorageStrategy} [options.tokenStorageStrategy=null] - Stratégie de stockage des tokens
    */
   constructor({
     baseURL,
@@ -43,7 +45,8 @@ export default class ApiClient extends EventEmitter {
     maxRetries = 0,
     circuitBreakerThreshold = 5,
     circuitBreakerResetTime = 60000,
-    fromJSONValue = true
+    fromJSONValue = true,
+    tokenStorageStrategy = null
   } = {}) {
     super(); // EventEmitter
 
@@ -54,7 +57,6 @@ export default class ApiClient extends EventEmitter {
     this.__entityTag = "ApiClient";
     
     this._baseURL = baseURL;
-    this._refreshToken = refreshToken;
     this._refreshUrl = refreshUrl;
     this._endpoints = endpoints;
     this._debug = debug;
@@ -122,30 +124,73 @@ export default class ApiClient extends EventEmitter {
     this._breakerOpen = false;
     this._lastBreakerOpenTime = null;
 
-    // Applique un token initial
+    this._accessToken = null;
+    this._refreshToken = null;
+
+    // Applique un token initial s'il est fourni
+    if(refreshToken){
+      this.setRefreshToken(refreshToken);
+    }
+
     if (accessToken) {
       this.setToken(accessToken);
     }
 
+    this._tokenStorage = tokenStorageStrategy || new MemoryStorageStrategy();
+
+    const initialAccessToken = this._tokenStorage.getAccessToken();
+    if (initialAccessToken) {
+      this.setToken(initialAccessToken);
+    }
+
+    const initialRefreshToken = this._tokenStorage.getRefreshToken();
+    if (initialRefreshToken) {
+      this.setRefreshToken(initialRefreshToken);
+    }
+    
+
     // Intercepteur 401 -> refresh
     this._client.interceptors.response.use(
-      (response) => response,
-      async (error) => {
-        if (error.response && error.response.status === 401) {
-          if (this._refreshToken) {
-            try {
-              const refreshed = await this._refreshAccessToken();
-              if (refreshed) {
-                return this._client.request(error.config);
-              }
-            } catch (err) {
-              throw new ApiClientError(err.message, 401, err);
+      response => response,
+      async error => {
+        const originalRequest = error.config;
+
+        // Si la requête est déjà réessayée, abandonne
+        if (originalRequest._retry) {
+          this._logger.error("[ApiClient] Requête déjà retentée, échec définitif.");
+          throw error;
+        }
+
+        if (error.response && error.response.status === 401 && this._refreshToken) {
+          originalRequest._retry = true;
+
+          try {
+            this._logger.info("[ApiClient] Tentative de refresh du token...");
+            const refreshed = await this._refreshAccessToken();
+
+            if (refreshed) {
+              this._logger.info("[ApiClient] Token rafraîchi avec succès.");
+
+              // 🔑 Mise à jour EXPLICITE du header Authorization dans la requête originale
+              originalRequest.headers["Authorization"] = "Bearer " + this.getToken();
+
+              this._logger.info("[ApiClient] Retente la requête originale avec le nouveau token.");
+              return this._client.request(originalRequest);
+            } else {
+              this.resetSession();
+              throw new ApiClientError("Impossible de rafraîchir le token.", 401);
             }
+          } catch (err) {
+            this.resetSession();
+            throw new ApiClientError("Erreur lors du rafraîchissement du token.", 401, err);
           }
         }
+
         throw error;
       }
     );
+
+
   }
 
   /**
@@ -155,6 +200,7 @@ export default class ApiClient extends EventEmitter {
    */
   setToken(token) {
     this._accessToken = token;
+    this._tokenStorage.setAccessToken(token);
     this._client.defaults.headers.common["Authorization"] = "Bearer " + token;
     // Extrait l'id depuis le token et le stocke si disponible
     const userId = this._getIdFromToken(token);
@@ -177,17 +223,20 @@ export default class ApiClient extends EventEmitter {
   /**
    * Sets the refresh token for the API client.
    *
-   * @param {string} rt - The refresh token to be set.
+   * @param {string} refreshToken - The refresh token to be set.
    */
-  setRefreshToken(rt) {
-    this._refreshToken = rt;
-    // Vous pouvez faire de même ici si besoin
-    const userId = this._getIdFromToken(rt);
-    if (userId) {
-      this._setUserId(userId);
-      this._logger.debug(`[ApiClient] userId extrait depuis refreshToken : ${userId}`);
+  setRefreshToken(token) {
+    this._refreshToken = token;
+    this._tokenStorage.setRefreshToken(token);
+    if(this.userId === null){
+    // Extrait l'id depuis le token et le stocke si disponible
+      const userId = this._getIdFromToken(token);
+      if (userId) {
+        this._setUserId(userId);
+        this._logger.debug(`[ApiClient] userId extrait depuis refreshToken : ${userId}`);
+      }
     }
-    this._logger.debug(`[ApiClient] setRefreshToken: ${rt}`);
+    this._logger.debug(`[ApiClient] setRefreshToken: ${token}`);
   }
 
   /**
@@ -235,14 +284,19 @@ export default class ApiClient extends EventEmitter {
    */
   async _refreshAccessToken() {
     if (!this._refreshToken) return false;
+
+    const refreshClient = axios.create({
+      baseURL: this._baseURL,
+      timeout: 10000, // ajuster si nécessaire
+      headers: { "Content-Type": "application/json" }
+    });
+
     try {
-      const response = await this._client.post(
-        this._refreshUrl,
-        { refreshToken: this._refreshToken },
-        { headers: { "Content-Type": "application/json" } }
-      );
-      if (response.data && response.data.accessToken) {
-        this.setToken(response.data.accessToken);
+      const response = await refreshClient.post(this._refreshUrl, {
+        refreshToken: this._refreshToken
+      });
+      if (response.data && response.data.token) {
+        this.setToken(response.data.token);
         if (response.data.refreshToken) {
           this.setRefreshToken(response.data.refreshToken);
         }
@@ -775,6 +829,7 @@ export default class ApiClient extends EventEmitter {
     this.setToken(null);
     this.setRefreshToken(null);
     this._setUserId(null);
+    this._tokenStorage.clear();
 
     // Suppression des en-têtes
     delete this._client.defaults.headers.common["Authorization"];

package/src/api/UserApi.js

@@ -1,6 +1,6 @@
 // UserApi.js
 import ApiClient from "../ApiClient.js";
-import { ApiResponseError } from "../error.js";
+import { ApiError, ApiResponseError } from "../error.js";
 import EndpointApi from "./EndpointApi.js";
 import { News } from "./News.js";
 import { Organization } from "./Organization.js";
@@ -11,8 +11,17 @@ export class UserApi {
   constructor(options) {
     // Injection de dépendance : ApiClient est créé à partir des options
     this.client = new ApiClient(options);
+    // si l'option "tokenStorageStrategy" est définie, on l'utilise pour créer une instance de ApiClient
     this.loggedUser = null;
   }
+
+  get isConnected() {
+    return this.client.isConnected;
+  }
+  get userId() {
+    return this.client.userId;
+  }
+  
   // Méthode d'authentification : récupère les données utilisateur depuis un endpoint
   async login(email, password) {
     return this.client.safeCall(async () => {
@@ -24,6 +33,16 @@ export class UserApi {
     });
   }
 
+  async meIsconnected() {
+    if(!this.client.isConnected || !this.client.userId) {
+      throw new ApiError("User not connected", 401);
+    }
+    this.client._logger.info("UserApi", "meIsconnected", this.client.userId);
+    this.loggedUser = new User(this.client, { id: this.client.userId }, { EndpointApi, Organization, Project, News });
+    return this.loggedUser;
+  }
+
+
   async register({
     name,
     username,
@@ -49,4 +68,5 @@ export class UserApi {
       return response.data;
     });
   }
+
 }

package/src/index.js

@@ -1,5 +1,7 @@
 import Api from "./Api.js";
 import ApiClient from "./ApiClient.js";
 import * as error from "./error.js";
+import { createDefaultTokenStorageStrategy } from "./utils/createDefaultTokenStorageStrategy.js";
+import { TokenStorageStrategy } from "./utils/TokenStorage.js";
 
-export default { ApiClient, Api, error };
+export default { ApiClient, Api, error, tokenStorageStrategy: { createDefaultTokenStorageStrategy, TokenStorageStrategy } };

package/src/utils/FileStorageStrategy.node.js

@@ -0,0 +1,60 @@
+// src/utils/FileStorageStrategy.node.js
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+import { TokenStorageStrategy } from "./TokenStorage.js";
+
+export class FileStorageStrategy extends TokenStorageStrategy {
+  constructor(filename = "tokens.json", dir = path.join(os.homedir(), ".config", "cocolight")) {
+    super();
+    this.dir = dir;
+    this.filePath = path.join(dir, filename);
+    this._ensureDirectoryExists();
+  }
+
+  _ensureDirectoryExists() {
+    if (!fs.existsSync(this.dir)) {
+      fs.mkdirSync(this.dir, { recursive: true });
+    }
+  }
+
+  _readFile() {
+    if (!fs.existsSync(this.filePath)) return {};
+    try {
+      return JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+     
+    } catch (e) {
+      console.error("Error reading token file:", e);
+      return {};
+    }
+  }
+
+  _writeFile(data) {
+    fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf8");
+  }
+
+  getAccessToken() {
+    return this._readFile().accessToken || null;
+  }
+
+  setAccessToken(token) {
+    const data = this._readFile();
+    data.accessToken = token;
+    this._writeFile(data);
+  }
+
+  getRefreshToken() {
+    return this._readFile().refreshToken || null;
+  }
+
+  setRefreshToken(token) {
+    const data = this._readFile();
+    data.refreshToken = token;
+    this._writeFile(data);
+  }
+
+  clear() {
+    this._writeFile({});
+  }
+}

package/src/utils/TokenStorage.js

@@ -0,0 +1,93 @@
+// src/utils/TokenStorage.js
+
+export class TokenStorageStrategy {
+  getAccessToken() {
+    throw new Error("getAccessToken() doit être implémenté");
+  }
+  
+  // eslint-disable-next-line no-unused-vars
+  setAccessToken(token) {
+    throw new Error("setAccessToken() doit être implémenté");
+  }
+  
+  getRefreshToken() {
+    throw new Error("getRefreshToken() doit être implémenté");
+  }
+  
+  // eslint-disable-next-line no-unused-vars
+  setRefreshToken(token) {
+    throw new Error("setRefreshToken() doit être implémenté");
+  }
+  
+  clear() {
+    throw new Error("clear() doit être implémenté");
+  }
+}
+  
+export class MemoryStorageStrategy extends TokenStorageStrategy {
+  constructor() {
+    super();
+    this._accessToken = null;
+    this._refreshToken = null;
+  }
+  
+  getAccessToken() {
+    return this._accessToken;
+  }
+  
+  setAccessToken(token) {
+    this._accessToken = token;
+  }
+  
+  getRefreshToken() {
+    return this._refreshToken;
+  }
+  
+  setRefreshToken(token) {
+    this._refreshToken = token;
+  }
+  
+  clear() {
+    this._accessToken = null;
+    this._refreshToken = null;
+  }
+}
+  
+export class LocalStorageStrategy extends TokenStorageStrategy {
+  constructor(prefix = "cocolight") {
+    super();
+    this.prefix = prefix;
+  }
+  
+  getAccessToken() {
+    return typeof localStorage !== "undefined"
+      ? localStorage.getItem(`${this.prefix}_accessToken`)
+      : null;
+  }
+  
+  setAccessToken(token) {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(`${this.prefix}_accessToken`, token);
+    }
+  }
+  
+  getRefreshToken() {
+    return typeof localStorage !== "undefined"
+      ? localStorage.getItem(`${this.prefix}_refreshToken`)
+      : null;
+  }
+  
+  setRefreshToken(token) {
+    if (typeof localStorage !== "undefined") {
+      localStorage.setItem(`${this.prefix}_refreshToken`, token);
+    }
+  }
+  
+  clear() {
+    if (typeof localStorage !== "undefined") {
+      localStorage.removeItem(`${this.prefix}_accessToken`);
+      localStorage.removeItem(`${this.prefix}_refreshToken`);
+    }
+  }
+}
+  

package/src/utils/createDefaultTokenStorageStrategy.js

@@ -0,0 +1,45 @@
+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.
+ *
+ * @param {string} [tokenStorageStrategy="auto"] - La stratégie de stockage de jetons souhaitée.
+ *   Les valeurs possibles sont :
+ *   - "memory" : Utilise une stratégie de stockage en mémoire.
+ *   - "localStorage" : Utilise le localStorage du navigateur (si disponible).
+ *   - "file" : Utilise une stratégie de stockage basée sur des fichiers (non disponible dans les environnements navigateur).
+ *   - "auto" : Sélectionne automatiquement la meilleure stratégie de stockage disponible.
+ *
+ * @returns {Promise<Object>} Une promesse qui se résout avec une instance de la stratégie de stockage sélectionnée.
+ *
+ * @throws {Error} Lève une erreur si la stratégie sélectionnée n'est pas disponible dans l'environnement actuel.
+ */
+export async function createDefaultTokenStorageStrategy(tokenStorageStrategy = "auto") {
+  if (tokenStorageStrategy === "memory") {
+    return new MemoryStorageStrategy();
+  }
+  if (tokenStorageStrategy === "localStorage") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return new LocalStorageStrategy();
+    } else {
+      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();
+  }
+  if (tokenStorageStrategy === "auto") {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return new LocalStorageStrategy();
+    } else {
+      const { FileStorageStrategy } = await import("./FileStorageStrategy.node.js");
+      return new FileStorageStrategy();
+    }
+  }
+}