@communecter/cocolight-api-client 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.5",
+    "version": "1.0.7",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",
@@ -17,14 +17,16 @@
     "scripts": {
         "test": "node --experimental-vm-modules ./node_modules/.bin/jest --config jest.config.js",
         "exemple": "node exemple/exemple.js",
+        "exemple-api": "node exemple/exemple-api.js",
         "lint": "eslint ./src ./exemple ./scripts --ext .js",
         "lint:fix": "eslint ./src ./scripts --ext .js --fix",
         "build:browser": "webpack --config webpack.config.standalone.js",
         "build:node": "webpack --config webpack.config.node.js",
         "build:esm": "webpack --config webpack.config.esm.mjs",
-        "build": "npm run generate:module && npm run generate:doc && npm run lint:fix && npm run build:browser && npm run build:node && npm run build:esm",
+        "build": "npm run generate:module:publish && npm run generate:doc && npm run lint:fix && npm run build:browser && npm run build:node && npm run build:esm",
         "build:publish": "npm run build && npm publish --access public",
         "generate:module": "node ./scripts/transform-json-module.js",
+        "generate:module:publish": "node ./scripts/transform-json-module.publish.js",
         "generate:doc": "node ./scripts/generate-doc.js",
         "generate:test": "node ./scripts/generate-tests.js",
         "generate:testdata": "node ./scripts/generate-test-data.js"
@@ -39,10 +41,10 @@
     "author": "Thomas",
     "license": "MIT",
     "files": [
-    "dist/",
-    "src/",
-    "package.json",
-    "README.md"
+        "dist/",
+        "src/",
+        "package.json",
+        "README.md"
     ],
     "peerDependencies": {
         "ajv": "^8.17.1",
@@ -52,27 +54,29 @@
         "ejson": "^2.2.3",
         "events": "^3.3.0",
         "pino": "^9.6.0",
-        "pino-pretty": "^13.0.0"
+        "pino-pretty": "^13.0.0",
+        "jwt-decode": "^4.0.0"
     },
     "devDependencies": {
+        "@babel/core": "^7.26.10",
+        "@babel/preset-env": "^7.26.9",
+        "@eslint/js": "^9.23.0",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
         "axios": "^1.4.0",
         "axios-retry": "^4.5.0",
-        "ejson": "^2.2.3",
-        "events": "^3.3.0",
-        "pino": "^9.6.0",
-        "pino-pretty": "^13.0.0",
-        "@babel/core": "^7.26.10",
-        "@babel/preset-env": "^7.26.9",
-        "@eslint/js": "^9.23.0",
+        "jwt-decode": "^4.0.0",
         "babel-jest": "^29.7.0",
         "babel-loader": "^10.0.0",
+        "ejson": "^2.2.3",
         "eslint": "^9.23.0",
         "eslint-plugin-import": "^2.31.0",
+        "events": "^3.3.0",
         "globals": "^16.0.0",
         "jest": "^29.7.0",
         "nodemon": "^3.1.9",
+        "pino": "^9.6.0",
+        "pino-pretty": "^13.0.0",
         "webpack": "^5.98.0",
         "webpack-cli": "^6.0.1"
     }

package/src/Api.js

@@ -0,0 +1,158 @@
+// Api.js
+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";
+
+export default class Api {
+  /**
+   * Authentifie l'utilisateur et retourne une instance d'Api.
+   *
+   * @param {string} email - L'adresse email.
+   * @param {string} password - Le mot de passe.
+   * @param {Object} options - Options pour l'ApiClient (baseURL, debug, etc.)
+   * @returns {Promise<Api>}
+   */
+  static async userLogin(email, password, options) {
+    const userApi = Api.userApi(options);
+    return await Api.userApiLogin(userApi, email, password);
+  }
+
+  /**
+   * Creates an instance of the UserApi class with the provided options.
+   *
+   * @param {Object} options - Configuration options for initializing the UserApi instance.
+   * @returns {UserApi} An instance of the UserApi class.
+   * @throws {Error} Throws an error if the UserApi instance cannot be created.
+   */
+  static userApi(options) {
+    try {
+      const userApi = new UserApi(options);
+      return userApi;
+    } catch (error) {
+      console.error("[Api.userApi] Erreur lors de la création d'un objet utilisateur :", error.message);
+      throw error;
+    }
+  }
+  
+  /**
+     * Logs in a user using the provided userApi instance, email, and password.
+     *
+     * @param {Object} userApi - The API instance used for user authentication.
+     * @param {string} email - The email address of the user.
+     * @param {string} password - The password of the user.
+     * @returns {Promise<Api>} A promise that resolves to an instance of the Api class
+     *                         initialized with the logged-in user and the API client.
+     * @throws {ApiAuthenticationError} If the login fails due to authentication issues.
+     * @throws {Error} If an unexpected error occurs during the login process.
+     */
+  static async userApiLogin(userApi, email, password) {
+    try {
+      const loggedUser = await userApi.login(email, password);
+      return new Api(loggedUser, userApi.client);
+    } catch (error) {
+      if(error instanceof ApiClientError) {
+        if(error?.details?.error) {
+          throw new ApiAuthenticationError(error.details.error, error.status, error.details);
+        } else {
+          throw error;
+        }
+      }
+    }
+  }
+    
+  /**
+   * Construit une instance d'Api.
+   *
+   * @param {User|null} loggedUser - L'utilisateur connecté ou null.
+   * @param {ApiClient} client - L'instance d'ApiClient.
+   */
+  constructor(loggedUser, client) {
+    this._loggedUser = loggedUser;
+    this._client = client;
+  }
+
+  /**
+   * Retourne l'utilisateur connecté.
+   *
+   * @returns {User} L'utilisateur connecté.
+   */
+  me() {
+    if (!this._loggedUser) {
+      throw new Error("Accès refusé : utilisateur non authentifié.");
+    }
+    return this._loggedUser;
+  }
+
+  /**
+   * Crée une instance User pour un utilisateur donné (autre que le connecté).
+   *
+   * @param {Object} userData - Les données de l'utilisateur public.
+   * @returns {User}
+   */
+  user(userData) {
+    try {
+      return new User(this._client, userData);
+    } catch (error) {
+      console.error("[Api.user] Erreur lors de la création d'un objet utilisateur public :", error.message);
+      throw error;
+    }
+  }
+
+
+  /**
+   * Creates an Organization object and optionally retrieves its profile.
+   *
+   * @param {Object} organizationData - The data required to initialize the Organization object.
+   * @param {Object} [options={ getProfile: true }] - Additional options for the organization creation.
+   * @param {boolean} [options.getProfile=true] - Whether to fetch the organization's profile after creation.
+   * @returns {Promise<Organization>} A promise that resolves to the created Organization object.
+   * @throws {Error} Throws an error if the organization creation or profile retrieval fails.
+   */
+  async organization(organizationData, options = { getProfile: true }) {
+    try {
+      const oraganization = new Organization(this._client, organizationData);
+      if (options.getProfile) {
+        await oraganization.getProfile();
+      }
+      return oraganization;
+    } catch (error) {
+      console.error("[Api.organization] Erreur lors de la création d'un objet organisation :", error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Creates a new Project instance and optionally retrieves its profile.
+   *
+   * @param {Object} projectData - The data used to initialize the Project instance.
+   * @param {Object} [options={ getProfile: true }] - Additional options for project creation.
+   * @param {boolean} [options.getProfile=true] - Whether to retrieve the project's profile after creation.
+   * @returns {Promise<Project>} A promise that resolves to the created Project instance.
+   * @throws {Error} If an error occurs during project creation or profile retrieval.
+   */
+  async project(projectData, options = { getProfile: true }) {
+    try {
+      const project = new Project(this._client, projectData);
+      if (options.getProfile) {
+        await project.getProfile();
+      }
+      return project;
+    } catch (error) {
+      console.error("[Api.project] Erreur lors de la création d'un objet projet :", error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * Retourne l'instance d'ApiClient.
+   *
+   * @returns {ApiClient}
+   */
+
+  get client() {
+    return this._client;
+  }
+
+}

package/src/ApiClient.js

@@ -5,6 +5,7 @@ import addFormats from "ajv-formats";
 import axios from "axios";
 import axiosRetry from "axios-retry";
 import EJSON from "ejson";
+import { jwtDecode } from "jwt-decode";
 import pino from "pino";
 
 import MongoID from "./EJSONType.js";
@@ -146,6 +147,12 @@ export default class ApiClient extends EventEmitter {
   setToken(token) {
     this._accessToken = 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);
+    if (userId) {
+      this._setUserId(userId);
+      this._logger.debug(`[ApiClient] userId extrait et défini : ${userId}`);
+    }
     this._logger.debug(`[ApiClient] setToken: ${token}`);
   }
 
@@ -165,6 +172,12 @@ export default class ApiClient extends EventEmitter {
    */
   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}`);
+    }
     this._logger.debug(`[ApiClient] setRefreshToken: ${rt}`);
   }
 
@@ -177,6 +190,36 @@ export default class ApiClient extends EventEmitter {
     return this._refreshToken;
   }
 
+  /**
+   * Indique si le client est connecté.
+   * On considère que le client est connecté si un token d'accès (_accessToken) est défini.
+   *
+   * @returns {boolean} True si connecté, false sinon.
+   */
+  get isConnected() {
+    return !!this._accessToken;
+  }
+
+  /**
+ * Extrait l'identifiant depuis un JWT.
+ *
+ * @param {string} token - Le token JWT (accessToken ou refreshToken).
+ * @returns {string|null} L'identifiant extrait ou null si non trouvé.
+ */
+  _getIdFromToken(token) {
+    if (!token) return null;
+    try {
+      // Décodage du token grâce à jwt-decode
+      const payload = jwtDecode(token);
+      // L'identifiant peut être dans "id" ou "userId"
+      this._logger.debug("[ApiClient] Payload décodé :", payload);
+      return payload.id || payload.userId || null;
+    } catch (err) {
+      this._logger.error("[ApiClient] Erreur lors du décodage du token :", err);
+      return null;
+    }
+  }
+
   /**
    * Méthode simplifiée de refresh (en JSON). 
    * Emet un event refreshSuccess si ça marche
@@ -199,6 +242,8 @@ export default class ApiClient extends EventEmitter {
       }
       return false;
     } catch (err) {
+      // Si on a une erreur, on reset la session
+      this.resetSession();
       this._logger.error(`[ApiClient] Refresh Error : ${err.message}`);
       return false;
     }
@@ -425,6 +470,14 @@ export default class ApiClient extends EventEmitter {
     return obj;
   }
   
+  async safeCall(fn, ...args) {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      this._logger.error(`[ApiClient.safeCall] Erreur: ${error.message}`);
+      throw error;
+    }
+  }
 
   /**
    * Calls an API endpoint with the specified parameters.
@@ -578,9 +631,9 @@ export default class ApiClient extends EventEmitter {
             this.setRefreshToken(value);
             break;
       
-          case "setUserId":
-            this._setUserId(value);
-            break;
+            // case "setUserId":
+            //   this._setUserId(value);
+            //   break;
             
           case "resetSession":
             this.resetSession();
@@ -612,7 +665,12 @@ export default class ApiClient extends EventEmitter {
       return response;
     } catch (error) {
       this._updateCircuitBreakerError();
-      throw error;
+      this._logger.error(`[ApiClient] Erreur lors de l'appel de ${constant}: ${error.message}`);
+      throw new ApiClientError(
+        `Erreur lors de l'appel de l'API : ${error.message}`,
+        error.response ? error.response.status : 500,
+        error.response ? error.response.data : null
+      );
     }
   }
   

package/src/api/EntityMixin.js

@@ -0,0 +1,43 @@
+import { ApiResponseError } from "../error.js";
+
+// EntityMixin.js
+export const EntityMixin = {
+  /**
+     * Résout l'identifiant de l'entité si seul le slug est fourni.
+     * @param {string} type - Le type d'entité (ex : "citoyens", "organizations", "projects").
+     * @returns {Promise<string>} L'identifiant résolu.
+     */
+  async resolveId(type) {
+    return this.apiClient.safeCall(async () => {
+      if (!this.id && this.slug) {
+        const response = await this.apiClient.callEndpoint("GET_ELEMENTS_KEY", {
+          pathParams:{
+            slug: this.slug
+          }
+        });
+        if(response?.data?.result === true) {
+          if(response?.data?.contextId && response?.data?.contextType === type) {
+            this.id = response.data.contextId;
+          } else {
+            throw new ApiResponseError(`Le slug ${this.slug} ne correspond pas à un ${type}`, response.status, response.data);
+          }
+        } else {
+          throw new ApiResponseError(`Impossible de récupérer l'identifiant pour le slug ${this.slug}`, response.status, response.data);
+        }
+      }
+      return this.id;
+    });
+  },
+  
+  /**
+     * Récupère le profil public de l'entité.
+     * @returns {Promise<Object>} Les données du profil public.
+     */
+  async getPublicProfile() {
+    return this.apiClient.safeCall(async () => {
+      await this.resolveId(this.getEntityType());
+      return this.apiClient.callEndpoint("GET_ELEMENTS_ABOUT", { pathParams: { id: this.id } });
+    });
+  }
+};
+  

package/src/api/Organization.js

@@ -0,0 +1,79 @@
+import { EntityMixin } from "./EntityMixin.js";
+
+// Organization.js
+export class Organization {
+  // Champs privés pour protéger l'état
+  #id;
+  #slug;
+  #data = null;
+
+  /**
+   * Crée une instance de Organization.
+   * @param {ApiClient} apiClient - L'instance d'ApiClient.
+   * @param {Object} identifier - Objet contenant { id } ou { slug }.
+   */
+
+  constructor(apiClient, { id, slug } = {}) {
+    if (!id && !slug) {
+      throw new Error("Vous devez fournir un id ou un slug pour créer un User.");
+    }
+    this.apiClient = apiClient;
+    this.#id = id || null;
+    this.#slug = slug || null;
+  }
+  
+  // Getters en lecture seule pour chaque propriété
+  get id() {
+    return this.#id;
+  }
+      
+  get slug() {
+    return this.#slug;
+  }
+
+  _slug(newSlug) {
+    this.#slug = newSlug;
+  }
+      
+  get isConnected() {
+    return this.apiClient.isConnected;
+  }
+
+  get data() {
+    return this.#data;
+  }
+
+  _setData(newData) {
+    this.#data = newData;
+  }
+
+  get userId() {
+    return this.apiClient.userId;
+  }
+  
+  get isMe() {
+    return this.isConnected && this.userId === this.id;
+  }
+
+  getEntityType() {
+    return "organizations";
+  }
+
+  /**
+     * Récupère le profil complet de l'organisation.
+     *
+     * @returns {Promise<Object>} Le profil complet.
+     */
+  async getProfile() {
+    return this.apiClient.safeCall(async () => {
+      const response = await this.getPublicProfile();
+      this._setData(response.data);
+      return response.data;
+    });
+  }
+  
+}
+
+// Incorporation du mixin dans Organization
+Object.assign(Organization.prototype, EntityMixin);
+  

package/src/api/Project.js

@@ -0,0 +1,79 @@
+import { EntityMixin } from "./EntityMixin.js";
+
+// Project.js
+export class Project {
+  // Champs privés pour protéger l'état
+  #id;
+  #slug;
+  #data = null;
+
+  /**
+   * Crée une instance de Project.
+   * @param {ApiClient} apiClient - L'instance d'ApiClient.
+   * @param {Object} identifier - Objet contenant { id } ou { slug }.
+   */
+
+  constructor(apiClient, { id, slug } = {}) {
+    if (!id && !slug) {
+      throw new Error("Vous devez fournir un id ou un slug pour créer un User.");
+    }
+    this.apiClient = apiClient;
+    this.#id = id || null;
+    this.#slug = slug || null;
+  }
+  
+  // Getters en lecture seule pour chaque propriété
+  get id() {
+    return this.#id;
+  }
+      
+  get slug() {
+    return this.#slug;
+  }
+
+  _slug(newSlug) {
+    this.#slug = newSlug;
+  }
+      
+  get isConnected() {
+    return this.apiClient.isConnected;
+  }
+
+  get data() {
+    return this.#data;
+  }
+
+  _setData(newData) {
+    this.#data = newData;
+  }
+
+  get userId() {
+    return this.apiClient.userId;
+  }
+  
+  get isMe() {
+    return this.isConnected && this.userId === this.id;
+  }
+
+  getEntityType() {
+    return "projects";
+  }
+
+  /**
+     * Récupère le profil complet de l'organisation.
+     *
+     * @returns {Promise<Object>} Le profil complet.
+     */
+  async getProfile() {
+    return this.apiClient.safeCall(async () => {
+      const response = await this.getPublicProfile();
+      this._setData(response.data);
+      return response.data;
+    });
+  }
+  
+}
+
+// Incorporation du mixin dans Project
+Object.assign(Project.prototype, EntityMixin);
+  

package/src/api/User.js

@@ -0,0 +1,89 @@
+import { EntityMixin } from "./EntityMixin.js";
+
+// User.js
+export class User {
+  // Champs privés pour protéger l'état
+  #id;
+  #slug;
+  #data;
+
+  /**
+   * Crée une instance de User.
+   * @param {ApiClient} apiClient - L'instance d'ApiClient.
+   * @param {Object} identifier - Objet contenant { id } ou { slug }.
+   * @param {Object} [data={}] - Données supplémentaires.
+   */
+
+  constructor(apiClient, { id, slug } = {}, data = {}) {
+    if (!id && !slug) {
+      throw new Error("Vous devez fournir un id ou un slug pour créer un User.");
+    }
+    this.apiClient = apiClient;
+    this.#id = id || null;
+    this.#slug = slug || null;
+    this.#data = data;
+  }
+  
+  // Getters en lecture seule pour chaque propriété
+  get id() {
+    return this.#id;
+  }
+  
+  get slug() {
+    return this.#slug;
+  }
+
+  _slug(newSlug) {
+    this.#slug = newSlug;
+  }
+  
+  get isConnected() {
+    return this.apiClient.isConnected;
+  }
+
+  // Getter pour accéder aux données
+  get data() {
+    return this.#data;
+  }
+
+  // Méthode interne qui permet de mettre à jour les données
+  _setData(newData) {
+    this.#data = newData;
+  }
+
+  getEntityType() {
+    return "citoyens";
+  }
+
+  get userId() {
+    return this.apiClient.userId;
+  }
+  
+  get isMe() {
+    return this.isConnected && this.userId === this.id;
+  }
+
+  /**
+     * Récupère le profil complet de l'utilisateur.
+     * Si l'utilisateur est connecté, on appelle le endpoint ME_INFO_URL,
+     * sinon, on peut imaginer appeler un endpoint public.
+     *
+     * @returns {Promise<Object>} Le profil complet.
+     */
+  async getProfile() {
+    return this.apiClient.safeCall(async () => {
+      if (this.isMe) {
+        const response = await this.apiClient.callEndpoint("ME_INFO_URL", {});
+        return response.data;
+      } else {
+        const response = await this.getPublicProfile();
+        return response.data;
+      }
+    });
+  }
+  
+}
+
+// Incorporation du mixin dans User
+Object.assign(User.prototype, EntityMixin);
+  

package/src/api/UserApi.js

@@ -0,0 +1,48 @@
+// UserApi.js
+import ApiClient from "../ApiClient.js";
+import { ApiResponseError } from "../error.js";
+import { User } from "./User.js";
+
+export class UserApi {
+  constructor(options) {
+    // Injection de dépendance : ApiClient est créé à partir des options
+    this.client = new ApiClient(options);
+    this.loggedUser = null;
+  }
+  // Méthode d'authentification : récupère les données utilisateur depuis un endpoint
+  async login(email, password) {
+    return this.client.safeCall(async () => {
+    // Appel à un endpoint d'authentification
+      const response = await this.client.callEndpoint("AUTHENTICATE_URL", { email, password });
+      // Création d'une instance de LoggedInUser à partir des données reçues
+      this.loggedUser = new User(this.client, { id: response.data.user.id }, response.data.user);
+      return this.loggedUser;
+    });
+  }
+
+  async register({
+    name,
+    username,
+    email,
+    pwd,
+  } = {}) {
+    return this.client.safeCall(async () => {
+      const response = await this.client.callEndpoint("PERSON_REGISTER", { name, username, email, pwd });
+      if(response?.data?.result === false) {
+        throw new ApiResponseError(response.data.msg, response.status, response.data);
+      }
+      return response.data;
+    });
+  }
+
+
+  async recoverPassword(email) {
+    return this.client.safeCall(async () => {
+      const response = await this.client.callEndpoint("PASSWORD_RECOVERY", { email });
+      if(response?.data?.result === false) {
+        throw new ApiResponseError(response.data.msg, response.status, response.data);
+      }
+      return response.data;
+    });
+  }
+}