@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@communecter/cocolight-api-client",
-    "version": "1.0.54",
+    "version": "1.0.56",
     "description": "Client Axios simplifié pour l'API cocolight",
     "repository": {
         "type": "git",
@@ -12,38 +12,40 @@
     "browser": "./dist/cocolight-api-client.browser.js",
     "exports": {
         "types": "./types/index.d.ts",
-            "import": {
-                "vite": "./dist/cocolight-api-client.vite.mjs.js",
-                "browser": "./dist/cocolight-api-client.vite.mjs.js",
-                "default": "./dist/cocolight-api-client.vite.mjs.js"
-            },
-            "require": "./dist/cocolight-api-client.cjs",
-            "default": "./dist/cocolight-api-client.mjs.js"
+        "import": {
+            "vite": "./dist/cocolight-api-client.vite.mjs.js",
+            "browser": "./dist/cocolight-api-client.vite.mjs.js",
+            "default": "./dist/cocolight-api-client.vite.mjs.js"
         },
+        "require": "./dist/cocolight-api-client.cjs",
+        "default": "./dist/cocolight-api-client.mjs.js"
+    },
     "type": "module",
     "types": "./types/index.d.ts",
     "scripts": {
-        "test": "node --experimental-vm-modules ./node_modules/.bin/jest --config jest.config.js",
+        "test": "vitest run",
+        "test:watch": "vitest watch",
+        "test:ui": "vitest --ui",
+        "test:old": "node --experimental-vm-modules ./node_modules/.bin/jest --config jest.config.js",
         "exemple": "node exemple/exemple.js",
-        "exemple-api": "node exemple/exemple-api.js",
-        "lint": "eslint ./src ./exemple ./scripts --ext .js",
-        "lint:fix": "eslint ./src ./scripts --ext .js --fix",
+        "exemple-api": "tsx exemple/exemple-api.ts",
+        "lint": "eslint ./src ./scripts --ext .js,.ts",
+        "lint:fix": "eslint ./src ./scripts --ext .js,.ts --fix",
+        "typecheck": "tsc --noEmit",
         "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:esm:rollup": "rollup -c rollup.config.mjs",
         "verif:esm": "webpack --config webpack.config.esm.mjs --profile --json > stats.json",
-        "build:types": "tsc --project tsconfig.types.json",
+        "build:ts": "tsc --project tsconfig.json",
+        "build:types": "npm run generate:methodeapi && tsc --project tsconfig.types.json",
         "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 && npm run build:esm:rollup && npm run build:types",
         "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",
         "generate:doc": "node ./scripts/generate-doc.js",
-        "generate:test": "node ./scripts/generate-tests.js",
-        "generate:testdata": "node ./scripts/generate-test-data.js",
         "generate:reponses": "node ./scripts/generate-constant-response-200.js",
-        "generate:methodeapi": "node ./scripts/generate-methode-api.js",
-        "generate:entities": "node scripts/generate-entities.js"
+        "generate:methodeapi": "node ./scripts/generate-methode-api.js"
     },
     "keywords": [
         "communecter",
@@ -78,14 +80,19 @@
     "devDependencies": {
         "@babel/core": "^7.26.10",
         "@babel/preset-env": "^7.26.9",
+        "@babel/preset-typescript": "^7.27.1",
         "@eslint/js": "^9.23.0",
         "@rollup/plugin-babel": "^6.0.4",
         "@rollup/plugin-commonjs": "^28.0.3",
         "@rollup/plugin-json": "^6.1.0",
         "@rollup/plugin-node-resolve": "^16.0.1",
         "@rollup/plugin-terser": "^0.4.4",
+        "@rollup/plugin-typescript": "^12.1.4",
         "@segment/ajv-human-errors": "^2.15.0",
         "@types/ejson": "^2.2.2",
+        "@typescript-eslint/eslint-plugin": "^8.46.2",
+        "@typescript-eslint/parser": "^8.46.2",
+        "@vitest/ui": "^4.0.1",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
         "axios": "^1.4.0",
@@ -93,6 +100,7 @@
         "babel-jest": "^29.7.0",
         "babel-loader": "^10.0.0",
         "bson-objectid": "^2.0.4",
+        "dotenv": "^17.2.3",
         "ejson": "^2.2.3",
         "eslint": "^9.23.0",
         "eslint-plugin-import": "^2.31.0",
@@ -107,7 +115,11 @@
         "pino-pretty": "^13.0.0",
         "rollup": "^4.40.0",
         "rollup-plugin-peer-deps-external": "^2.2.4",
+        "ts-loader": "^9.5.4",
+        "tslib": "^2.8.1",
+        "tsx": "^4.20.6",
         "typescript": "^5.9.2",
+        "vitest": "^4.0.1",
         "webpack": "^5.98.0",
         "webpack-cli": "^6.0.1"
     }

package/src/{Api.js → Api.ts}

@@ -1,5 +1,6 @@
-// Api.js
+// Api.ts
 import { Badge } from "./api/Badge.js";
+import { Comment } from "./api/Comment.js";
 import EndpointApi from "./api/EndpointApi.js";
 import { createFromCollection, registerEntity } from "./api/EntityRegistry.js";
 import { Event } from "./api/Event.js";
@@ -11,6 +12,10 @@ import { User } from "./api/User.js";
 import { UserApi } from "./api/UserApi.js";
 import { ApiAuthenticationError, ApiClientError, ApiError, ApiResponseError } from "./error.js";
 
+import type ApiClient from "./ApiClient.js";
+import type { ApiClientOptions } from "./ApiClient.js";
+import type { GetElementsKeyResponse } from "./types/api-responses.js";
+
 registerEntity("User", User);
 registerEntity("Organization", Organization);
 registerEntity("Project", Project);
@@ -18,61 +23,68 @@ registerEntity("Event", Event);
 registerEntity("Poi", Poi);
 registerEntity("Badge", Badge);
 registerEntity("EndpointApi", EndpointApi);
-registerEntity("UserApi", UserApi);
+// registerEntity("UserApi", UserApi);
 registerEntity("News", News);
+registerEntity("Comment", Comment);
+
+/**
+ * Union type for all possible entity types
+ */
+type EntityTypes = User | Organization | Project | Event | Poi | Badge | News | Comment;
 
-/** @typedef {import("./ApiClient.js").default} ApiClient */
-/** @typedef {import("./ApiClient.js").ApiClientOptions} ApiClientOptions */
+/**
+ * Type pour récupérer une entité existante via l'API publique.
+ * Nécessite soit un id, soit un slug.
+ * Les propriétés additionnelles sont autorisées mais ignorées lors de la récupération.
+ */
+type EntityData =
+  | { id: string; slug?: string; [key: string]: any }
+  | { slug: string; id?: string; [key: string]: any };
 
 export default class Api {
+  private _loggedUser: User | null;
+  private _client: ApiClient;
+
   /**
    * Authentifie l'utilisateur et retourne une instance d'Api.
-   *
-   * @param {string} email - L'adresse email.
-   * @param {string} password - Le mot de passe.
-   * @param {ApiClientOptions|ApiClient} options - Options pour l'ApiClient ou instance existante.
-   * @returns {Promise<Api>}
-   * @throws {ApiAuthenticationError|ApiClientError|ApiError}
    */
-  static async userLogin(email, password, options) {
+  static async userLogin(
+    email: string,
+    password: string,
+    options: ApiClientOptions | ApiClient
+  ): Promise<Api> {
     const userApi = Api.userApi(options);
     return await Api.userApiLogin(userApi, email, password);
   }
 
   /**
    * Crée une instance de UserApi avec les options fournies.
-   *
-   * @param {ApiClientOptions|ApiClient} options - Options pour ApiClient ou instance d'ApiClient.
-   * @returns {UserApi}
-   * @throws {Error}
    */
-  static userApi(options) {
+  static userApi(options: ApiClientOptions | ApiClient): UserApi {
     try {
       const userApi = new UserApi(options);
       return userApi;
     } catch (error) {
-      console.error("[Api.userApi] Erreur lors de la création d'un objet utilisateur :", error.message);
+      console.error("[Api.userApi] Erreur lors de la création d'un objet utilisateur :", (error as Error).message);
       throw error;
     }
   }
   
   /**
    * Connecte un utilisateur avec un UserApi existant.
-   *
-   * @param {UserApi} userApi - Instance UserApi utilisée pour l'authentification.
-   * @param {string} email - Email de l'utilisateur.
-   * @param {string} password - Mot de passe de l'utilisateur.
-   * @returns {Promise<Api>}
-   * @throws {ApiAuthenticationError|ApiClientError|ApiError}
    */
-  static async userApiLogin(userApi, email, password) {
+  static async userApiLogin(
+    userApi: UserApi,
+    email: string,
+    password: string
+  ): Promise<Api> {
     try {
 
       if (!userApi) {
-        throw new ApiError("userApi is not defined");
+        throw new ApiError("userApi is not defined", 500);
       }
       if(!userApi.client) {
-        throw new ApiError("userApi.client is not defined");
+        throw new ApiError("userApi.client is not defined", 500);
       }
 
       if(userApi.client.isConnected) {
@@ -82,7 +94,7 @@ export default class Api {
         return new Api(loggedUser, userApi.client);
       } else {
         if (!email || !password) {
-          throw new ApiError("email and password are required");
+          throw new ApiError("email and password are required", 400);
         }
         const loggedUser = await userApi.login(email, password);
         return new Api(loggedUser, userApi.client);
@@ -100,24 +112,18 @@ export default class Api {
     
   /**
    * Construit une instance d'Api.
-   *
-   * @param {User|null} loggedUser - L'utilisateur connecté ou null.
-   * @param {ApiClient} client - L'instance d'ApiClient.
    */
-  constructor(loggedUser, client) {
+  constructor(loggedUser: User | null, client: ApiClient) {
     this._loggedUser = loggedUser;
     this._client = client;
   }
 
   /**
    * Retourne l'utilisateur connecté.
-   *
-   * @returns {Promise<User>} L'utilisateur connecté.
-   * @throws {ApiAuthenticationError} Si l'utilisateur n'est pas authentifié.
    */
-  async me() {
+  async me(): Promise<User> {
     if (!this._loggedUser) {
-      throw new ApiAuthenticationError("Accès refusé : utilisateur non authentifié.");
+      throw new ApiAuthenticationError("Accès refusé : utilisateur non authentifié.", 401);
     }
     await this._loggedUser.get();
     return this._loggedUser;
@@ -125,22 +131,18 @@ export default class Api {
 
   /**
    * Crée une instance User (autre que le connecté).
-   *
-   * @param {{id?: string, slug?: string, [k: string]: any}} userData
-   * @returns {Promise<User>}
-   * @throws {Error}
    */
-  async user(userData) {
+  async user(userData: EntityData): Promise<User> {
     try {
       if (!userData.id && !userData.slug) {
-        return new User(this._client, userData, { EndpointApi, Organization, Project, Event, Poi, Badge, News });
+        return new User(this._client, userData, { EndpointApi, Organization, Project, Event, Poi, Badge, News, Comment });
       } else {
-        const user = new User(this._client, userData, { EndpointApi, Organization, Project, Event, Poi, Badge, News });
+        const user = new User(this._client, userData, { EndpointApi, Organization, Project, Event, Poi, Badge, News, Comment });
         await user.get();
         return user;
       }
     } catch (error) {
-      console.error("[Api.user] Erreur lors de la création d'un objet utilisateur public :", error.message);
+      console.error("[Api.user] Erreur lors de la création d'un objet utilisateur public :", (error as Error).message);
       throw error;
     }
   }
@@ -148,121 +150,109 @@ export default class Api {
 
   /**
    * Creates an Organization object and optionally retrieves its profile.
-   *
-   * @param {{id?: string, slug?: string, [k: string]: any}} organizationData - The data required to initialize the Organization object.
-   * @returns {Promise<Organization>} A promise that resolves to the created Organization object.
-   * @throws {Error} Throws an error if the organization creation or profile retrieval fails.
    */
-  async organization(organizationData) {
+  async organization(organizationData: EntityData): Promise<Organization> {
     try {
-      const organization = new Organization(this._client, organizationData, { EndpointApi, User, Project, Event, Poi, Badge, News });
+      const organization = new Organization(this._client, organizationData, { EndpointApi, User, Project, Event, Poi, Badge, News, Comment });
       if (!organizationData.id && !organizationData.slug) {
         throw new Error("Vous devez fournir un id ou un slug pour créer une instance Organization.");
       }
       await organization.get();
       return organization;
     } catch (error) {
-      console.error("[Api.organization] Erreur lors de la création d'un objet organisation :", error.message);
+      console.error("[Api.organization] Erreur lors de la création d'un objet organisation :", (error as Error).message);
       throw error;
     }
   }
 
   /**
    * Creates a new Project instance and optionally retrieves its profile.
-   *
-   * @param {{id?: string, slug?: string, [k: string]: any}} projectData - The data used to initialize the Project instance.
-   * @returns {Promise<Project>} A promise that resolves to the created Project instance.
-   * @throws {Error} If an error occurs during project creation or profile retrieval.
    */
-  async project(projectData) {
+  async project(projectData: EntityData): Promise<Project> {
     try {
-      const project = new Project(this._client, projectData, { EndpointApi, User, Organization, Event, Poi, Badge, News });
+      const project = new Project(this._client, projectData, { EndpointApi, User, Organization, Event, Poi, Badge, News, Comment });
       if (!projectData.id && !projectData.slug) {
         throw new Error("Vous devez fournir un id ou un slug pour créer une instance Project.");
       }
       await project.get();
       return project;
     } catch (error) {
-      console.error("[Api.project] Erreur lors de la création d'un objet projet :", error.message);
+      console.error("[Api.project] Erreur lors de la création d'un objet projet :", (error as Error).message);
       throw error;
     }
   }
 
   /**
    * Creates a new Event instance and optionally retrieves its profile.
-   *
-   * @param {{id?: string, slug?: string, [k: string]: any}} eventData
-   * @returns {Promise<Event>}
-   * @throws {Error}
    */
-  async event(eventData) {
+  async event(eventData: EntityData): Promise<Event> {
     try {
-      const event = new Event(this._client, eventData, { EndpointApi, User, Organization, Project, Poi, Badge, News });
+      const event = new Event(this._client, eventData, { EndpointApi, User, Organization, Project, Poi, Badge, News, Comment });
       if (!eventData.id && !eventData.slug) {
         throw new Error("Vous devez fournir un id ou un slug pour créer une instance Event.");
       }
       await event.get();
       return event;
     } catch (error) {
-      console.error("[Api.event] Erreur lors de la création d'un objet événement :", error.message);
+      console.error("[Api.event] Erreur lors de la création d'un objet événement :", (error as Error).message);
       throw error;
     }
   }
 
   /**
    * Retourne une entité à partir d'un slug.
-   *
-   * @param {string} slug
-   * @returns {Promise<User|Organization|Project|Event|Poi|Badge|News>}
-   * @throws {ApiResponseError|ApiClientError|ApiError}
    */
-  async entitySlug(slug) {
-    if (slug) {
-      try {
-        const data = await this.endpointApi.getElementsKey({
-          pathParams:{
-            slug: slug
-          }
-        });
-        if(data?.contextId && data?.contextType) {
-          const entity = createFromCollection(data?.contextType, this._client, { id: data?.contextId });
-          await entity.get();
-          return entity;
-        } else {
-          throw new ApiResponseError(`Le slug ${slug} n'est pas valide`, 200, data);
+  async entitySlug(slug: string): Promise<EntityTypes> {
+    if (!slug) {
+      throw new ApiError("slug requis", 400);
+    }
+    try {
+      const data = await this.endpointApi.getElementsKey({
+        pathParams:{
+          slug: slug
         }
-      } catch (error) {
-        if(error instanceof ApiResponseError) {
-          throw new ApiResponseError(`Impossible de récupérer l'identifiant pour le slug ${slug}`, error.status, error.responseData);
-        } else {
-          throw error;
+      }) as GetElementsKeyResponse;
+
+      if(data.contextId && data.contextType) {
+        const entity = createFromCollection(data.contextType, this._client, { id: data.contextId });
+        if (!entity) {
+          throw new ApiResponseError(`Le type d'entité pour le slug ${slug} n'est pas reconnu`, 200, data as object);
         }
+        await entity.get();
+        // On sait que c'est l'un des types concrets → on caste
+        return entity as EntityTypes;
+      } else {
+        throw new ApiResponseError(`Le slug ${slug} n'est pas valide`, 200, data as object);
+      }
+    } catch (error) {
+      if(error instanceof ApiResponseError) {
+        throw new ApiResponseError(`Impossible de récupérer l'identifiant pour le slug ${slug}`, error.status, error.responseData);
+      } else {
+        throw error;
       }
     }
+
   }
 
   /**
    * Retourne l'instance d'ApiClient.
-   * @returns {ApiClient}
    */
-  get client() {
+  get client(): ApiClient {
     return this._client;
   }
 
   /**
    * Retourne l'instance d'EndpointApi.
-   * @returns {EndpointApi}
    */
-  get endpointApi() {
+  get endpointApi(): EndpointApi {
     return new EndpointApi(this._client);
   }
 
   /**
    * Déconnecte l'utilisateur et réinitialise la session.
-   * @returns {void}
    */
-  logout () {
-    this.loggedUser = null;
+  logout(): void {
+    this._loggedUser = null;
     this._client.resetSession();
     this._client._logger.info("UserApi: User logged out");
   }