@communecter/cocolight-api-client 1.0.6 → 1.0.8

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;
+    });
+  }
+}

package/src/api/UserMixin.js

@@ -0,0 +1,59 @@
+// eslint-disable-next-line no-unused-vars
+import { ApiResponseError } from "../error.js";
+
+// UserMixin.js
+export const UserMixin = {
+
+  /**
+   * Récupérer les informations utilisateur : Récupère les informations du profil utilisateur pour un token donné.
+   * Constant : ME_INFO_URL
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async _meInfoUrl() {
+    return this.callIsConnected("ME_INFO_URL");
+  },
+
+  /**
+   * Changer le mot de passe : Permet de changer le mot de passe d'un utilisateur.
+   * Constant : CHANGE_PASSWORD
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.oldPassword - Ancien mot de passe
+   * @param {string} data.newPassword - Nouveau mot de passe
+   * @param {string} data.newPassword2 - Confirmation du nouveau mot de passe
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async _changePassword(data = {}) {
+    if(data.userId) {
+      delete data.userId;
+    }
+    if(data.mode) {
+      delete data.mode;
+    }
+    return this.callIsConnected("CHANGE_PASSWORD", data);
+  },
+
+  /**
+   * Supprimer un compte : Permet de supprimer un compte utilisateur.
+   * Constant : DELETE_ACCOUNT
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.reason - Raison de la suppression (default: "")
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {ApiAuthenticationError} - En cas d'erreur d'authentification.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async _deleteAccount(data = {}) {
+    if (data.pathParams) {
+      delete data.pathParams;
+    }
+    return this.callIsConnected("DELETE_ACCOUNT", data);
+  }
+
+};
+  

package/src/api/UtilMixin.js

@@ -0,0 +1,82 @@
+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(image) {
+    if (!image) {
+      throw new ApiValidationError("Le fichier est requis.");
+    }
+    let mimeType = "";
+    
+    // Vérification en navigateur : File et Blob
+    if (typeof File !== "undefined" && image instanceof File) {
+      mimeType = image.type;
+      if (!mimeType || !mimeType.startsWith("image/") || !["image/jpg", "image/jpeg", "image/png"].includes(mimeType)) {
+        throw new ApiValidationError("Le fichier doit être une image valide.");
+      }
+    } else if (typeof Blob !== "undefined" && image instanceof Blob) {
+      mimeType = image.type;
+      // rajouter un name au blob avce timestamp et la bonne extension
+      const fileName = `${Date.now()}.${mimeType.split("/")[1]}`;
+      image = new File([image], fileName, { type: mimeType });
+      console.log(fileName);
+
+      if (!mimeType || !mimeType.startsWith("image/") || !["image/jpg", "image/jpeg", "image/png"].includes(mimeType)) {
+        throw new ApiValidationError("Le fichier doit être une image valide (jpg ou png).");
+      }
+    }
+    // Vérification en Node : image peut être un Buffer
+    else if (typeof Buffer !== "undefined" && Buffer.isBuffer(image)) {
+      const fileTypeResult = await fileTypeFromBuffer(image);
+      if (!fileTypeResult || !fileTypeResult.mime.startsWith("image/") || !["image/jpg", "image/jpeg", "image/png"].includes(fileTypeResult.mime)) {
+        throw new ApiValidationError("Le fichier doit être une image valide.");
+      }
+      mimeType = fileTypeResult.mime;
+    } else {
+      throw new ApiValidationError("Le fichier doit être de type File (navigateur) ou Buffer (Node).");
+    }
+    return image;
+  }
+};
+