@communecter/cocolight-api-client 1.0.7 → 1.0.9

package/src/mixin/UtilMixin.js

@@ -0,0 +1,246 @@
+import { fileTypeFromBuffer } from "file-type";
+
+import { ApiAuthenticationError, ApiValidationError } from "../error.js";
+
+// UtilMixin.js
+export const UtilMixin = {
+
+  async call(constant, data = {}) {
+    return this.apiClient.safeCall(async () => {
+      const response = await this.apiClient.callEndpoint(constant, data);
+      this.apiClient.checkAndThrowApiResponseError(response);
+      return response.data;
+    });
+  },
+
+  async callNoConnected(constant, data = {}) {
+    if(this.isConnected) {
+      throw new ApiAuthenticationError("Vous devez ne devez pas être connecté pour faire cette action.");
+    }
+    return this.call(constant, data);
+  },
+
+  async callIsConnected(param, data = {}) {
+    if(!this.isConnected) {
+      throw new ApiAuthenticationError("Vous devez être connecté pour faire cette action.");
+    }
+    // Si le premier paramètre est une fonction, on l'exécute en tant que callback
+    if (typeof param === "function") {
+      return await param();
+    }
+    return this.call(param, data);
+  },
+
+  async callIsMe(param, data = {}) {
+    if (!this.isMe) {
+      throw new ApiAuthenticationError("Vous devez être vous-même pour faire cette action.");
+    }
+    // Si le premier paramètre est une fonction, on l'exécute en tant que callback
+    if (typeof param === "function") {
+      return await param();
+    }
+    // Sinon, on considère qu'il s'agit d'un constant et on appelle la méthode par défaut
+    return await this.callIsConnected(param, data);
+  },
+
+  async validateImage(imageInput){
+    const image = await this._validateUploadInput(imageInput, {
+      allowedMimeTypes: ["image/jpeg", "image/png", "image/jpg"],
+      expectedType: "image"
+    });
+    return image;
+  },
+
+  async validateFile(fileInput){
+    const file = await this._validateUploadInput(fileInput, {
+      allowedMimeTypes: ["application/pdf", "text/plain", "text/csv"],
+      expectedType: "file"
+    });
+    return file;
+  },
+
+  async _validateUploadInput(input, { allowedMimeTypes = [], expectedType = "any" }) {
+    if (!input) {
+      throw new ApiValidationError("Le fichier est requis.");
+    }
+  
+    const isNode = typeof window === "undefined" && typeof process !== "undefined";
+    let mimeType = "";
+    let output = input;
+  
+    // Navigateur : File
+    if (typeof File !== "undefined" && input instanceof File) {
+      mimeType = input.type;
+      if (!allowedMimeTypes.includes(mimeType)) {
+        throw new ApiValidationError("Le type du fichier est invalide.");
+      }
+    }
+  
+    // Navigateur : Blob
+    else if (typeof Blob !== "undefined" && input instanceof Blob) {
+      mimeType = input.type;
+      if (!allowedMimeTypes.includes(mimeType)) {
+        throw new ApiValidationError("Le type du fichier est invalide.");
+      }
+  
+      const ext = mimeType.split("/")[1] || "bin";
+      const fileName = `${Date.now()}.${ext}`;
+      output = new File([input], fileName, { type: mimeType });
+    }
+  
+    // Node.js : Buffer
+    else if (isNode && Buffer.isBuffer(input)) {
+      const fileTypeResult = await fileTypeFromBuffer(input);
+      mimeType = fileTypeResult?.mime;
+  
+      if (!fileTypeResult || !allowedMimeTypes.includes(mimeType)) {
+        throw new ApiValidationError("Le type du fichier est invalide.");
+      }
+  
+      // Pour un fichier image, on transforme en stream
+      if (expectedType === "image") {
+        const ext = fileTypeResult.ext;
+        const filename = `${Date.now()}.${ext}`;
+        output = await this._createReadStreamFromBuffer(input, filename, mimeType);
+      }
+    }
+  
+    // Node.js : ReadableStream
+    else if (isNode && input?.readable && typeof input._read === "function") {
+      const previewChunks = [];
+      const tee = await this._passThrough();
+      const resultStream = await this._passThrough();
+  
+      const MAX_BYTES = 4100;
+      let bytesRead = 0;
+  
+      input.on("data", (chunk) => {
+        if (bytesRead < MAX_BYTES) {
+          previewChunks.push(chunk);
+          bytesRead += chunk.length;
+        }
+      });
+  
+      input.pipe(tee).pipe(resultStream);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+  
+      const previewBuffer = Buffer.concat(previewChunks);
+      const fileTypeResult = await fileTypeFromBuffer(previewBuffer);
+      mimeType = fileTypeResult?.mime;
+  
+      if (!fileTypeResult || !allowedMimeTypes.includes(mimeType)) {
+        throw new ApiValidationError("Le type du fichier est invalide.");
+      }
+  
+      resultStream.path = `${Date.now()}.${fileTypeResult.ext}`;
+      resultStream.mimeType = mimeType;
+      output = resultStream;
+    }
+  
+    else {
+      throw new ApiValidationError("Type de fichier non reconnu.");
+    }
+  
+    return output;
+  },
+
+  /**
+ * Transforme un Buffer en ReadableStream équivalent à fs.createReadStream
+ * @param {Buffer} buffer - Le buffer contenant les données binaires
+ * @param {string} filename - Nom de fichier (utilisé dans FormData)
+ * @param {string} mimeType - Type MIME (utilisé dans FormData)
+ * @returns {Object} - { stream, filename, mimeType }
+ */
+  async _createReadStreamFromBuffer(buffer, filename = "file.bin", mimeType = "application/octet-stream") {
+    const stream = await this._bufferToReadable(buffer);
+    stream.path = filename; // 👈 hack pour simuler un vrai fichier ReadStream
+    stream.mimeType = mimeType;
+    return stream;
+  },
+
+  async _bufferToReadable(buffer) {
+    if (typeof window === "undefined") {
+      const { bufferToReadable } = await import("../utils/stream-utils.node.js");
+      return bufferToReadable(buffer);
+    } else {
+      throw new Error("bufferToReadable ne doit pas être appelé dans le navigateur");
+    }
+  },
+  
+  async _passThrough() {
+    if (typeof window === "undefined") {
+      const { createPassThrough } = await import("../utils/stream-utils.node.js");
+      return createPassThrough();
+    } else {
+      throw new Error("passThrough ne doit pas être appelé dans le navigateur");
+    }
+  },
+
+  // async _bufferToReadable(buffer) {
+  //   if (typeof window === "undefined") {
+  //     const { Readable } = await import("stream");
+  //     return Readable.from(buffer);
+  //   } else {
+  //     throw new Error("bufferToReadable ne doit pas être appelé dans le navigateur");
+  //   }
+  // },
+
+  // async _passThrough() {
+  //   if (typeof window === "undefined") {
+  //     const { PassThrough } = await import("stream");
+  //     return new PassThrough();
+  //   } else {
+  //     throw new Error("passThrough ne doit pas être appelé dans le navigateur");
+  //   }
+  // },
+
+  _omitProps(obj, propsToRemove) {
+    if (!obj || typeof obj !== "object") return {};
+  
+    const result = { ...obj };
+    for (const prop of propsToRemove) {
+      delete result[prop];
+    }
+    return result;
+  },
+
+  _pickProps(obj, keys, transforms = {}) {
+    if (!obj || typeof obj !== "object") return {};
+
+    const result = {};
+
+    for (const key of keys) {
+      if (key in obj) {
+        const value = obj[key];
+        if (typeof transforms[key] === "function") {
+          result[key] = transforms[key](value, obj); // (valeur, objet source)
+        } else {
+          result[key] = value;
+        }
+      }
+    }
+
+    return result;
+  },
+
+  _createFilteredProxy(list) {
+    return new Proxy(list, {
+      get(target, prop, receiver) {
+        if (typeof prop === "string" && !isNaN(prop)) {
+          const active = target.filter(n => !n._isDeleted);
+          return active[prop];
+        }
+        if (prop === "length") {
+          return target.filter(n => !n._isDeleted).length;
+        }
+        if (typeof target[prop] === "function") {
+          return (...args) => target.filter(n => !n._isDeleted)[prop](...args);
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+  }
+  
+  
+};
+  

package/src/utils/stream-utils.node.js

@@ -0,0 +1,10 @@
+// utils/stream-utils.node.js
+export async function bufferToReadable(buffer) {
+  const { Readable } = await import("stream");
+  return Readable.from(buffer);
+}
+  
+export async function createPassThrough() {
+  const { PassThrough } = await import("stream");
+  return new PassThrough();
+}

package/src/api/EntityMixin.js

@@ -1,43 +0,0 @@
-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 } });
-    });
-  }
-};
-