@communecter/cocolight-api-client 1.0.17 → 1.0.19

package/src/index.js

@@ -1,8 +1,10 @@
 import Api from "./Api.js";
 import ApiClient from "./ApiClient.js";
 import * as error from "./error.js";
+import { createDefaultMultiServerTokenStorageStrategy } from "./utils/createDefaultMultiServerTokenStorageStrategy.js";
 import { createDefaultTokenStorageStrategy } from "./utils/createDefaultTokenStorageStrategy.js";
+import { MultiServerTokenStorageStrategy } from "./utils/MultiServerTokenStorageStrategy.js";
 import OfflineClientManager from "./utils/OfflineClientManager.js";
 import { TokenStorageStrategy } from "./utils/TokenStorage.js";
 
-export default { ApiClient, Api, error, tokenStorageStrategy: { createDefaultTokenStorageStrategy, TokenStorageStrategy }, OfflineClientManager };
+export default { ApiClient, Api, error, tokenStorageStrategy: { createDefaultTokenStorageStrategy, TokenStorageStrategy, createDefaultMultiServerTokenStorageStrategy, MultiServerTokenStorageStrategy }, OfflineClientManager };

package/src/mixin/EntityMixin.js

@@ -1,4 +1,4 @@
-import { ApiResponseError } from "../error.js";
+import { ApiError, ApiResponseError } from "../error.js";
 
 // EntityMixin.js
 export const EntityMixin = {
@@ -104,6 +104,325 @@ export const EntityMixin = {
     image = await this._validateImage(image);
     const data = { pathParams: { folder: this.getEntityType(), ownerId: this.id },  profil_avatar: image };
     return this.callIsConnected(() => this.endpointApi.profilImage(data));
+  },
+
+  /**
+   * Crée une instance d'organisation et récupère son profil si nécessaire.
+   *
+   * @param {Object} organizationData - Les données nécessaires pour initialiser l'organisation.
+   * @returns {Promise<Organization>} Une promesse qui résout l'objet Organisation créé.
+   * @throws {Error} Si une erreur se produit lors de la création de l'organisation.
+   */
+  async organization(organizationData = {}) {
+    if(!this.isMe){
+      throw new ApiError("Vous devez être connecté et être l'utilisateur pour créer une organisation.");
+    }
+    return this.entity("organizations", organizationData);
+  },
+
+  /**
+   * Crée une instance de projet et récupère son profil si nécessaire.
+   *
+   * @param {Object} projectData - Les données nécessaires pour initialiser le projet.
+   * @returns {Promise<Project>} Une promesse qui résout l'objet Projet créé.
+   * @throws {Error} Si une erreur se produit lors de la création du projet.
+   */
+  async project(projectData = {}) {
+    // TODO: Vérifier si l'utilisateur est admin de l'organisation
+    if(!this.isConnected){
+      throw new ApiError("Vous devez être connecté pour créer un projet.");
+    }
+    return this.entity("projects", projectData);
+  },
+
+  /**
+   * Crée une instance de POI et la récupère si nécessaire.
+   * 
+   * @param {Object} poiData - Les données nécessaires pour initialiser le POI.
+   * @returns {Promise<Poi>} Une promesse qui résout l'objet POI créé.
+   * @throws {Error} Si une erreur se produit lors de la création du POI.
+   */
+  async poi(poiData = {}) {
+    // TODO: Vérifier si l'utilisateur est admin de l'organisation
+    if(!this.isConnected){
+      throw new ApiError("Vous devez être connecté pour créer un POI.");
+    }
+    return this.entity("poi", poiData);
+  },
+
+  /**
+   * Crée une instance d'événement et la récupère si nécessaire.
+   * 
+   * @param {Object} eventData - Les données nécessaires pour initialiser l'événement.
+   * @returns {Promise<Event>} Une promesse qui résout l'objet Événement créé.
+   * @throws {Error} Si une erreur se produit lors de la création de l'événement.
+   */
+  async event(eventData = {}) {
+    // TODO: Vérifier si l'utilisateur est admin de l'organisation
+    if(!this.isConnected){
+      throw new ApiError("Vous devez être connecté pour créer un événement.");
+    }
+    return this.entity("events", eventData);
+  },
+
+  /**
+   * Crée une instance de badge et la récupère si nécessaire.
+   * 
+   * @param {Object} badgeData - Les données nécessaires pour initialiser le badge.
+   * @returns {Promise<Badge>} Une promesse qui résout l'objet Badge créé.
+   * @throws {Error} Si une erreur se produit lors de la création du badge.
+   */
+  async badge(badgeData = {}) {
+    // TODO: Vérifier si l'utilisateur est admin de l'organisation
+    if(!this.isConnected){
+      throw new ApiError("Vous devez être connecté pour créer un badge.");
+    }
+    return this.entity("badges", badgeData);
+  },
+
+  /**
+   * 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 = {}) {
+    if(!this.isConnected){
+      throw new ApiError("Vous devez être connecté.");
+    }
+    return this.entity("news", newsData);
+  },
+
+  /**
+   * Récupérer les organisations d'une entitée : la liste des organisations dont l'entité est membre ou admin valide.
+   * Constant : GET_ORGANIZATIONS_ADMIN | GET_ORGANIZATIONS_NO_ADMIN
+   * @param {Object} data - Les données à envoyer.
+   * @returns {Promise<Object>} - Les données de réponse.
+   */
+  async getOrganizations(data = {}) {
+
+    if(this.isMe){
+      data.pathParams = { type: this.getEntityType(), id: this.id };
+      // NOTE : dans le schema je crois que si pas de data.filters alors le default ce fait avec data.pathParams
+      // data.filters = {
+      //   [`links.members.${this.id}`]: { "$exists": true },
+      //   [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
+      //   [`links.members.${this.id}.isInviting`]: { "$exists": false }
+      // };
+    } else {
+      delete data?.pathParams;
+      data.filters = {
+        [`links.members.${this.id}`]: { "$exists": true },
+        [`links.members.${this.id}.toBeValidated`]: { "$exists": false },
+        [`links.members.${this.id}.isInviting`]: { "$exists": false }
+      };
+    }
+  
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getOrganizationsAdmin(data))
+      : () => this.endpointApi.getOrganizationsNoAdmin(data);
+  
+    const arrayObjetOrganizations = await fetchFn();
+  
+    if (!Array.isArray(arrayObjetOrganizations.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des organisations.", 500, arrayObjetOrganizations.results);
+    }
+  
+    // nettoyage du count
+    delete arrayObjetOrganizations?.count?.spam;
+  
+    // calcul du total
+    const totalCount = Object.values(arrayObjetOrganizations.count || {}).reduce((acc, val) => acc + val, 0);
+    arrayObjetOrganizations.count.total = totalCount;
+  
+    const rawOrganizationsList = arrayObjetOrganizations.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+  
+    return {
+      count: arrayObjetOrganizations.count,
+      results: rawOrganizationsList
+    };
+  },
+
+  /**
+     * Récupérer les projets d'une entitée : liste des projets de l'entité ou elle est "parent" ou "contributeur".
+     * Constant : GET_PROJECTS_ADMIN | GET_PROJECTS_NO_ADMIN
+     * @param {Object} data - Les données à envoyer.
+     * @returns {Promise<Object>} - Les données de réponse.
+     */
+  async getProjects(data = {}) {
+
+    if(this.isMe){
+      data.pathParams = { type: this.getEntityType(), id: this.id };
+      // NOTE : dans le schema je crois que si pas de data.filters alors le default ce fait avec data.pathParams
+      // data.filters = {
+      //   "$or": {
+      //     [`links.contributors.${this.id}`]: { "$exists": true },
+      //     [`parent.${this.id}`]: { "$exists": true }
+      //   },
+      //   [`links.contributors.${this.id}`]: { "$exists": true }
+      // };
+    } else {
+      delete data?.pathParams;
+      data.filters = {
+        "$or": {
+          [`links.contributors.${this.id}`]: { "$exists": true },
+          [`parent.${this.id}`]: { "$exists": true }
+        },
+        [`links.contributors.${this.id}`]: { "$exists": true }
+      };
+    }
+    
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getProjectsAdmin(data))
+      : () => this.endpointApi.getProjectsNoAdmin(data);
+    
+    
+    const arrayObjetProjects = await fetchFn();
+    
+    if (!Array.isArray(arrayObjetProjects.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des projets.", 500, arrayObjetProjects.results);
+    }
+  
+    const rawProjectsList = arrayObjetProjects.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+    
+    return {
+      count: arrayObjetProjects?.count?.projects ?? 0,
+      results: rawProjectsList
+    };
+  },
+
+  /**
+   * Récupérer les POIs d'une entité : liste des POIs de l'entité ou elle est "parent".
+   * Constant : GET_POIS_NO_ADMIN / GET_POIS_ADMIN
+   * @param {Object} data - Les données à envoyer.
+   * @returns {Promise<Object>} - Les données de réponse.
+   */
+  async getPois(data = {}) {
+
+    if(this.isMe){
+      data.pathParams = { type: this.getEntityType(), id: this.id };
+      // NOTE : dans le schema je crois que si pas de data.filters alors le default ce fait avec data.pathParams
+      // data.filters = {
+      //   [`parent.${this.id}`]: { "$exists": true },
+      // };
+    } else {
+      delete data?.pathParams;
+      data.filters = {
+        [`parent.${this.id}`]: { "$exists": true },
+      };
+    }
+  
+    const fetchFn = this.isMe
+      ? () => this.callIsMe(() => this.endpointApi.getPoisAdmin(data))
+      : () => this.endpointApi.getPoisNoAdmin(data);
+  
+    const arrayObjetPois = await fetchFn();
+    if (!Array.isArray(arrayObjetPois.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des POIs.", 500, arrayObjetPois.results);
+    }
+
+    // lier les entités au objets
+    const rawPoisList = arrayObjetPois.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetPois.count?.poi ?? 0,
+      results: rawPoisList
+    };
+  },
+
+  /**
+   * Récupérer les abonnés d'une entité
+   * Constant : GET_SUBSCRIBERS
+   * @param {Object} data - Les données à envoyer.
+   * @returns {Promise<Object>} - Les données de réponse.
+   */
+  async getSubscribers(data = {}) {
+    delete data?.pathParams;
+
+    data.filters =  {
+      [`links.follows.${this.id}`]: { "$exists": true },
+      [`links.follows.${this.id}.toBeValidated`]: { "$exists": false },
+      [`links.follows.${this.id}.isInviting`]: { "$exists": false }
+    };
+  
+    const arrayObjetSubscribers = await  this.endpointApi.getSubscribers(data);
+    if (!Array.isArray(arrayObjetSubscribers.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des abonnés.", 500, arrayObjetSubscribers.results);
+    }
+
+    // lier les entités au objets
+    const rawSubscribersList = arrayObjetSubscribers.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetSubscribers.count,
+      results: rawSubscribersList
+    };
+  },
+
+  /**
+   * Liste des badges créés par l'entité
+   * Constant : GET_BADGES
+   * @param {Object} data - Les données à envoyer.
+   * @returns {Promise<Object>} - Les données de réponse. 
+   */
+  async getBadgesIssuer(data = {}) {
+    delete data?.pathParams;
+  
+    data.filters = data.filters || {};
+    data.filters["$or"] = {};
+    data.filters["$or"][`issuer.${this.id}`] = { "$exists": true };
+
+    const arrayObjetBadges = await this.endpointApi.getBadges(data);
+    if (!Array.isArray(arrayObjetBadges.results)) {
+      throw new ApiResponseError("Erreur lors de la récupération des badges.", 500, arrayObjetBadges.results);
+    }
+
+    // lier les entités au objets
+    const rawBadgesList = arrayObjetBadges.results.map(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return {
+      count: arrayObjetBadges.count?.badges ?? 0,
+      results: rawBadgesList
+    };
+  },
+
+  /**
+   * 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(
+      (d) => this.linkEntity?.(d.collection, d) ?? d
+    );
+
+    return this._createFilteredProxy(rawNewsList);
   }
+
+
 };
   

package/src/mixin/MutualEntityMixin.js

@@ -42,7 +42,228 @@ export const MutualEntityMixin = {
   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,7 +1,7 @@
 import ObjectID from "bson-objectid";
 // import { fileTypeFromBuffer } from "file-type";
 import pkg from "file-type";
-const { fileTypeFromBuffer } = pkg;
+const { fromBuffer } = pkg;
 
 import { ApiAuthenticationError, ApiValidationError } from "../error.js";
 
@@ -136,7 +136,7 @@ export const UtilMixin = {
   
     // Node.js : Buffer
     else if (isNode && Buffer.isBuffer(input)) {
-      const fileTypeResult = await fileTypeFromBuffer(input);
+      const fileTypeResult = await fromBuffer(input);
       mimeType = fileTypeResult?.mime;
   
       if (!fileTypeResult || !allowedMimeTypes.includes(mimeType)) {
@@ -171,7 +171,7 @@ export const UtilMixin = {
       await new Promise((resolve) => setTimeout(resolve, 10));
   
       const previewBuffer = Buffer.concat(previewChunks);
-      const fileTypeResult = await fileTypeFromBuffer(previewBuffer);
+      const fileTypeResult = await fromBuffer(previewBuffer);
       mimeType = fileTypeResult?.mime;
   
       if (!fileTypeResult || !allowedMimeTypes.includes(mimeType)) {
@@ -269,6 +269,10 @@ export const UtilMixin = {
     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) {

package/src/utils/MultiServerFileStorageStrategy.node.js

@@ -0,0 +1,65 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+import { MultiServerTokenStorageStrategy } from "./MultiServerTokenStorageStrategy.js";
+
+export class MultiServerFileStorageStrategy extends MultiServerTokenStorageStrategy {
+  constructor(filename = "tokens.json", dir = path.join(os.homedir(), ".config", "cocolight")) {
+    super();
+    this.filePath = path.join(dir, filename);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  }
+
+  _readFile() {
+    if (!fs.existsSync(this.filePath)) return {};
+    try {
+      return JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+
+  _writeFile(data) {
+    fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf8");
+  }
+
+  getAccessToken() {
+    this._ensureContext();
+    return this._readFile()[this._currentBaseURL]?.accessToken || null;
+  }
+
+  setAccessToken(token) {
+    this._ensureContext();
+    const all = this._readFile();
+    all[this._currentBaseURL] = { ...(all[this._currentBaseURL] || {}), accessToken: token };
+    this._writeFile(all);
+  }
+
+  getRefreshToken() {
+    this._ensureContext();
+    return this._readFile()[this._currentBaseURL]?.refreshToken || null;
+  }
+
+  setRefreshToken(token) {
+    this._ensureContext();
+    const all = this._readFile();
+    all[this._currentBaseURL] = { ...(all[this._currentBaseURL] || {}), refreshToken: token };
+    this._writeFile(all);
+  }
+
+  clear() {
+    this._ensureContext();
+    const all = this._readFile();
+    delete all[this._currentBaseURL];
+    this._writeFile(all);
+  }
+
+  getServers() {
+    return Object.keys(this._readFile());
+  }
+
+  exportAll() {
+    return this._readFile();
+  }
+}