@communecter/cocolight-api-client 1.0.1 → 1.0.4

package/package.json

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

package/src/ApiClient.js

@@ -273,34 +273,110 @@ export default class ApiClient extends EventEmitter {
     }
     return obj;
   }
-  
+
   _resolveSpecialValuesInPlace(obj) {
-    // Si l'objet ressemble à un fichier uploadé (détecte la présence d'un stream dans la propriété value), ne rien modifier.
-    if (obj && typeof obj === "object" && obj.value && typeof obj.value.pipe === "function") {
-      return obj;
-    }
-  
     const aliasMap = {
       userId: () => this.userId,
       accessToken: () => this._accessToken,
       refreshToken: () => this._refreshToken,
-      baseURL: () => this._baseURL,
-      // vous pouvez ajouter d'autres alias ici
+      baseURL: () => this._baseURL
+    };
+  
+    const resolveString = (str) => {
+      if (typeof str !== "string") return str;
+      return str.replace(/@(\w+)/g, (_, key) => {
+        const fn = aliasMap[key];
+        const value = typeof fn === "function" ? fn() : undefined;
+        if (value === undefined || value === null) {
+          return `@${key}`; // on laisse tel quel si la valeur n'est pas définie
+        }
+        return value;
+      });
     };
   
-    if (typeof obj === "string" && obj.startsWith("@")) {
-      const varName = obj.slice(1);
-      return typeof aliasMap[varName] === "function" ? aliasMap[varName]() : obj;
-    } else if (Array.isArray(obj)) {
-      for (let i = 0; i < obj.length; i++) {
-        obj[i] = this._resolveSpecialValuesInPlace(obj[i]);
+    // Vérifie si l'objet est un binaire (par exemple un flux ou un Buffer)
+    const isBinary = (input) => {
+      return input && typeof input === "object" &&
+             (typeof input.pipe === "function" || (typeof Buffer !== "undefined" && input instanceof Buffer));
+    };
+  
+    // Vérifie si l'objet est un "plain object"
+    const isPlainObject = (input) => {
+      return Object.prototype.toString.call(input) === "[object Object]";
+    };
+  
+    const internal = (input) => {
+      // Si c'est un binaire, ne rien modifier
+      if (isBinary(input)) {
+        return input;
+      }
+      // Si c'est un tableau, on traite chaque élément
+      if (Array.isArray(input)) {
+        return input.map(internal);
       }
+      // Si c'est un plain object, on crée un nouvel objet avec remplacement dans les clés et valeurs
+      if (isPlainObject(input)) {
+        const result = {};
+        for (const [key, value] of Object.entries(input)) {
+          const resolvedKey = resolveString(key);
+          result[resolvedKey] = internal(value);
+        }
+        return result;
+      }
+      // Si c'est une string, on applique le remplacement
+      if (typeof input === "string") {
+        return resolveString(input);
+      }
+      // Sinon (nombre, booléen, etc.), on retourne la valeur telle quelle
+      return input;
+    };
+  
+    return internal(obj);
+  }
+  
+
+  _cleanSchemaLeftoverAlias(obj) {
+    // Expression régulière qui détecte n'importe quel alias du type "@quelqueChose"
+    const aliasRegex = /@\w+/;
+    
+    if (Array.isArray(obj)) {
+      return obj.map(item => this._cleanSchemaLeftoverAlias(item));
     } else if (obj && typeof obj === "object") {
-      for (const key in obj) {
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-          obj[key] = this._resolveSpecialValuesInPlace(obj[key]);
+      const newObj = {};
+      for (const key of Object.keys(obj)) {
+        const val = obj[key];
+  
+        // Si le nom de la clé contient un alias (exemple : "@userId", "@anything"), on ne la copie pas
+        if (aliasRegex.test(key)) {
+          continue;
         }
+  
+        // Si la propriété s'appelle "default"
+        if (key === "default") {
+          // Si la valeur est une chaîne et qu'elle contient un alias, on ne la copie pas
+          if (typeof val === "string" && aliasRegex.test(val)) {
+            continue;
+          }
+          // Si la valeur est un objet, on le nettoie récursivement
+          if (val && typeof val === "object") {
+            const cleanedDefault = this._cleanSchemaLeftoverAlias(val);
+            // On ajoute seulement si l'objet nettoyé n'est pas vide
+            if (Object.keys(cleanedDefault).length > 0) {
+              newObj[key] = cleanedDefault;
+            }
+            continue;
+          }
+        }
+  
+        // Si la valeur est une chaîne contenant un alias, on ne la copie pas
+        if (typeof val === "string" && aliasRegex.test(val)) {
+          continue;
+        }
+  
+        // Sinon, on nettoie récursivement la valeur
+        newObj[key] = this._cleanSchemaLeftoverAlias(val);
       }
+      return newObj;
     }
     return obj;
   }
@@ -357,8 +433,15 @@ export default class ApiClient extends EventEmitter {
     // === 1. PathParams ===
     let resolvedPath = path;
     if (pathSchema) {
+
+      // Si auth est "none" et que userId n'est pas défini, on nettoie le schéma
+      let schemaToCompile = pathSchema;
+      if (auth === "none" && this.userId === null) {
+        schemaToCompile = this._cleanSchemaLeftoverAlias(pathSchema);
+      }
+
       const pathParams = data.pathParams || {};
-      const validatePathParams = this._ajv.compile(pathSchema);
+      const validatePathParams = this._ajv.compile(schemaToCompile);
       const valid = validatePathParams(pathParams);
   
       if (!valid) {
@@ -377,11 +460,17 @@ export default class ApiClient extends EventEmitter {
   
     // === 2. Validation données (request schema) ===
     if (requestSchema) {
+      // Si auth est "none" et que userId n'est pas défini, on nettoie le schéma
+      let schemaToCompile = requestSchema;
+      if (auth === "none" && this.userId === null) {
+        schemaToCompile = this._cleanSchemaLeftoverAlias(requestSchema);
+      }
+
       const dataForValidation = { ...data };
       delete dataForValidation.pathParams;
       const cleanedData = ApiClient.stripNullsInPlace(dataForValidation);
-
-      const validateRequest = this._ajv.compile(requestSchema);
+        
+      const validateRequest = this._ajv.compile(schemaToCompile);
       const valid = validateRequest(cleanedData);
       if (!valid) {
         this.emit("validationError", { stage: "request", errors: validateRequest.errors });