@communecter/cocolight-api-client 1.0.54 → 1.0.56

package/src/types/transforms.ts

@@ -0,0 +1,110 @@
+// types/transforms.ts - Types spécialisés pour les transformations par entité
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+
+import type { TransformFunction, EntityRefsMap } from "./entities.js";
+import type { SocialNetworkPayload } from "./payloads.js";
+
+/**
+ * Types pour les données d'entrée des transforms
+ */
+export interface ParentData {
+  [key: string]: {
+    type?: string;
+    name?: string;
+  };
+}
+
+export interface OrganizerData {
+  [key: string]: {
+    type?: string;
+    name?: string;
+  };
+}
+
+// Alias pour SocialNetworkPayload depuis payloads.ts (évite la duplication)
+export type SocialNetworkData = SocialNetworkPayload;
+
+/**
+ * Types pour les transforms spécifiques aux événements
+ */
+export interface EventTransforms {
+  parent: TransformFunction<ParentData | null, EntityRefsMap>;
+  organizer: TransformFunction<OrganizerData | null, EntityRefsMap>;
+  [key: string]: TransformFunction<any, any> | undefined;
+}
+
+/**
+ * Types pour les transforms spécifiques aux utilisateurs/organisations/projets (réseaux sociaux)
+ */
+export interface SocialTransforms {
+  github: TransformFunction<any, string | undefined>;
+  gitlab: TransformFunction<any, string | undefined>;
+  facebook: TransformFunction<any, string | undefined>;
+  twitter: TransformFunction<any, string | undefined>;
+  instagram: TransformFunction<any, string | undefined>;
+  linkedIn?: TransformFunction<any, string | undefined>;
+  youtube?: TransformFunction<any, string | undefined>;
+  website?: TransformFunction<any, string | undefined>;
+  diaspora?: TransformFunction<any, string | undefined>;
+  mastodon?: TransformFunction<any, string | undefined>;
+  telegram?: TransformFunction<any, string | undefined>;
+  signal?: TransformFunction<any, string | undefined>;
+  [key: string]: TransformFunction<any, any> | undefined;
+}
+
+/**
+ * Types pour les transforms des utilisateurs
+ */
+export interface UserTransforms extends SocialTransforms {
+  // Ajouter d'autres transforms spécifiques aux utilisateurs si nécessaire
+}
+
+/**
+ * Types pour les transforms des organisations
+ */
+export interface OrganizationTransforms extends SocialTransforms {
+  // Ajouter d'autres transforms spécifiques aux organisations si nécessaire
+}
+
+/**
+ * Types pour les transforms des projets
+ */
+export interface ProjectTransforms extends SocialTransforms {
+  parent: TransformFunction<ParentData | null, EntityRefsMap>;
+}
+
+/**
+ * Union de tous les types de transforms
+ */
+export type EntityTransforms = EventTransforms | UserTransforms | OrganizationTransforms | ProjectTransforms;
+
+/**
+ * Fonction helper pour créer des transforms d'entité avec type safety
+ */
+export function createEntityRef(type: string, name?: string) {
+  return { type, name };
+}
+
+/**
+ * Fonction helper pour transformer les données parent/organizer
+ */
+export function transformEntityRefs(val: ParentData | OrganizerData | null): EntityRefsMap {
+  if (!val || typeof val !== "object") return {};
+
+  return Object.fromEntries(
+    Object.entries(val).map(([key, obj]) => [
+      key,
+      createEntityRef(
+        obj?.type ?? "",
+        obj?.name ?? undefined
+      )
+    ])
+  );
+}
+
+/**
+ * Fonction helper pour extraire les données de réseaux sociaux
+ */
+export function createSocialTransform(field: keyof SocialNetworkData): TransformFunction<any, string | undefined> {
+  return (val: any, full?: any) => full?.socialNetwork?.[field];
+}

package/src/utils/{FileOfflineStorageStrategy.node.js → FileOfflineStorageStrategy.node.ts}

@@ -1,27 +1,30 @@
-// src/utils/FileOfflineStorage.node.js
-import fs from "fs";
-import os from "os";
-import path from "path";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
 
 import { OfflineQueueStorageStrategy } from "./OfflineQueueStorageStrategy.js";
 
-export class FileOfflineStorage extends OfflineQueueStorageStrategy {
-  constructor(filename = "offline-queue.json", dir = path.join(os.homedir(), ".config", "cocolight")) {
+export class FileOfflineStorage<T = any> extends OfflineQueueStorageStrategy<T> {
+  public readonly dir: string;
+  public readonly filePath: string;
+
+  constructor(filename: string = "offline-queue.json", dir: string = path.join(os.homedir(), ".config", "cocolight")) {
     super();
     this.dir = dir;
     this.filePath = path.join(dir, filename);
     this._ensureDirectoryExists();
   }
 
-  _ensureDirectoryExists() {
+  private _ensureDirectoryExists(): void {
     if (!fs.existsSync(this.dir)) {
       fs.mkdirSync(this.dir, { recursive: true });
     }
   }
-  _readFile() {
+
+  private _readFile(): T[] {
     if (!fs.existsSync(this.filePath)) return [];
     try {
-      const json = JSON.parse(fs.readFileSync(this.filePath, "utf8"));
+      const json: T[] = JSON.parse(fs.readFileSync(this.filePath, "utf8"));
       return json;
     } catch (e) {
       console.error("Erreur lecture offline queue :", e);
@@ -29,7 +32,7 @@ export class FileOfflineStorage extends OfflineQueueStorageStrategy {
     }
   }
 
-  _writeFile(queue) {
+  private _writeFile(queue: T[]): void {
     try {
       fs.writeFileSync(this.filePath, JSON.stringify(queue, null, 2), "utf8");
     } catch (e) {
@@ -37,11 +40,11 @@ export class FileOfflineStorage extends OfflineQueueStorageStrategy {
     }
   }
 
-  async loadQueue() {
+  async loadQueue(): Promise<T[]> {
     return this._readFile();
   }
 
-  async saveQueue(queue) {
+  async saveQueue(queue: T[]): Promise<void> {
     this._writeFile(queue);
   }
 }

package/src/utils/{FileStorageStrategy.node.js → FileStorageStrategy.node.ts}

@@ -1,36 +1,28 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
 
 import { TokenStorageStrategy } from "./TokenStorage.js";
 
-/**
- * Stratégie de stockage des tokens basée sur un fichier (Node uniquement).
- * @implements {TokenStorageStrategy}
- */
 export class FileStorageStrategy extends TokenStorageStrategy {
-  /**
-   * @param {string} [filename="tokens.json"]
-   * @param {string} [dir=path.join(os.homedir(), ".config", "cocolight")]
-   */
-  constructor(filename = "tokens.json", dir = path.join(os.homedir(), ".config", "cocolight")) {
+  public readonly dir: string;
+  public readonly filePath: string;
+
+  constructor(filename: string = "tokens.json", dir: string = path.join(os.homedir(), ".config", "cocolight")) {
     super();
-    /** @type {string} */
     this.dir = dir;
-    /** @type {string} */
     this.filePath = path.join(dir, filename);
     this._ensureDirectoryExists();
   }
 
-  /** @private */
-  _ensureDirectoryExists() {
+  private _ensureDirectoryExists(): void {
     if (!fs.existsSync(this.dir)) {
       fs.mkdirSync(this.dir, { recursive: true });
     }
   }
 
-  /** @private */
-  _readFile() {
+  private _readFile(): any {
     if (!fs.existsSync(this.filePath)) return {};
     try {
       return JSON.parse(fs.readFileSync(this.filePath, "utf8"));
@@ -41,46 +33,31 @@ export class FileStorageStrategy extends TokenStorageStrategy {
     }
   }
 
-  /** 
-   * @private
-   * @param {Record<string, any>} data
-   */
-  _writeFile(data) {
+  private _writeFile(data: Record<string, any>): void {
     fs.writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf8");
   }
 
-  /** @returns {string|null} */
-  getAccessToken() {
+  getAccessToken(): string | null {
     return this._readFile().accessToken || null;
   }
 
-  /** 
-   * @param {string|null} token
-   * @returns {void}
-   */
-  setAccessToken(token) {
+  setAccessToken(token: string | null): void {
     const data = this._readFile();
     data.accessToken = token;
     this._writeFile(data);
   }
 
-  /** @returns {string|null} */
-  getRefreshToken() {
+  getRefreshToken(): string | null {
     return this._readFile().refreshToken || null;
   }
 
-  /** 
-   * @param {string|null} token
-   * @returns {void}
-   */
-  setRefreshToken(token) {
+  setRefreshToken(token: string | null): void {
     const data = this._readFile();
     data.refreshToken = token;
     this._writeFile(data);
   }
 
-  /** @returns {void} */
-  clear() {
+  clear(): void {
     this._writeFile({});
   }
 }

package/src/utils/MultiServerFileStorageStrategy.node.ts

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

package/src/utils/MultiServerTokenStorageStrategy.ts

@@ -0,0 +1,139 @@
+import { TokenStorageStrategy } from "./TokenStorage.js";
+
+export abstract class MultiServerTokenStorageStrategy extends TokenStorageStrategy {
+  protected _currentBaseURL: string | null = null;
+
+  constructor() {
+    super();
+  }
+
+  use(baseURL: string): void {
+    if (!baseURL) throw new Error("baseURL est requis");
+    this._currentBaseURL = baseURL.replace(/\/+$/, "");
+  }
+
+  protected _ensureContext(): void {
+    if (!this._currentBaseURL) throw new Error("baseURL non défini. Appelez use(baseURL)");
+  }
+
+  protected _requireBaseURL(): string {
+    this._ensureContext();
+    return this._currentBaseURL!;
+  }
+
+  abstract getServers(): string[];
+  abstract exportAll(): Record<string, { accessToken?: string | null; refreshToken?: string | null }>;
+
+}
+
+export class MultiServerMemoryStorageStrategy extends MultiServerTokenStorageStrategy {
+  private _storage = new Map<string, { accessToken?: string | null; refreshToken?: string | null }>();
+
+  constructor() {
+    super();
+  }
+
+  getAccessToken(): string | null {
+    const base = this._requireBaseURL();
+    return this._storage.get(base)?.accessToken ?? null;
+  }
+
+  setAccessToken(token: string | null): void {
+    const base = this._requireBaseURL();
+    const current = this._storage.get(base) || {};
+    this._storage.set(base, { ...current, accessToken: token });
+  }
+
+  getRefreshToken(): string | null {
+    const base = this._requireBaseURL();
+    return this._storage.get(base)?.refreshToken ?? null;
+  }
+
+  setRefreshToken(token: string | null): void {
+    const base = this._requireBaseURL();
+    const current = this._storage.get(base) || {};
+    this._storage.set(base, { ...current, refreshToken: token });
+  }
+
+  clear(): void {
+    const base = this._requireBaseURL();
+    this._storage.delete(base);
+  }
+
+  getServers(): string[] {
+    return Array.from(this._storage.keys());
+  }
+
+  exportAll(): Record<string, { accessToken?: string | null; refreshToken?: string | null }> {
+    return Object.fromEntries(this._storage.entries());
+  }
+}
+
+export class MultiServerLocalStorageStrategy extends MultiServerTokenStorageStrategy {
+  public readonly prefix: string;
+
+  constructor(prefix: string = "cocolight") {
+    super();
+    this.prefix = prefix;
+  }
+
+  private _key(baseURL: string): string {
+    return `${this.prefix}_tokens_${baseURL}`;
+  }
+
+  private _getData(): any {
+    this._ensureContext();
+    if (typeof localStorage === "undefined") return {};
+    const raw = localStorage.getItem(this._key(this._currentBaseURL!));
+    return raw ? JSON.parse(raw) : {};
+  }
+
+  private _setData(data: any): void {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(this._key(this._currentBaseURL!), JSON.stringify(data));
+  }
+
+  getAccessToken(): string | null {
+    return this._getData().accessToken ?? null;
+  }
+
+  setAccessToken(token: string | null): void {
+    const data = this._getData();
+    data.accessToken = token;
+    this._setData(data);
+  }
+
+  getRefreshToken(): string | null {
+    return this._getData().refreshToken ?? null;
+  }
+
+  setRefreshToken(token: string | null): void {
+    const data = this._getData();
+    data.refreshToken = token;
+    this._setData(data);
+  }
+
+  clear(): void {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(this._key(this._currentBaseURL!));
+  }
+
+  getServers(): string[] {
+    if (typeof localStorage === "undefined") return [];
+    const keys = Object.keys(localStorage);
+    return keys
+      .filter(k => k.startsWith(`${this.prefix}_tokens_`))
+      .map(k => k.replace(`${this.prefix}_tokens_`, ""));
+  }
+
+  exportAll(): Record<string, { accessToken?: string | null; refreshToken?: string | null }> {
+    const result: Record<string, { accessToken?: string | null; refreshToken?: string | null }> = {};
+
+    for (const baseURL of this.getServers()) {
+      const key = this._key(baseURL);
+      const raw = typeof localStorage !== "undefined" ? localStorage.getItem(key) : null;
+      if (raw) result[baseURL] = JSON.parse(raw);
+    }
+    return result;
+  }
+}