@communecter/cocolight-api-client 1.0.19 → 1.0.21

package/src/mixin/MutualEntityMixin.js

@@ -1,269 +0,0 @@
-import { ApiResponseError } from "../error.js";
-
-// MutualEntityMixin.js
-export const MutualEntityMixin = {
-  /**
-     * 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) {
-    if (!this.id && this.slug) {
-      try {
-        const data = await this.endpointApi.getElementsKey({
-          pathParams:{
-            slug: this.slug
-          }
-        });
-        if(data?.contextId && data?.contextType === type) {
-          this._id(data.contextId);
-        } else {
-          throw new ApiResponseError(`Le slug ${this.slug} ne correspond pas à un ${type}`, 200, data);
-        }
-      } catch (error) {
-        if(error instanceof ApiResponseError) {
-          if(error?.responseData?.contextType !== type) {
-            throw error;
-          } else {
-            throw new ApiResponseError(`Impossible de récupérer l'identifiant pour le slug ${this.slug}`, error.status, error.responseData);
-          }
-        } else {
-          throw error;
-        }
-      }
-    }
-    return this.id;
-  },
-  
-  /**
-     * Récupère le profil public de l'entité.
-     * @returns {Promise<Object>} Les données du profil public.
-     */
-  async getPublicProfile() {
-    await this.resolveId(this.getEntityType());
-    return this.endpointApi.getElementsAbout({ pathParams: { id: this.id, type: this.getEntityType() } });
-  },
-
-  /**
- * Récupère la classe d'entité et ses dépendances à partir du type d'entité.
- * 
- * @param {string} entityType - Le type d'entité.
- * @return {{ entityClass: Function, deps: Object } | null}
- */
-  _getEntityMeta(entityType) {
-    const selfClass = this.constructor;
-    const selfTag = this.__entityTag;
-  
-    const commonDeps = {
-      EndpointApi: this.deps.EndpointApi,
-      User: selfTag === "User" ? selfClass : this.deps.User,
-      Organization: selfTag === "Organization" ? selfClass : this.deps.Organization,
-      Project: selfTag === "Project" ? selfClass : this.deps.Project,
-      Event: selfTag === "Event" ? selfClass : this.deps.Event,
-      Poi: selfTag === "Poi" ? selfClass : this.deps.Poi,
-      Badge: selfTag === "Badge" ? selfClass : this.deps.Badge,
-      News: selfTag === "News" ? selfClass : this.deps.News
-    };
-  
-    const map = {
-      citoyens:     { entityClass: commonDeps.User,         deps: commonDeps },
-      organizations:{ entityClass: commonDeps.Organization, deps: commonDeps },
-      projects:      { entityClass: commonDeps.Project,      deps: commonDeps },
-      events:       { entityClass: commonDeps.Event,        deps: { ...commonDeps, Badge: undefined } },
-      poi:          { entityClass: commonDeps.Poi,          deps: { ...commonDeps, Badge: undefined, News: undefined } },
-      news:         { entityClass: commonDeps.News,         deps: { ...commonDeps } },
-      badges:       { entityClass: commonDeps.Badge,        deps: { 
-        EndpointApi: commonDeps.EndpointApi, 
-        User: commonDeps.User, 
-        Organization: commonDeps.Organization, 
-        Project: commonDeps.Project 
-      } }
-    };
-  
-    return map[entityType] || null;
-  },
-
-  /**
- * Lier des données d'entité à une instance d'entité.
- * 
- * @param {string} entityType - Le type d'entité (ex : "citoyens", "organisations", "projets").
- * @param {Object} entityData - Les données de l'entité à lier.
- * @return {Object} L'entité liée.
- */
-  linkEntity(entityType, entityData) {
-    const meta = this._getEntityMeta(entityType);
-    if (!meta) return entityData;
-    return meta.entityClass.fromServerData(entityData, this, meta.deps);
-  },
-
-  /**
- * Récupère et lie une entité à partir de son ID.
- * 
- * @param {string} entityType - Le type d'entité.
- * @param {string} entityId - L'identifiant de l'entité.
- * @param {Object} [options] - Options supplémentaires :
- * @param {boolean} [options.skipGet] - Si true, ne pas appeler `get()` sur l'entité.
- * @return {Promise<Object|null>} L'entité liée ou null.
- */
-  async linkEntityById(entityType, entityId, options = {}) {
-    const meta = this._getEntityMeta(entityType);
-    if (!meta) return null;
-    const entity = new meta.entityClass(this, { id: entityId }, meta.deps);
-    if(options?.skipGet) return entity;
-    await entity.get();
-    return entity;
-  },
-
-
-  /**
-   * Lie des entités présentes dans `this.serverData` à partir de leurs IDs,
-   * en les filtrant dynamiquement et en optionnellement les transformant.
-   *
-   * @param {string} entityType - Le type d'entité (ex : "badges", "citoyens", etc.).
-   * @param {Object} filters - Clés/valeurs de filtres dynamiques. Les valeurs peuvent être :
-   *   - un littéral (comparaison stricte ou intelligente selon le type),
-   *   - une chaîne (utilise `includes` insensible à la casse),
-   *   - une RegExp (appliquée si la valeur est une chaîne),
-   *   - une fonction `(value) => boolean`.
-   * @param {Object} [options] - Options supplémentaires :
-   * @param {string} [options.key] - Le champ de `this.serverData` à utiliser (par défaut = entityType).
-   * @param {Function} [options.mapFn] - Fonction de transformation `(entity) => any` appliquée au résultat.
-   *
-   * @return {Promise<Array<Object>>} Liste des entités liées, filtrées et éventuellement transformées.
-   *
-   * @example
-   * // Tous les badges avec `name` contenant "codev"
-   * const badges = await this.linkEntitiesFromServerData("badges", { name: "codev" });
-   *
-   * @example
-   * // Badges non expirés et visibles
-   * const badges = await this.linkEntitiesFromServerData("badges", {
-   *   expiredOn: false,
-   *   show: "true"
-   * });
-   *
-   * @example
-   * // Badges émis après 2023
-   * const badges = await this.linkEntitiesFromServerData("badges", {
-   *   issuedOn: (v) => new Date(v) >= new Date("2023-01-01")
-   * });
-   *
-   * @example
-   * // Extraire uniquement les noms des badges
-   * const namesOnly = await this.linkEntitiesFromServerData("badges", {}, {
-   *   mapFn: (badge) => badge.meta.name
-   * });
-   */
-  async linkEntitiesFromServerData(entityType, filters = {}, options = {}) {
-    const key = options.key || entityType;
-    const mapFn = typeof options.mapFn === "function" ? options.mapFn : null;
-
-    const isTruthy = (v) => v === true || v === "true";
-    const isFalsy = (v) => v === false || v === "false";
-
-    const data = this.serverData?.[key];
-    const result = [];
-
-    if (data && typeof data === "object" && Object.keys(data).length > 0) {
-      for (const id of Object.keys(data)) {
-        const meta = data[id];
-
-        const matches = Object.entries(filters).every(([key, expected]) => {
-          const actual = meta[key];
-
-          if (typeof expected === "function") {
-            try {
-              return expected(actual);
-            } catch (err) {
-              console.warn(`Erreur dans le filtre personnalisé pour ${key}`, err);
-              return false;
-            }
-          }
-
-          if (expected instanceof RegExp) {
-            return typeof actual === "string" && expected.test(actual);
-          }
-
-          if (typeof expected === "string" && typeof actual === "string") {
-            return actual.toLowerCase().includes(expected.toLowerCase());
-          }
-
-          if (isTruthy(expected)) return isTruthy(actual);
-          if (isFalsy(expected)) return isFalsy(actual);
-
-          if (
-            typeof actual === "string" &&
-            typeof expected === "string" &&
-            !isNaN(Date.parse(actual)) &&
-            !isNaN(Date.parse(expected))
-          ) {
-            return new Date(actual).getTime() === new Date(expected).getTime();
-          }
-
-          return actual === expected;
-        });
-
-        if (!matches) continue;
-
-        try {
-          const entity = await this.linkEntityById(entityType, id);
-          if (entity) {
-            entity.meta = meta;
-            result.push(mapFn ? mapFn(entity) : entity);
-          }
-        } catch (error) {
-          this._logger?.error?.(`Erreur lors de la récupération de l'entité ${entityType} (${id}) :`, error);
-        }
-      }
-    }
-    return result;
-  },
-
-
-  entityInstanceData(entityType, entityData) {
-    const meta = this._getEntityMeta(entityType);
-    const selfKey = this.__entityTag; // ex: "User", "Organization", etc.
-    const selfClass = this.constructor;
-
-    // pour citoyens la signature est différentes
-    return new meta.entityClass(this, entityData, {
-      [selfKey]: selfClass,
-      ...meta.deps
-    });
-  },
-
-  /**
-   * Crée une instance d'entité, et déclenche get() si certaines propriétés sont présentes.
-   * TODO : pas finis
-   * @param {string} entityType
-   * @param {Object} entityData
-   * @return {Promise<Object>}
-   */
-  async entity(entityType, entityData = {}) {
-    try {
-      const entity = this.entityInstanceData(entityType, entityData);
-
-      const fetchKeysByEntity = {
-        citoyens: ["id", "slug"],
-        organisations: ["id", "slug"],
-        projets: ["id", "slug"],
-        events: ["id", "slug"],
-        poi: ["id", "slug"],
-        news: ["id"],
-        badges: ["id"],
-      };
-
-      const fetchKeys = fetchKeysByEntity[entityType];
-
-      if (fetchKeys && this._hasAtLeastOne(entityData, fetchKeys)) {
-        await entity.get();
-      }
-
-      return entity;
-    } catch (error) {
-      this.apiClient._logger.error(`[Api.${this.__entityTag}.${entityType}] Erreur lors de la création d'une instance ${entityType} :`, error.message);
-      throw error;
-    }
-  }
-  
-};

package/src/mixin/UtilMixin.js

@@ -1,300 +0,0 @@
-import ObjectID from "bson-objectid";
-// import { fileTypeFromBuffer } from "file-type";
-import pkg from "file-type";
-const { fromBuffer } = pkg;
-
-import { ApiAuthenticationError, ApiValidationError } from "../error.js";
-
-// UtilMixin.js
-export const UtilMixin = {
-
-  /**
-   * Appelle une méthode de l'API.
-   * 
-   * @param {string} constant - Le nom de la méthode à appeler.
-   * @param {object} data - Les données à passer à la méthode.
-   * @returns {Promise<any>} - La promesse de la méthode appelée.
-   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiClientError} - Si l'utilisateur n'est pas authentifié.
-   */
-  async call(constant, data = {}) {
-    return this.apiClient.safeCall(async () => {
-      const response = await this.apiClient.callEndpoint(constant, data);
-      this.apiClient.checkAndThrowApiResponseError(response);
-      return response.data;
-    });
-  },
-
-  /**
-   * Appelle une méthode de l'API si l'utilisateur n'est pas connecté.
-   * 
-   * @param {string} constant - Le nom de la méthode à appeler.
-   * @param {object} data - Les données à passer à la méthode.
-   * @returns {Promise<any>} - La promesse de la méthode appelée.
-   * @throws {ApiAuthenticationError} - Si l'utilisateur est connecté.
-   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
-   */
-  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);
-  },
-
-  /**
-   * Appelle une méthode de l'API si l'utilisateur est connecté.
-   * 
-   * @param {string|function} param - Le nom de la méthode à appeler ou une fonction de rappel.
-   * @param {object} data - Les données à passer à la méthode.
-   * @returns {Promise<any>} - La promesse de la méthode appelée.
-   * @throws {ApiAuthenticationError} - Si l'utilisateur n'est pas connecté.
-   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
-   */
-  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);
-  },
-
-  /**
-   * Appelle une méthode de l'API si l'utilisateur est lui-même.
-   * 
-   * @param {string|function} param - Le nom de la méthode à appeler ou une fonction de rappel.
-   * @param {object} data - Les données à passer à la méthode.
-   * @returns {Promise<any>} - La promesse de la méthode appelée.
-   * @throws {ApiAuthenticationError} - Si l'utilisateur n'est pas lui-même.
-   * @throws {ApiValidationError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiResponseError} - Si une erreur se produit lors de l'appel de l'API.
-   * @throws {ApiClientError} - Si une erreur se produit lors de l'appel de l'API.
-   */
-  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 fromBuffer(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 fromBuffer(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;
-  },
-
-  _hasAtLeastOne(obj, keys = []) {
-    return keys.some((key) => key in obj && obj[key] != null);
-  },
-
-  _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);
-      }
-    });
-  },
-  
-  _newId() {
-    const newId = new ObjectID();
-    return newId.toString();
-  }
-  
-};
-