@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/EJSONType.ts

@@ -0,0 +1,103 @@
+/**
+ * Interface pour le module MongoID
+ */
+export interface MongoIDModule {
+  _looksLikeObjectID: (str: string) => boolean;
+  ObjectID: typeof ObjectID;
+}
+
+/**
+ * Teste si une chaîne ressemble à un ObjectID Mongo (24 hex).
+ */
+const looksLikeObjectID = (str: string): boolean => str.length === 24 && /^[0-9a-f]*$/.test(str);
+
+/**
+ * Représentation minimaliste d'un ObjectID Mongo (stocke l'hex en interne).
+ */
+class ObjectID {
+  private _str?: string;
+
+  /**
+   * @param hexString - Chaîne hexadécimale (24 chars). Si omise, l'instance est vide.
+   * @throws {Error} Si `hexString` est fournie mais invalide.
+   */
+  constructor(hexString?: string) {
+    this._str = undefined;
+
+    // impl « random-based » d'origine commentée, on accepte seulement un hex fourni
+    if (hexString) {
+      hexString = hexString.toLowerCase();
+      if (!looksLikeObjectID(hexString)) {
+        throw new Error("Invalid hexadecimal string for creating an ObjectID");
+      }
+      // pour _.isEqual() / égalité structurelle
+      this._str = hexString;
+    }
+  }
+
+  /**
+   * Compare à un autre ObjectID.
+   */
+  equals(other: unknown): boolean {
+    return other instanceof ObjectID && this.valueOf() === other.valueOf();
+  }
+
+  /**
+   * Représentation lisible (style Mongo shell).
+   */
+  toString(): string {
+    return `ObjectID("${this._str}")`;
+  }
+
+  /**
+   * Clone l'ObjectID.
+   */
+  clone(): ObjectID {
+    return new ObjectID(this._str);
+  }
+
+  /**
+   * Nom de type EJSON.
+   */
+  typeName(): "oid" {
+    return "oid";
+  }
+
+  /**
+   * Timestamp (secondes) extrait des 4 premiers octets.
+   * @returns Nombre de secondes depuis l'époque Unix.
+   */
+  getTimestamp(): number {
+    // _str est défini si le constructeur a validé la chaîne
+    // si undefined, parseInt renverra NaN (comportement d'origine)
+    return Number.parseInt(this._str?.substr(0, 8) ?? "", 16);
+  }
+
+  /**
+   * Valeur primitive (hex).
+   */
+  valueOf(): string | undefined {
+    return this._str;
+  }
+
+  /**
+   * Valeur JSON (hex).
+   */
+  toJSONValue(): string | undefined {
+    return this.valueOf();
+  }
+
+  /**
+   * Chaîne hexadécimale (24 chars).
+   */
+  toHexString(): string | undefined {
+    return this.valueOf();
+  }
+}
+
+const MongoID: MongoIDModule = {
+  _looksLikeObjectID: looksLikeObjectID,
+  ObjectID
+};
+
+export default MongoID;

package/src/api/{Badge.js → Badge.ts}

@@ -1,40 +1,40 @@
 import { ApiError } from "../error.js";
-import BaseEntity from "./BaseEntity.js";
+import { BaseEntity } from "./BaseEntity.js";
 
-export class Badge extends BaseEntity {
-  static entityType = "badges";
+export class Badge extends BaseEntity<any> {
+  static override entityType = "badges";
 
-  static entityTag = "Badge";
+  static override entityTag = "Badge";
 
-  static SCHEMA_CONSTANTS = [
+  static override SCHEMA_CONSTANTS: string[] = [
     "ADD_BADGES",
   ];
 
-  static ADD_BLOCKS = new Map([
+  static ADD_BLOCKS: Map<string, string> = new Map([
     ["ADD_BADGES", "addBadges"]
   ]);
 
-  static UPDATE_BLOCKS = new Map([
+  static UPDATE_BLOCKS: Map<string, string> = new Map([
   ]);
 
-  defaultFields = {
+  override defaultFields: Record<string, any> = {
 
   };
 
-  removeFields = [];
+  override removeFields: string[] = [];
 
-  transforms = {
+  // transforms = {
 
-  };
+  // };
 
-  async _add(payload) {
+  override _add = async (payload: Record<string, any>): Promise<void> => {
     if (!this._calledFromSave) {
-      throw new ApiError("utilisation invalide de _add, utilisez save");
+      throw new ApiError("utilisation invalide de _add, utilisez save", 400);
     }
     payload.id = this._newId?.();
     if (payload.slug) delete payload.slug;
 
-    for (const [constant, methodName] of Badge.ADD_BLOCKS) {
+    for (const [constant, methodName] of Array.from(Badge.ADD_BLOCKS)) {
       const blockData = this._extractChangedFieldsFromSchema(
         this.apiClient,
         constant,
@@ -42,24 +42,24 @@ export class Badge extends BaseEntity {
         () => {}
       );
       if (blockData && Object.keys(blockData).length > 0) {
-        const data = await this[methodName](blockData);
+        const data = await (this as any)[methodName](blockData);
         if (!this.id && data?.map?.id) {
           this._draftData.id = data.map.id;
           this._draftData.slug = data.map.slug;
         }
       }
     }
-  }
+  };
 
-  async _update(payload) {
+  override _update = async (payload: Record<string, any>): Promise<boolean> => {
     // TODO: qui peut modifier un badge ?
     if (!this._calledFromSave) {
-      throw new ApiError("utilisation invalide de _update, utilisez save");
+      throw new ApiError("utilisation invalide de _update, utilisez save", 400);
     }
     if (payload.id) delete payload.id;
     let hasChanged = false;
 
-    for (const [constant, methodName] of Badge.UPDATE_BLOCKS) {
+    for (const [constant, methodName] of Array.from(Badge.UPDATE_BLOCKS)) {
       const blockData = this._extractChangedFieldsFromSchema(
         this.apiClient,
         constant,
@@ -68,60 +68,71 @@ export class Badge extends BaseEntity {
         this.removeFields
       );
       if (blockData && Object.keys(blockData).length > 0) {
-        await this[methodName](blockData);
+        await (this as any)[methodName](blockData);
         hasChanged = true;
       }
     }
 
     return hasChanged;
-  }
+  };
 
-  async getOrganizations() {
-    throw new ApiError(`getOrganizations n'existe pas dans ${this.constructor.name}`);
+  override async getOrganizations(): Promise<never> {
+    throw new ApiError(`getOrganizations n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getProjects() {
-    throw new ApiError(`getProjects n'existe pas dans ${this.constructor.name}`);
+
+  override async getProjects(): Promise<never> {
+    throw new ApiError(`getProjects n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getEvents() {
-    throw new ApiError(`getEvents n'existe pas dans ${this.constructor.name}`);
+
+  async getEvents(): Promise<never> {
+    throw new ApiError(`getEvents n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getPois() {
-    throw new ApiError(`getPois n'existe pas dans ${this.constructor.name}`);
+
+  override async getPois(): Promise<never> {
+    throw new ApiError(`getPois n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getBadgesIssuer() {
-    throw new ApiError(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`);
+
+  override async getBadgesIssuer(): Promise<never> {
+    throw new ApiError(`getBadgesIssuer n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getNews() {
-    throw new ApiError(`getNews n'existe pas dans ${this.constructor.name}`);
+
+  override async getNews(): Promise<never> {
+    throw new ApiError(`getNews n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async getSubscribers() {
-    throw new ApiError(`getSubscribers n'existe pas dans ${this.constructor.name}`);
+
+  override async getSubscribers(): Promise<never> {
+    throw new ApiError(`getSubscribers n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async project() {
-    throw new ApiError(`project n'existe pas dans ${this.constructor.name}`);
+
+  override async project(): Promise<never> {
+    throw new ApiError(`project n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async poi() {
-    throw new ApiError(`poi n'existe pas dans ${this.constructor.name}`);
+
+  override async poi(): Promise<never> {
+    throw new ApiError(`poi n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async event() {
-    throw new ApiError(`event n'existe pas dans ${this.constructor.name}`);
+
+  override async event(): Promise<never> {
+    throw new ApiError(`event n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async badge() {
-    throw new ApiError(`badge n'existe pas dans ${this.constructor.name}`);
+
+  override async badge(): Promise<never> {
+    throw new ApiError(`badge n'existe pas dans ${this.constructor.name}`, 501);
   }
 
-  async news() {
-    throw new ApiError(`news n'existe pas dans ${this.constructor.name}`);
+
+  override async news(): Promise<never> {
+    throw new ApiError(`news n'existe pas dans ${this.constructor.name}`, 501);
   }
 
 }