@communecter/cocolight-api-client 1.0.9 → 1.0.10

package/src/mixin/DraftStateMixin.js

@@ -0,0 +1,176 @@
+// DraftStateMixin.js
+import { ApiError, ApiValidationError } from "../error.js";
+
+export const DraftStateMixin = {
+
+  /**
+   * Crée un proxy combinant draft + serveur, avec transformations facultatives.
+   * @param {Object} server
+   * @param {Object} draft
+   * @param {Array} allowedFields - champs autorisés dans le draft
+   * @param {Object} [transforms={}] - transformateurs de lecture
+   * @param {Object} [options={}] - options
+   * @returns {Proxy}
+   */
+  createDraftProxy(apiClient, server = {}, draft = {}, allowedFields = [], transforms = {}, options = {}) {
+    return new Proxy({}, {
+      get: (_, prop) => {
+        const val = prop in draft ? draft[prop] : server[prop];
+        const transformer = transforms[prop];
+        return typeof transformer === "function" ? transformer(val) : val;
+      },
+
+      set: (_, prop, value) => {
+        if (!allowedFields.includes(prop)) {
+          const message = `[DraftProxy] Le champ "${prop}" n'est pas autorisé.`;
+          if (options.throwOnError) {
+            throw new ApiValidationError(message, 400, null, {
+              field: prop,
+              value,
+              allowedFields
+            });
+          }
+          apiClient._logger.warn(message);
+          return false;
+        }
+        draft[prop] = value;
+        return true;
+      },
+
+      deleteProperty: (_, prop) => {
+        if (!allowedFields.includes(prop)) return false;
+        delete draft[prop];
+        return true;
+      },
+
+      has: (_, prop) => prop in draft || prop in server,
+      ownKeys: () => [...new Set([...Object.keys(server), ...Object.keys(draft)])],
+      getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true })
+    });
+  },
+
+  _extractWritableFields(schema = {}, data = {}, ctx = { defs: {}, visited: new Set() }) {
+    if (!schema || typeof schema !== "object") return [];
+    if (schema.$id && ctx.visited.has(schema.$id)) return [];
+    if (schema.$id) ctx.visited.add(schema.$id);
+    ctx.defs = schema.$defs || schema.definitions || ctx.defs;
+
+    const fields = [];
+
+    if (schema.$ref) {
+      const refKey = schema.$ref.replace(/^#\/?(\$defs|definitions)\//, "");
+      const resolved = ctx.defs?.[refKey];
+      if (resolved) fields.push(...this._extractWritableFields(resolved, data, ctx));
+    }
+
+    if (schema.allOf) {
+      schema.allOf.forEach(s => fields.push(...this._extractWritableFields(s, data, ctx)));
+    }
+
+    if (schema.if && schema.then) {
+      const condition = schema.if?.properties;
+      let matches = true;
+      if (condition) {
+        for (const key in condition) {
+          const expected = condition[key]?.const;
+          if (data[key] !== expected) {
+            matches = false;
+            break;
+          }
+        }
+      }
+      if (matches && schema.then) {
+        fields.push(...this._extractWritableFields(schema.then, data, ctx));
+      } else if (!matches && schema.else) {
+        fields.push(...this._extractWritableFields(schema.else, data, ctx));
+      }
+    }
+
+    if (schema.properties) {
+      fields.push(...Object.entries(schema.properties)
+        // eslint-disable-next-line no-unused-vars
+        .filter(([_, def]) => def.readOnly !== true && def.const === undefined)
+        .map(([key]) => key));
+    }
+
+    return [...new Set(fields)];
+  },
+
+  buildDraftAndProxy({ data = {}, serverData = null, constant, apiClient, transforms = {}, throwOnError = true, removeFields = [] }) {
+    const constants = Array.isArray(constant) ? constant : [constant];
+    const combinedSchema = {
+      allOf: [],
+      $defs: {}
+    };
+    
+    for (const key of constants) {
+      const sch = apiClient.getRequestSchema(key);
+      if (!sch) throw new ApiError(`Unable to find schema for ${key}.`);
+    
+      // Extraire et fusionner les $defs
+      if (sch.$defs) {
+        for (const [defKey, defVal] of Object.entries(sch.$defs)) {
+          if (combinedSchema.$defs[defKey]) {
+            apiClient._logger.warn(`Duplicate $defs key '${defKey}' from schema '${key}'`);
+          } else {
+            combinedSchema.$defs[defKey] = defVal;
+          }
+        }
+      }
+    
+      combinedSchema.allOf.push(sch);
+    }
+    const draft = {};
+    let allowed = this._extractWritableFields(combinedSchema, data);
+
+    if (data.id && allowed.indexOf("id") === -1) {
+      allowed.push("id");
+    }
+    if (data.slug && allowed.indexOf("slug") === -1) {  
+      allowed.push("slug");
+    }
+
+    allowed = allowed.filter(k => !removeFields.includes(k));
+
+    for (const key of allowed) {
+      const raw = data[key];
+      const transformed = typeof transforms[key] === "function" ? transforms[key](raw, data) : raw;
+      if (transformed !== undefined) draft[key] = transformed;
+    }
+
+    const proxy = this.createDraftProxy(apiClient, serverData, draft, allowed, transforms, { throwOnError });
+
+    return { draft, proxy };
+  },
+
+  extractChangedFieldsFromSchema(apiClient, constant, data = {}, getInitialDraft, removeFields = []) {
+    const schema = apiClient.getRequestSchema(constant);
+    let allowed = this._extractWritableFields(schema, data);
+    const changed = {};
+    const initialDraft = getInitialDraft?.() || {};
+  
+    // on enlève les champs qui ne sont pas dans le draft
+    // ou qui sont dans removeFields
+    allowed = allowed.filter(k => !removeFields.includes(k));
+
+    for (const key of allowed) {
+      // on verifie que le champ existe dans le draft
+      // sinon on ne le prend pas en compte
+
+      if (data[key] === undefined) continue;
+  
+      const current = data[key];
+      const initial = initialDraft[key];
+  
+      const changedValue =
+        JSON.stringify(current) !== JSON.stringify(initial);
+  
+      if (changedValue) {
+        changed[key] = current;
+      }
+    }
+  
+    return Object.keys(changed).length > 0 ? changed : null;
+  }
+  
+};

package/src/mixin/EntityMixin.js

@@ -3,46 +3,107 @@ 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.
+     * Récupère le profil complet de l'organisation.
+     *
+     * @returns {Promise<Object>} Le profil complet.
      */
-  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;
+  async get() {
+    return this.apiClient.safeCall(async () => {
+      const data = await this.getPublicProfile();
+      this._setData(data);
+      return data;
+    });
+  },
+  
+  /**
+   * Mettre à jour les paramètres d'un élément : Mise à jour des paramètres spécifiques d'un élément.
+   * Constant : UPDATE_SETTINGS
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.type - data.type
+   * @param {undefined} data.value - data.value
+   * @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 updateSettings(data = {}) {
+    data.idEntity = this.id;
+    data.typeEntity = this.getEntityType();
+    return this.callIsConnected(() => this.endpointApi.updateSettings(data));
   },
   
   /**
-     * Récupère le profil public de l'entité.
-     * @returns {Promise<Object>} Les données du profil public.
+   * Mettre à jour la description d'un élément : Permet de mettre à jour la description courte et complète d'un élément.
+   * Constant : UPDATE_BLOCK_DESCRIPTION
+   * @param {Object} data - Les données à envoyer.
+   * @param {string} data.descMentions - Mentions dans la description (default: "")
+   * @param {string} data.shortDescription - Courte description
+   * @param {string} data.description - Description complète
+   * @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 updateDescription(data = {}) {
+    data.typeElement = this.getEntityType();
+    data.id = this.id;
+    return this.callIsConnected(() => this.endpointApi.updateBlockDescription(data));
+  },
+    
+  /**
+     * Mettre à jour les informations d'un élément : Permet de mettre à jour les informations générales d'un élément (nom, contacts, etc.).
+     * Constant : UPDATE_BLOCK_INFO
      */
-  async getPublicProfile() {
-    await this.resolveId(this.getEntityType());
-    return this.endpointApi.getElementsAbout({ pathParams: { id: this.id, type: this.getEntityType() } });
+  async updateInfo(data = {}) {
+    data.typeElement = this.getEntityType();
+    data.id = this.id;
+    return this.callIsConnected(() => this.endpointApi.updateBlockInfo(data));
+  },
+    
+  /**
+   * Mettre à jour les réseaux sociaux d'un élément : Permet de mettre à jour les liens vers les réseaux sociaux d'un élément.
+   * Constant : UPDATE_BLOCK_SOCIAL
+   */
+  async updateSocial(data = {}) {
+    data.typeElement = this.getEntityType();
+    data.id = this.id;
+    return this.callIsConnected(() => this.endpointApi.updateBlockSocial(data));
+  },
+    
+  /**
+   * Mettre à jour les localités d'un élément : Permet de mettre à jour l'adresse et les informations géographiques d'un élément.
+   * Constant : UPDATE_BLOCK_LOCALITY
+   */
+  async updateLocality(data = {}) {
+    data.typeElement = this.getEntityType();
+    data.id = this.id;
+    return this.callIsConnected(() => this.endpointApi.updateBlockLocality(data));
+  },
+    
+  /**
+   * Mettre à jour le slug d'un élément : Permet de mettre à jour le slug pour une URL simplifiée.
+   * Constant : UPDATE_BLOCK_SLUG
+   */
+  async updateSlug({ slug }) {
+    try {
+      await this.endpointApi.check({ type: this.getEntityType(), id: this.id, slug });
+    } catch (error) {
+      if(error instanceof ApiResponseError) {
+        throw new ApiResponseError("Erreur lors de la vérification du slug.", error.status, error.data);
+      }
+      throw error;
+    }
+    return this.callIsConnected(() => this.endpointApi.updateBlockSlug({ typeElement: this.getEntityType(), id: this.id, slug }));
+  },
+    
+  /**
+   * Mettre à jour l'image de profil : Permet de mettre à jour l'image de profil d'un utilisateur ou d'une entité.
+   * Constant : PROFIL_IMAGE
+   */
+  async updateImageProfil({ profil_avatar: image  }) {
+    image = await this.validateImage(image);
+    const data = { pathParams: { folder: this.getEntityType(), ownerId: this.id },  profil_avatar: image };
+    return this.callIsConnected(() => this.endpointApi.profilImage(data));
   }
-
 };
   

package/src/mixin/MutualEntityMixin.js

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

package/src/mixin/NewsMixin.js

@@ -1,8 +1,42 @@
-// eslint-disable-next-line no-unused-vars
 import { ApiResponseError } from "../error.js";
 
 // NewsMixin.js
 export const NewsMixin = {
+  /**
+   * Récupérer les actualités : Récupère la liste d’actualités selon plusieurs critères.
+   * Constant : GET_NEWS
+   * @param {Object} data - Les données à envoyer.
+   * @param {number} data.dateLimit - Limite de date timestamp ou 0 (default: 0)
+   * @param {object} data.search - data.search
+   * @param {string} data.search.name - Nom ou terme recherché (default: "")
+   * @param {number} data.indexStep - Nombre de résultats par page (default: 12)
+   * @returns {Promise<Object>} - Les données de réponse.
+   * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
+   * @throws {Error} - En cas d'erreur inattendue.
+   */
+  async getNews(data = {}) {
+    data.pathParams = { type: this.getEntityType(), id: this.id };
+    const arrayObjetNews =  await this.endpointApi.getNews(data);
+    if(!Array.isArray(arrayObjetNews)){
+      throw new ApiResponseError("Erreur lors de la récupération des actualités.", 500, arrayObjetNews);
+    }
+    const rawNewsList = arrayObjetNews.map((newsData) =>
+      this.deps.News.fromServerData(newsData, this, { User : this.deps.User, EndpointApi: this.deps.EndpointApi })
+    );
+    return this._createFilteredProxy(rawNewsList);
+  },
 
+  async news(newsData) {
+    try {
+      const news = new this.deps.News(this, newsData, { User: this.deps.User, EndpointApi : this.deps.EndpointApi });
+      if (newsData.id) {
+        await news.get();
+      }
+      return news;
+    } catch (error) {
+      this.apiClient._logger.error(`[Api.${this.getEntityType()}.news] Erreur lors de la création d'une instance news :`, error.message);
+      throw error;
+    }
+  }
 };
   

package/src/mixin/UtilMixin.js

@@ -1,3 +1,4 @@
+import ObjectID from "bson-objectid";
 import { fileTypeFromBuffer } from "file-type";
 
 import { ApiAuthenticationError, ApiValidationError } from "../error.js";
@@ -5,6 +6,16 @@ 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);
@@ -13,6 +24,17 @@ export const UtilMixin = {
     });
   },
 
+  /**
+   * 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.");
@@ -20,6 +42,17 @@ export const UtilMixin = {
     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.");
@@ -31,6 +64,17 @@ export const UtilMixin = {
     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.");
@@ -239,8 +283,12 @@ export const UtilMixin = {
         return Reflect.get(target, prop, receiver);
       }
     });
-  }
+  },
   
+  _newId() {
+    const newId = new ObjectID();
+    return newId.toString();
+  }
   
 };