@communecter/cocolight-api-client 1.0.17 → 1.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.17",
+    "version": "1.0.19",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",
@@ -23,7 +23,7 @@
         "build:browser": "webpack --config webpack.config.standalone.js",
         "build:node": "webpack --config webpack.config.node.js",
         "build:esm": "webpack --config webpack.config.esm.mjs",
-        "build": "npm run generate:module:publish && npm run generate:doc && npm run lint:fix && npm run build:browser && npm run build:node && npm run build:esm",
+        "build": "npm run generate:module:publish && npm run generate:methodeapi && npm run generate:doc && npm run lint:fix && npm run build:browser && npm run build:node && npm run build:esm",
         "build:publish": "npm run build && npm publish --access public",
         "generate:module": "node ./scripts/transform-json-module.js",
         "generate:module:publish": "node ./scripts/transform-json-module.publish.js",

package/src/Api.js

@@ -1,7 +1,10 @@
 // Api.js
+import { Badge } from "./api/Badge.js";
 import EndpointApi from "./api/EndpointApi.js";
+import { Event } from "./api/Event.js";
 import { News } from "./api/News.js";
 import { Organization } from "./api/Organization.js";
+import { Poi } from "./api/Poi.js";
 import { Project } from "./api/Project.js";
 import { User } from "./api/User.js";
 import { UserApi } from "./api/UserApi.js";
@@ -117,9 +120,9 @@ export default class Api {
   async user(userData) {
     try {
       if (!userData.id && !userData.slug) {
-        return new User(this._client, userData, { EndpointApi, Organization, Project, News });
+        return new User(this._client, userData, { EndpointApi, Organization, Project, Event, Poi, Badge, News });
       } else {
-        const user = new User(this._client, userData, { EndpointApi, Organization, Project, News });
+        const user = new User(this._client, userData, { EndpointApi, Organization, Project, Event, Poi, Badge, News });
         await user.get();
         return user;
       }
@@ -139,7 +142,7 @@ export default class Api {
    */
   async organization(organizationData) {
     try {
-      const organization = new Organization(this._client, organizationData, { EndpointApi, User, Project, News });
+      const organization = new Organization(this._client, organizationData, { EndpointApi, User, Project, Event, Poi, Badge, News });
       if (!organizationData.id && !organizationData.slug) {
         throw new Error("Vous devez fournir un id ou un slug pour créer une instance Organization.");
       }
@@ -160,7 +163,7 @@ export default class Api {
    */
   async project(projectData) {
     try {
-      const project = new Project(this._client, projectData, { User, News, EndpointApi });
+      const project = new Project(this._client, projectData, { EndpointApi, User, Event, Poi, Badge, News });
       if (!projectData.id && !projectData.slug) {
         throw new Error("Vous devez fournir un id ou un slug pour créer une instance Project.");
       }

package/src/ApiClient.js

@@ -12,6 +12,7 @@ import pino from "pino";
 import MongoID from "./EJSONType.js";
 import endpointsJson from "./endpoints.module.js";
 import { ApiClientError, ApiResponseError, ApiValidationError, CircuitBreakerError } from "./error.js";
+import { MultiServerTokenStorageStrategy } from "./utils/MultiServerTokenStorageStrategy.js";
 import { MemoryStorageStrategy } from "./utils/TokenStorage.js";
 
 
@@ -150,6 +151,10 @@ export default class ApiClient extends EventEmitter {
     this._accessToken = null;
     this._refreshToken = null;
 
+    if (tokenStorageStrategy instanceof MultiServerTokenStorageStrategy) {
+      tokenStorageStrategy.use(this._baseURL);
+    }
+    
     this._tokenStorage = tokenStorageStrategy || new MemoryStorageStrategy();
 
     if (
@@ -649,7 +654,7 @@ export default class ApiClient extends EventEmitter {
       if (!valid) {
         const errorMessages = this._ajvErrorHuman(validatePathParams.errors);
         this.emit("validationError", { stage: "pathParams", errors: validatePathParams.errors });
-        throw new ApiValidationError("Path parameter validation failed.", 400, errorMessages, validatePathParams.errors);
+        throw new ApiValidationError(`callEndpoint: ${constant} -  Path parameter validation failed.`, 400, errorMessages, validatePathParams.errors);
       }
   
       resolvedParams = this._resolveSpecialValuesInPlace(pathParams);
@@ -678,7 +683,7 @@ export default class ApiClient extends EventEmitter {
       if (!valid) {
         const errorMessages = validateRequest.errors ? this._ajvErrorHuman(validateRequest.errors) : [];
         this.emit("validationError", { stage: "request", errors: validateRequest.errors });
-        throw new ApiValidationError("Request validation failed.", 400, errorMessages , validateRequest.errors);
+        throw new ApiValidationError(`callEndpoint: ${constant} - Request validation failed.`, 400, errorMessages , validateRequest.errors);
       }
 
       data = this._resolveSpecialValuesInPlace(cleanedData, resolvedParams);
@@ -1440,7 +1445,7 @@ export default class ApiClient extends EventEmitter {
   /**
  * Liste des champs de date à normaliser.
  */
-  _dateFields = ["modified", "created", "updated", "birthDate", "lastLoginDate", "startDate", "endDate", "date"];
+  _dateFields = ["modified", "created", "updated", "birthDate", "lastLoginDate", "startDate", "endDate", "date", "issuedOn"];
 
   /**
  * Normalise récursivement un objet, un tableau ou une valeur simple.

package/src/api/Badge.js

@@ -0,0 +1,117 @@
+import BaseEntity from "./BaseEntity.js";
+
+export class Badge extends BaseEntity {
+  static entityType = "badges";
+
+  static SCHEMA_CONSTANTS = [
+    "ADD_BADGES",
+  ];
+
+  static ADD_BLOCKS = new Map([
+    ["ADD_BADGES", "addBadges"]
+  ]);
+
+  static UPDATE_BLOCKS = new Map([
+  ]);
+
+  defaultFields = {
+
+  };
+
+  removeFields = [];
+
+  transforms = {
+
+  };
+
+  async _add(payload) {
+    payload.id = this._newId?.();
+    if (payload.slug) delete payload.slug;
+
+    for (const [constant, methodName] of Badge.ADD_BLOCKS) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => {}
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        const data = await this[methodName](blockData);
+        if (!this.id && data?.map?.id) {
+          this._draftData.id = data.map.id;
+          this._draftData.slug = data.map.slug;
+        }
+      }
+    }
+  }
+
+  async _update(payload) {
+    if (payload.id) delete payload.id;
+    let hasChanged = false;
+
+    for (const [constant, methodName] of Badge.UPDATE_BLOCKS) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => this.initialDraftData,
+        this.removeFields
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        await this[methodName](blockData);
+        hasChanged = true;
+      }
+    }
+
+    return hasChanged;
+  }
+
+  async getOrganizations() {
+    throw new Error(`getOrganizations n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getProjects() {
+    throw new Error(`getProjects n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getEvents() {
+    throw new Error(`getEvents n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getPois() {
+    throw new Error(`getPois n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getBadgesIssuer() {
+    throw new Error(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getNews() {
+    throw new Error(`getNews n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getSubscribers() {
+    throw new Error(`getSubscribers n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async project() {
+    throw new Error(`project n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async poi() {
+    throw new Error(`poi n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async event() {
+    throw new Error(`event n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async badge() {
+    throw new Error(`badge n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async news() {
+    throw new Error(`news n'existe pas dans ${this.constructor.name}`);
+  }
+
+}

package/src/api/BaseEntity.js

@@ -0,0 +1,162 @@
+// BaseEntity.js
+import { ApiError } from "../error.js";
+import { DraftStateMixin } from "../mixin/DraftStateMixin.js";
+import { EntityMixin } from "../mixin/EntityMixin.js";
+import { MutualEntityMixin } from "../mixin/MutualEntityMixin.js";
+import { UtilMixin } from "../mixin/UtilMixin.js";
+
+export class BaseEntity {
+  _draftData = {};
+  _initialDraftData = {};
+  _serverData = null;
+  _calledFromSave = false;
+
+  constructor(parent, data = {}, deps = {}, config = {}) {
+    this.__entityTag = config.entityTag || this.constructor.name || "BaseEntity";
+    this.deps = deps;
+
+    this.EndpointApiClass = deps.EndpointApi;
+
+    if (parent?.__entityTag === "ApiClient") {
+      this.apiClient = parent;
+      this.parent = null;
+    } else if (parent?.apiClient) {
+      this.apiClient = parent.apiClient;
+      this.parent = parent;
+    } else {
+      throw new ApiError("Parent invalide ou ApiClient manquant.");
+    }
+
+    this.endpointApi = typeof deps.EndpointApi === "function"
+      ? new deps.EndpointApi(this.apiClient)
+      : deps.EndpointApi;
+
+    this._serverData = null;
+
+    const { draft, proxy } = this._buildDraftAndProxy({
+      data: { ...data, ...this.defaultFields },
+      serverData: this._serverData,
+      constant: this.constructor.SCHEMA_CONSTANTS,
+      apiClient: this.apiClient,
+      transforms: this.transforms,
+      removeFields: this.removeFields
+    });
+
+    this._initialDraftData = JSON.parse(JSON.stringify(draft));
+    this._draftData = draft;
+    this.data = proxy;
+  }
+
+  get id() {
+    return this._draftData.id || null;
+  }
+
+  _id(newId) {
+    this._draftData.id = newId;
+  }
+
+  get isConnected() {
+    return this.apiClient.isConnected;
+  }
+
+  get userId() {
+    return this.apiClient.userId;
+  }
+
+  get draftData() {
+    return this._draftData;
+  }
+
+  get initialDraftData() {
+    return this._initialDraftData;
+  }
+
+  get serverData() {
+    return this._serverData;
+  }
+
+  get isMe() {
+    return this.isConnected && this.userId === this.parent?.id;
+  }
+
+  getEntityType() {
+    return this.constructor.entityType;
+  }
+
+  _setData(newData) {
+    this._serverData = { ...newData };
+
+    const { draft, proxy } = this._buildDraftAndProxy({
+      data: { ...newData, ...this.defaultFields },
+      serverData: this._serverData,
+      constant: this.constructor.SCHEMA_CONSTANTS,
+      apiClient: this.apiClient,
+      transforms: this.transforms,
+      removeFields: this.removeFields
+    });
+    this._initialDraftData = JSON.parse(JSON.stringify(draft));
+    this._draftData = draft;
+    this.data = proxy;
+  }
+
+  async refresh() {
+    if (!this.id) throw new ApiError("Impossible de rafraîchir sans ID.");
+    return this.get();
+  }
+
+  async save() {
+    if (!this.isConnected) throw new ApiError("Non connecté.");
+    this._calledFromSave = true;
+    try {
+      const payload = { ...this._draftData };
+
+      if (!this.id && typeof this._add === "function") {
+        await this._add(payload);
+        return await this.refresh();
+      } else if (typeof this._update === "function") {
+        const hasChanged = await this._update(payload);
+        if (hasChanged) return await this.refresh();
+      }
+
+      return this._serverData;
+    } finally {
+      this._calledFromSave = false;
+    }
+  }
+
+  static fromServerData(data, parent, deps) {
+    const instance = new this(parent, {}, deps);
+    instance._serverData = { ...data };
+
+    const { draft, proxy } = instance._buildDraftAndProxy({
+      data: { ...data, ...instance.defaultFields },
+      serverData: instance._serverData,
+      constant: this.SCHEMA_CONSTANTS,
+      apiClient: instance.apiClient,
+      transforms: instance.transforms,
+      removeFields: instance.removeFields
+    });
+
+    instance._draftData = draft;
+    instance.data = proxy;
+    return instance;
+  }
+
+  hasChanges() {
+    return JSON.stringify(this._draftData) !== JSON.stringify(this._initialDraftData);
+  }
+
+  defaultFields = {};
+  removeFields = [];
+  transforms = {};
+}
+
+Object.assign(
+  BaseEntity.prototype,
+  DraftStateMixin,
+  EntityMixin,
+  MutualEntityMixin,
+  UtilMixin
+);
+
+export default BaseEntity;

package/src/api/EndpointApi.js

@@ -210,7 +210,7 @@ class EndpointApi {
    * Constant : UPDATE_BLOCK_DESCRIPTION
    * @param {object} data - data
    * @param {"descriptions"} data.block - Nom du bloc à mettre à jour (doit être 'descriptions') (default: "descriptions")
-   * @param {"citoyens" | "projects" | "organizations"} data.typeElement - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
+   * @param {"citoyens" | "projects" | "organizations" | "poi"} data.typeElement - Type d'élément (citoyens, projects, organizations, poi) (default: "citoyens")
    * @param {string} data.id - ID de l'élément concerné
    * @param {string | null} data.scope - Périmètre de mise à jour (default: "")
    * @param {string} data.descMentions - Mentions dans la description (default: "")
@@ -230,7 +230,7 @@ class EndpointApi {
    * Constant : UPDATE_BLOCK_INFO
    * @param {object} data - data
    * @param {"info"} data.block - Nom du bloc à mettre à jour (doit être 'info') (default: "info")
-   * @param {"citoyens" | "projects" | "organizations"} data.typeElement - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
+   * @param {"citoyens" | "projects" | "organizations" | "poi"} data.typeElement - Type d'élément (citoyens, projects, organizations, poi) (default: "citoyens")
    * @param {string} data.id - ID de l'élément concerné
    * @param {string} data.scope - Périmètre de mise à jour (default: "")
    * @returns {Promise<Object>} - Les données de réponse.
@@ -273,7 +273,7 @@ class EndpointApi {
    * Constant : UPDATE_BLOCK_LOCALITY
    * @param {object} data - data
    * @param {"localities"} data.block - Nom du bloc à mettre à jour (doit être 'localities') (default: "localities")
-   * @param {"citoyens" | "projects" | "organizations"} data.typeElement - Type d'élément (default: "citoyens")
+   * @param {"citoyens" | "projects" | "organizations" | "poi"} data.typeElement - Type d'élément (default: "citoyens")
    * @param {string} data.id - ID de l'élément concerné
    * @param {string} data.scope - Périmètre de mise à jour (default: "")
    * @param {object} data.geo - Coordonnées géographiques
@@ -312,7 +312,7 @@ class EndpointApi {
    * Constant : UPDATE_BLOCK_SLUG
    * @param {object} data - data
    * @param {"info"} data.block - Nom du bloc à mettre à jour (doit être 'info') (default: "info")
-   * @param {"citoyens" | "projects" | "organizations"} data.typeElement - Type d'élément (citoyens, projects, organizations) (default: "citoyens")
+   * @param {"citoyens" | "projects" | "organizations" | "poi"} data.typeElement - Type d'élément (citoyens, projects, organizations, poi) (default: "citoyens")
    * @param {string} data.id - ID de l'élément concerné
    * @param {string} data.scope - data.scope (default: "")
    * @param {string} data.slug - Slug simplifié pour URL
@@ -348,7 +348,7 @@ class EndpointApi {
    * @param {object} data - data
    * @param {any} data.profil_avatar - Fichier image de profil au format binaire
    * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "projects" | "organizations"} data.pathParams.folder - Type d'entité (default: "citoyens")
+   * @param {"citoyens" | "projects" | "organizations" | "events" | "poi"} data.pathParams.folder - Type d'entité (default: "citoyens")
    * @param {string} data.pathParams.ownerId - ID de l'utilisateur ou de l'entité
    * @returns {Promise<Object>} - Les données de réponse.
    * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.
@@ -365,7 +365,7 @@ class EndpointApi {
    * @param {object} data - data
    * @param {"ficheInfoElement"} data.tpl - Template utilisé (ex: ficheInfoElement) (default: "ficheInfoElement")
    * @param {object} data.pathParams - data.pathParams
-   * @param {"citoyens" | "projects" | "organizations"} data.pathParams.type - Type d'entité (default: "citoyens")
+   * @param {"citoyens" | "projects" | "organizations" | "events" | "poi" | "badges"} data.pathParams.type - Type d'entité (default: "citoyens")
    * @param {string} data.pathParams.id - ID de l'utilisateur ou de l'entité
    * @returns {Promise<Object>} - Les données de réponse.
    * @throws {ApiResponseError} - En cas d'erreur détectée dans la réponse.

package/src/api/Event.js

@@ -0,0 +1,144 @@
+import BaseEntity from "./BaseEntity.js";
+
+export class Event extends BaseEntity {
+  static entityType = "events";
+
+  static SCHEMA_CONSTANTS = [
+    "ADD_EVENT",
+    // "UPDATE_BLOCK_DESCRIPTION",
+    // "UPDATE_BLOCK_INFO",
+    // "UPDATE_BLOCK_SOCIAL",
+    // "UPDATE_BLOCK_LOCALITY",
+    // "UPDATE_BLOCK_SLUG",
+    // "PROFIL_IMAGE"
+  ];
+
+  static ADD_BLOCKS = new Map([
+    ["ADD_EVENT", "addEvent"]
+  ]);
+
+  static UPDATE_BLOCKS = new Map([
+    // ["UPDATE_BLOCK_DESCRIPTION", "updateDescription"],
+    // ["UPDATE_BLOCK_INFO", "updateInfo"],
+    // ["UPDATE_BLOCK_SOCIAL", "updateSocial"],
+    // ["UPDATE_BLOCK_LOCALITY", "updateLocality"],
+    // ["UPDATE_BLOCK_SLUG", "updateSlug"],
+    // ["PROFIL_IMAGE", "updateImageProfil"]
+  ]);
+
+  defaultFields = {
+
+  };
+
+  removeFields = ["typeElement"];
+
+  transforms = {
+
+  };
+
+  async _add(payload) {
+    if (!this._calledFromSave) {
+      throw new Error("utilisation invalide de _add, utilisez save");
+    }
+
+    payload.id = this._newId?.();
+    if (payload.slug) delete payload.slug;
+
+    for (const [constant, methodName] of Event.ADD_BLOCKS) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => {}
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        const data = await this[methodName](blockData);
+        if (!this.id && data?.map?.id) {
+          this._draftData.id = data.map.id;
+          this._draftData.slug = data.map.slug;
+        }
+      }
+    }
+  }
+
+  async _update(payload) {
+    if (!this._calledFromSave) {
+      throw new Error("utilisation invalide de _update, utilisez save");
+    }
+
+    if (payload.id) delete payload.id;
+    let hasChanged = false;
+
+    for (const [constant, methodName] of Event.UPDATE_BLOCKS) {
+      const blockData = this._extractChangedFieldsFromSchema(
+        this.apiClient,
+        constant,
+        { ...payload, ...this.defaultFields },
+        () => this.initialDraftData,
+        this.removeFields
+      );
+      if (blockData && Object.keys(blockData).length > 0) {
+        await this[methodName](blockData);
+        hasChanged = true;
+      }
+    }
+
+    return hasChanged;
+  }
+
+  async getOrganizations() {
+    throw new Error(`getOrganizations n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getProjects() {
+    throw new Error(`getProjects n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getEvents() {
+    throw new Error(`getEvents - les sous-events ne sont pas encore implémentés dans ${this.constructor.name}`);
+  }
+
+  async getPois() {
+    throw new Error(`getPois n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getBadgesIssuer() {
+    throw new Error(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async getNews(data = {}) {
+    return super.getNews(data);
+  }
+
+  async getSubscribers(data = {}) {
+    return super.getSubscribers(data);
+  }
+
+  async project() {
+    throw new Error(`project n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async poi() {
+    throw new Error(`poi n'existe pas dans ${this.constructor.name}`);
+  }
+
+  async event() {
+    throw new Error(`les sous-events ne sont pas encore implémentés dans ${this.constructor.name}`);
+  }
+
+  async badge() {
+    throw new Error(`badge n'existe pas dans ${this.constructor.name}`);
+  }
+
+  /**
+   * Crée une instance de news et la récupère si nécessaire.
+   * 
+   * @param {Object} newsData - Les données nécessaires pour initialiser la news.
+   * @returns {Promise<News>} Une promesse qui résout l'objet News créé.
+   * @throws {Error} Si une erreur se produit lors de la création de la news.
+   */
+  async news(newsData = {}) {
+    return super.news(newsData);
+  }
+
+}