@communecter/cocolight-api-client 1.0.7 → 1.0.9

package/src/Api.js

@@ -1,4 +1,5 @@
 // Api.js
+import EndpointApi from "./api/EndpointApi.js";
 import { Organization } from "./api/Organization.js";
 import { Project } from "./api/Project.js";
 import { User } from "./api/User.js";
@@ -55,10 +56,9 @@ export default class Api {
       if(error instanceof ApiClientError) {
         if(error?.details?.error) {
           throw new ApiAuthenticationError(error.details.error, error.status, error.details);
-        } else {
-          throw error;
         }
       }
+      throw error;
     }
   }
     
@@ -80,7 +80,7 @@ export default class Api {
    */
   me() {
     if (!this._loggedUser) {
-      throw new Error("Accès refusé : utilisateur non authentifié.");
+      throw new ApiAuthenticationError("Accès refusé : utilisateur non authentifié.");
     }
     return this._loggedUser;
   }
@@ -93,7 +93,7 @@ export default class Api {
    */
   user(userData) {
     try {
-      return new User(this._client, userData);
+      return new User(this._client, userData, {}, { EndpointApi });
     } catch (error) {
       console.error("[Api.user] Erreur lors de la création d'un objet utilisateur public :", error.message);
       throw error;
@@ -112,9 +112,9 @@ export default class Api {
    */
   async organization(organizationData, options = { getProfile: true }) {
     try {
-      const oraganization = new Organization(this._client, organizationData);
+      const oraganization = new Organization(this._client, organizationData, { EndpointApi });
       if (options.getProfile) {
-        await oraganization.getProfile();
+        await oraganization.getProfil();
       }
       return oraganization;
     } catch (error) {
@@ -134,9 +134,9 @@ export default class Api {
    */
   async project(projectData, options = { getProfile: true }) {
     try {
-      const project = new Project(this._client, projectData);
+      const project = new Project(this._client, projectData, { EndpointApi });
       if (options.getProfile) {
-        await project.getProfile();
+        await project.getProfil();
       }
       return project;
     } catch (error) {
@@ -155,4 +155,8 @@ export default class Api {
     return this._client;
   }
 
+  get endpointApi() {
+    return new EndpointApi(this._client);
+  }
+  
 }

package/src/ApiClient.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events";
 
+import { AggregateAjvError } from "@segment/ajv-human-errors";
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
 import axios from "axios";
@@ -10,7 +11,7 @@ import pino from "pino";
 
 import MongoID from "./EJSONType.js";
 import endpointsJson from "./endpoints.module.js";
-import { ApiClientError, CircuitBreakerError } from "./error.js";
+import { ApiClientError, ApiResponseError, ApiValidationError, CircuitBreakerError } from "./error.js";
 
 EJSON.addType("oid", value => {
   return new MongoID.ObjectID(value);
@@ -74,9 +75,16 @@ export default class ApiClient extends EventEmitter {
     };
 
     // AJV
-    this._ajv = new Ajv({ strict: false, useDefaults: true });
+    this._ajv = new Ajv({ strict: false, useDefaults: true, allErrors: true, verbose: true });
     addFormats(this._ajv);
 
+    this._ajv.addKeyword({
+      keyword: "startBeforeEnd",
+      type: "object",
+      errors: true,
+      validate: this._startBeforeEndValidate
+    });
+
     // Pino logger
     // (Ici en mode pretty-print sur la console, tu peux configurer comme tu veux)
     this._logger = pino({
@@ -470,6 +478,15 @@ export default class ApiClient extends EventEmitter {
     return obj;
   }
   
+  /**
+   * Safely calls an asynchronous function and handles any errors that occur.
+   * Logs the error message using the instance's logger before re-throwing the error.
+   *
+   * @param {Function} fn - The asynchronous function to be called.
+   * @param {...any} args - The arguments to pass to the function.
+   * @returns {Promise<any>} The result of the asynchronous function.
+   * @throws {Error} Re-throws any error that occurs during the function execution.
+   */
   async safeCall(fn, ...args) {
     try {
       return await fn(...args);
@@ -543,8 +560,9 @@ export default class ApiClient extends EventEmitter {
       const valid = validatePathParams(pathParams);
   
       if (!valid) {
+        const errorMessages = this._ajvErrorHuman(validatePathParams.errors);
         this.emit("validationError", { stage: "pathParams", errors: validatePathParams.errors });
-        throw new ApiClientError("Path parameter validation failed.", 400, validatePathParams.errors);
+        throw new ApiValidationError("Path parameter validation failed.", 400, errorMessages, validatePathParams.errors);
       }
   
       resolvedParams = this._resolveSpecialValuesInPlace(pathParams);
@@ -571,8 +589,9 @@ export default class ApiClient extends EventEmitter {
       const validateRequest = this._ajv.compile(schemaToCompile);
       const valid = validateRequest(cleanedData);
       if (!valid) {
+        const errorMessages = validateRequest.errors ? this._ajvErrorHuman(validateRequest.errors) : [];
         this.emit("validationError", { stage: "request", errors: validateRequest.errors });
-        throw new ApiClientError("Request validation failed.", 400, validateRequest.errors);
+        throw new ApiValidationError("Request validation failed.", 400, errorMessages , validateRequest.errors);
       }
 
       data = this._resolveSpecialValuesInPlace(cleanedData, resolvedParams);
@@ -603,8 +622,9 @@ export default class ApiClient extends EventEmitter {
           const validateResponse = this._ajv.compile(schema);
           const valid = validateResponse(response.data);
           if (!valid) {
+            const errorMessages = this._ajvErrorHuman(validateResponse.errors);
             this.emit("validationError", { stage: "response", errors: validateResponse.errors });
-            throw new ApiClientError("Response validation failed.", status, validateResponse.errors);
+            throw new ApiValidationError("Response validation failed.", status, errorMessages, validateResponse.errors);
           }
         }
       }
@@ -666,14 +686,83 @@ export default class ApiClient extends EventEmitter {
     } catch (error) {
       this._updateCircuitBreakerError();
       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
-      );
+      if(error instanceof ApiValidationError) {
+        throw error;
+      } else {
+        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
+        );
+      }
+
     }
   }
   
+  /**
+   * Converts AJV (Another JSON Schema Validator) errors into human-readable messages.
+   *
+   * @param {Array} errors - An array of AJV validation error objects.
+   * @returns {Array<string>} An array of human-readable error messages extracted from the AJV errors.
+   */
+  _ajvErrorHuman(errors){
+    try {
+      const errorsMessages = new AggregateAjvError(errors);
+      const messages = errorsMessages.errors.map(({ message }) => message);
+      return messages;
+    } catch (e) {
+      this._logger.error("[ApiClient] _ajvErrorHuman", e);
+      return errors.map(({ message }) => message);
+    }
+  }
+
+  /**
+   * Checks the API response for errors and throws an `ApiResponseError` if any are found.
+   *
+   * This method examines the `response.data` object to determine if it contains
+   * error information. It handles both standard and nested error cases:
+   * 
+   * - Standard case: If `data.result` is a boolean and is `false`, an error is thrown.
+   * - Nested case: If `data.resultErrors` exists and contains a `result` property
+   *   that is a boolean and is `false`, an error is thrown.
+   *
+   * If no errors are found, the original `response` is returned.
+   *
+   * @param {Object} response - The API response object to check.
+   * @param {Object} response.data - The data payload of the response.
+   * @param {number} response.status - The HTTP status code of the response.
+   * @throws {ApiResponseError} If an error is detected in the response data.
+   * @returns {Object} The original `response` object if no errors are found.
+   */
+  checkAndThrowApiResponseError(response) {
+    const data = response.data;
+    if (!data || typeof data !== "object") {
+      return response;
+    }
+  
+    // Cas standard : vérifie si data.result vaut false
+    if (typeof data.result === "boolean" && data.result === false) {
+      throw new ApiResponseError(
+        data.msg || "Erreur inconnue",
+        response.status,
+        data
+      );
+    }
+  
+    // Cas imbriqué : vérifie si data.resultErrors existe et contient une erreur
+    if (data.resultErrors && typeof data.resultErrors === "object") {
+      if (typeof data.resultErrors.result === "boolean" && data.resultErrors.result === false) {
+        throw new ApiResponseError(
+          data.resultErrors.msg || "Erreur inconnue",
+          response.status,
+          data
+        );
+      }
+    }
+  
+    return response;
+  }
+    
   /**
  * Réinitialise complètement la session de l'utilisateur :
  * - Token d'accès
@@ -1271,5 +1360,24 @@ export default class ApiClient extends EventEmitter {
     return data;
   }
 
+  _startBeforeEndValidate = (schema, data) => {
+    if (!data.startDate || !data.endDate) return true;
+  
+    const isValid = new Date(data.startDate) < new Date(data.endDate);
+    if (!isValid) {
+      this._startBeforeEndValidate.errors = [
+        {
+          instancePath: "", // ou "." si tu veux le chemin actuel
+          schemaPath: "#/startBeforeEnd",
+          keyword: "startBeforeEnd",
+          params: {},
+          message: "startDate must be before endDate"
+        }
+      ];
+    }
+    return isValid;
+  };
+  
+
 
 }