@pi-spi/app 0.0.0-stage → 1.2.1

package/src/modules/transactions/infra/transaction_output_hive.ts

@@ -0,0 +1,91 @@
+import { AppStorage } from '../../../core/storage';
+import type { Stream } from '../../../core/stream';
+import { ListeMeta } from '../../../shared/models/liste_meta';
+import { Transaction, TransactionStatut } from '../domain/models/transaction';
+import { TransactionListe } from '../domain/models/transaction_liste';
+import type { TransactionListParams } from '../ports/output/transaction_output_port';
+
+/** Stockage local (chiffré) des transactions et des souscriptions */
+export class TransactionLocalHive {
+  static readonly collectionId = 'transactions';
+  static readonly collectionSchedule = 'subscriptions';
+
+  /** Lister les transactions à partir des données en local */
+  async list(params: TransactionListParams): Promise<TransactionListe> {
+    const { compte, compteAlias, limit, sens, dateOperationDebut, dateOperationFin, categories, subscriptionId, keyword } =
+      params;
+    let transactions = await AppStorage.list(TransactionLocalHive.collectionId, (json) => Transaction.fromJson(json));
+
+    // Uniquement les transactions irrévocables du compte
+    transactions = transactions.filter(
+      (tx) => tx.statut === TransactionStatut.irrevocable && tx.dateOperation != null && tx.compte === compte,
+    );
+    // Filtrer par alias
+    if (compteAlias != null) transactions = transactions.filter((tx) => tx.compteAlias === compteAlias);
+    if (subscriptionId != null) transactions = transactions.filter((tx) => tx.subscriptionId === subscriptionId);
+    // Filtrer par sens
+    if (sens != null && sens.length > 0) transactions = transactions.filter((tx) => sens.includes(tx.sens));
+    // Filtrer par catégorie
+    if (categories != null && categories.length > 0) {
+      transactions = transactions.filter((tx) => tx.categorie != null && categories.includes(tx.categorie));
+    }
+    // Filtrer par date
+    if (dateOperationDebut != null) {
+      transactions = transactions.filter((tx) => tx.dateOperation!.getTime() >= dateOperationDebut.getTime());
+    }
+    if (dateOperationFin != null) {
+      transactions = transactions.filter((tx) => tx.dateOperation!.getTime() <= dateOperationFin.getTime());
+    }
+    // Filtrer par mot-clé (montant exact, ou texte de la transaction)
+    if (keyword != null && keyword.trim().length > 0) {
+      const amount = Number(keyword);
+      if (!Number.isNaN(amount)) {
+        transactions = transactions.filter((tx) => tx.montant === amount);
+      } else {
+        transactions = transactions.filter((tx) => tx.toString().toLowerCase().indexOf(keyword.toLowerCase()) > 0);
+      }
+    }
+
+    // Les plus récentes d'abord
+    transactions.sort(compareByDateDesc);
+
+    // Retourner le nombre d'éléments demandé
+    if (limit != null && limit < transactions.length) {
+      return new TransactionListe(transactions.slice(0, limit), new ListeMeta({ total: transactions.length, limit }));
+    }
+    return new TransactionListe(transactions, new ListeMeta({ total: transactions.length, limit: transactions.length }));
+  }
+
+  /** Récupérer une transaction */
+  get(reference: string): Promise<Transaction | null> {
+    return AppStorage.get(TransactionLocalHive.collectionId, reference, (json) => Transaction.fromJson(json));
+  }
+
+  /** Enregistre une transaction dans la base locale */
+  async save(transaction: Transaction): Promise<void> {
+    await AppStorage.save(TransactionLocalHive.collectionId, transaction.endToEndId, transaction.toJson());
+  }
+
+  /** Met à jour une transaction dans la base locale (en conservant les données locales, ex. catégorie) */
+  async patch(transaction: Transaction): Promise<void> {
+    await AppStorage.patch(TransactionLocalHive.collectionId, transaction.endToEndId, transaction.toJson());
+  }
+
+  /** Écoute les changements de la liste des transactions */
+  stream(): Promise<Stream<Transaction[]>> {
+    return AppStorage.streamList(TransactionLocalHive.collectionId, (json) => Transaction.fromJson(json));
+  }
+
+  /** Enregistre une souscription dans la base locale */
+  async schedule(transaction: Transaction): Promise<void> {
+    await AppStorage.save(TransactionLocalHive.collectionSchedule, transaction.endToEndId, transaction.toJson());
+  }
+}
+
+/** Tri par date d'opération décroissante (sans date en dernier) */
+export function compareByDateDesc(a: Transaction, b: Transaction): number {
+  if (b.dateOperation == null && a.dateOperation == null) return 0;
+  if (b.dateOperation == null) return -1;
+  if (a.dateOperation == null) return 1;
+  return b.dateOperation.getTime() - a.dateOperation.getTime();
+}

package/src/modules/transactions/infra/transaction_output_remote.ts

@@ -0,0 +1,206 @@
+import { Api, ApiError, ApiException } from '../../../core/api';
+import { Logger } from '../../../core/logger';
+import { subscribeToSSE } from '../../../core/sse';
+import { coldStream, errorStream, type Stream } from '../../../core/stream';
+import { Transaction, TransactionStatut } from '../domain/models/transaction';
+import type { TransactionCancelReason } from '../domain/models/transaction_cancel_reason';
+import { TransactionListe } from '../domain/models/transaction_liste';
+import type { TransactionConfirmCommand } from '../domain/models/transaction_send/transaction_confirm_command';
+import type { TransactionSendCommand } from '../domain/models/transaction_send/transaction_send_command';
+import type { TransactionSendCommandSchedule } from '../domain/models/transaction_send/transaction_send_command_schedule';
+import { TransactionSendResponse } from '../domain/models/transaction_send/transaction_send_response';
+import type { TransactionListParams } from '../ports/output/transaction_output_port';
+import { compareByDateDesc } from './transaction_output_hive';
+
+/** Délai d'attente de la réponse SSE */
+const SSE_TIMEOUT_MS = 30_000;
+
+const noInternet = () =>
+  new ApiException({ error: ApiError.noInternetConnection, statusCode: -1, message: 'Pas de connexion Internet' });
+
+/** Date au format attendu par l'API : UTC, millisecondes, suffixe Z */
+function apiDate(date: Date): string {
+  return `${date.toISOString().substring(0, 23)}Z`;
+}
+
+function parseStatut(value: string): TransactionStatut {
+  return (Object.values(TransactionStatut) as string[]).includes(value)
+    ? (value as TransactionStatut)
+    : TransactionStatut.initie;
+}
+
+/** Accès à l'API des transferts */
+export class TransactionOutputRemote {
+  readonly logger = new Logger();
+
+  /** Lister les transactions */
+  async list(params: Omit<TransactionListParams, 'compteAlias' | 'categories'> & { alias?: string }): Promise<TransactionListe> {
+    const { compte, alias, page, limit, sortBy, fields, keyword, subscriptionId, sens, dateOperationDebut, dateOperationFin } =
+      params;
+    const queryParameters: Record<string, unknown> = { compte };
+    if (page != null) queryParameters.page = page;
+    if (limit != null) queryParameters.limit = limit;
+    if (sortBy != null) queryParameters.sortBy = sortBy;
+    if (fields != null) queryParameters.fields = fields;
+    if (alias != null) queryParameters.alias = alias;
+    if (keyword != null) queryParameters.keyword = keyword;
+    if (subscriptionId != null) queryParameters.subscriptionId = subscriptionId;
+    if (sens != null && sens.length > 0) queryParameters.sens = sens.length > 1 ? sens.join(',') : sens[0];
+    if (dateOperationDebut != null) queryParameters.dateDebut = apiDate(dateOperationDebut);
+    if (dateOperationFin != null) queryParameters.dateFin = apiDate(dateOperationFin);
+
+    const response = await Api.get('/transferts', { queryParameters });
+    const liste = TransactionListe.fromJson(response.data);
+    // Trier par date d'opération décroissante
+    liste.data.sort(compareByDateDesc);
+    return liste;
+  }
+
+  /** Récupérer une transaction */
+  async get(reference: string): Promise<Transaction> {
+    const response = await Api.get(`/transferts/${reference}/details`);
+    return Transaction.fromJson(response.data);
+  }
+
+  /** Initier une transaction */
+  async initiate(command: TransactionSendCommand): Promise<Transaction> {
+    if (!(await Api.hasNetworkConnection())) throw noInternet();
+    const response = await Api.post('/transferts', { data: command.toJson() });
+    return Transaction.fromJson(response.data);
+  }
+
+  /** Programmer une transaction */
+  async schedule(endToEndId: string, command: TransactionSendCommandSchedule): Promise<Transaction> {
+    if (!(await Api.hasNetworkConnection())) throw noInternet();
+    const response = await Api.post('/souscriptions', { data: { ...command.toJson(), endToEndId } });
+    return Transaction.fromJson(response.data);
+  }
+
+  /** En-têtes communs des requêtes SSE */
+  private sseHeaders(): Record<string, string> {
+    return { Accept: 'text/event-stream', 'Cache-Control': 'no-cache', Authorization: `Bearer ${Api.accessToken}` };
+  }
+
+  /** Confirmer une transaction : la réponse finale (irrévocable/rejetée) arrive par SSE. */
+  async confirm(endToEndId: string, command: TransactionConfirmCommand): Promise<Stream<Transaction>> {
+    if (!(await Api.hasNetworkConnection())) return errorStream(noInternet());
+    try {
+      const response = await Api.put(`/transferts/${endToEndId}`, { data: command.toJson() });
+      const transaction = Transaction.fromJson(response.data);
+      if (Api.config.api.demoMode) {
+        // Le flux de confirmation réel passe par du SSE (hors du client
+        // intercepté par le mock) : on simule une confirmation immédiate.
+        return coldStream(async (emit) => {
+          await delay(1000);
+          transaction.dateOperation = new Date();
+          transaction.statut = TransactionStatut.irrevocable;
+          emit(transaction);
+        });
+      }
+      return this.streamResponse(transaction, `/transferts/${transaction.endToEndId}/reponses`, (tx, ack) => {
+        tx.dateOperation = ack.dateIrrevocabilite;
+        tx.statut = parseStatut(ack.statut);
+        tx.statutRaison = ack.codeRejet;
+      }, (tx, error) => {
+        tx.statut = TransactionStatut.rejete;
+        tx.statutRaison = error;
+      });
+    } catch (e) {
+      this.logger.e('Reception reponse erreur', { error: e });
+      return errorStream(e);
+    }
+  }
+
+  /** Retourner les fonds : la réponse finale arrive par SSE. */
+  async returnFunds(transaction: Transaction): Promise<Stream<Transaction>> {
+    if (!(await Api.hasNetworkConnection())) return errorStream(noInternet());
+    try {
+      await Api.put(`/transferts/${transaction.endToEndId}/retours`);
+      if (Api.config.api.demoMode) {
+        // Même raison qu'en confirm() : on simule directement le retour de fonds.
+        return coldStream(async (emit) => {
+          await delay(1000);
+          if (transaction.endToEndId === 'ESNB00120240101153554Destinataire9e') {
+            transaction.retourStatut = TransactionStatut.rejete;
+            transaction.retourStatutRaison = 'AG10';
+          } else if (transaction.endToEndId === 'ESNB00120240101153554Participant19e') {
+            transaction.retourStatut = TransactionStatut.rejete;
+            transaction.retourStatutRaison = 'AM04';
+          } else {
+            transaction.annulationStatut = TransactionStatut.irrevocable;
+            transaction.retourStatut = TransactionStatut.irrevocable;
+            transaction.retourDate = new Date();
+          }
+          emit(transaction);
+        });
+      }
+      return this.streamResponse(transaction, `/transferts/${transaction.endToEndId}/retours/reponses`, (tx, ack) => {
+        tx.retourStatut = parseStatut(ack.statut);
+        tx.retourDate = ack.dateIrrevocabilite;
+        tx.retourStatutRaison = ack.codeRejet;
+      }, (tx, error) => {
+        tx.retourStatut = TransactionStatut.rejete;
+        tx.retourStatutRaison = error;
+      });
+    } catch (e) {
+      this.logger.e('Reception reponse retour de fonds erreur', { error: e });
+      return errorStream(e);
+    }
+  }
+
+  /**
+   * Écoute la réponse SSE [path] : applique la première réponse valide à
+   * [transaction] et l'émet, puis ferme le flux (timeout 30 s). Une donnée
+   * illisible émet la transaction en erreur (« Invalid data format »).
+   */
+  private streamResponse(
+    transaction: Transaction,
+    path: string,
+    apply: (tx: Transaction, ack: TransactionSendResponse) => void,
+    applyError: (tx: Transaction, error: string) => void,
+  ): Stream<Transaction> {
+    return {
+      listen: (listener, onError) => {
+        const subscription = subscribeToSSE({
+          url: `${Api.url}${path}`,
+          headers: this.sseHeaders(),
+          timeoutMs: SSE_TIMEOUT_MS,
+          onEvent: (event) => {
+            if (event.data == null) return;
+            this.logger.i(`Received response => ${event.data}`);
+            try {
+              apply(transaction, TransactionSendResponse.fromJson(JSON.parse(event.data)));
+              listener(transaction);
+              // Arrêter le flux après la première réponse valide
+              subscription.close();
+            } catch (e) {
+              this.logger.e('Data parsing error', { error: e });
+              applyError(transaction, 'Invalid data format');
+              listener(transaction);
+            }
+          },
+          onError: (error) => onError?.(error),
+        });
+        return () => subscription.close();
+      },
+    };
+  }
+
+  /** Demander l'annulation d'une transaction */
+  async cancel(transaction: Transaction, reason: TransactionCancelReason): Promise<Transaction> {
+    if (!(await Api.hasNetworkConnection())) throw noInternet();
+    const response = await Api.put(`/transferts/${transaction.endToEndId}/annulations`, { data: { raison: reason } });
+    return Transaction.fromJson(response.data);
+  }
+
+  /** Rejeter une transaction (demande de paiement ou d'annulation) */
+  async reject(transaction: Transaction, reason: string): Promise<Transaction> {
+    if (!(await Api.hasNetworkConnection())) throw noInternet();
+    const response = await Api.put(`/transferts/${transaction.endToEndId}/rejets`, { data: { raison: reason } });
+    return Transaction.fromJson(response.data);
+  }
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/modules/transactions/infra/transaction_output_repository.ts

@@ -0,0 +1,88 @@
+import { Logger } from '../../../core/logger';
+import type { Stream } from '../../../core/stream';
+import { TransactionStatut, type Transaction } from '../domain/models/transaction';
+import type { TransactionCancelReason } from '../domain/models/transaction_cancel_reason';
+import type { TransactionListe } from '../domain/models/transaction_liste';
+import type { TransactionConfirmCommand } from '../domain/models/transaction_send/transaction_confirm_command';
+import type { TransactionSendCommand } from '../domain/models/transaction_send/transaction_send_command';
+import type { TransactionSendCommandSchedule } from '../domain/models/transaction_send/transaction_send_command_schedule';
+import type { TransactionListParams, TransactionOutputPort } from '../ports/output/transaction_output_port';
+import { TransactionLocalHive } from './transaction_output_hive';
+import { TransactionOutputRemote } from './transaction_output_remote';
+
+/** Dépôt des transactions : serveur + copie locale (catégories, mode hors ligne) */
+export class TransactionOutputRepository implements TransactionOutputPort {
+  readonly logger = new Logger();
+  readonly repoRemote = new TransactionOutputRemote();
+  /** Pour enregistrer les données localement */
+  readonly repoLocal = new TransactionLocalHive();
+
+  async search(params: TransactionListParams): Promise<TransactionListe> {
+    // Récupérer sur le serveur et mettre à jour la copie locale
+    const liste = await this.repoRemote.list({ ...params, alias: params.compteAlias });
+    for (const tx of liste.data) void this.repoLocal.patch(tx);
+    return liste;
+  }
+
+  list(params: TransactionListParams): Promise<TransactionListe> {
+    return this.repoLocal.list(params);
+  }
+
+  initiate(command: TransactionSendCommand): Promise<Transaction> {
+    return this.repoRemote.initiate(command);
+  }
+
+  async confirm(command: TransactionConfirmCommand): Promise<Stream<Transaction>> {
+    const result = await this.repoRemote.confirm(command.endToendId, command);
+    return {
+      listen: (listener, onError) =>
+        result.listen((event) => {
+          if (event.statut === TransactionStatut.irrevocable) void this.repoLocal.save(event);
+          listener(event);
+        }, onError),
+    };
+  }
+
+  async schedule(endToEndId: string, command: TransactionSendCommandSchedule): Promise<Transaction> {
+    const transaction = await this.repoRemote.schedule(endToEndId, command);
+    void this.repoLocal.schedule(transaction);
+    return transaction;
+  }
+
+  /** Mise à jour locale */
+  update(transaction: Transaction): Promise<void> {
+    return this.repoLocal.save(transaction);
+  }
+
+  /** Retourner les fonds après une transaction reçue */
+  returnFunds(transaction: Transaction): Promise<Stream<Transaction>> {
+    return this.repoRemote.returnFunds(transaction);
+  }
+
+  async cancel(transaction: Transaction, reason: TransactionCancelReason): Promise<Transaction> {
+    const updated = await this.repoRemote.cancel(transaction, reason);
+    await this.repoLocal.save(updated);
+    // On retourne la donnée locale (informations uniquement locales, ex. catégorie)
+    return (await this.repoLocal.get(updated.endToEndId))!;
+  }
+
+  /** Récupérer une transaction sur le serveur (en conservant les données locales) */
+  async get(reference: string): Promise<Transaction> {
+    const serveur = await this.repoRemote.get(reference);
+    // On actualise la donnée locale
+    await this.repoLocal.patch(serveur);
+    // On retourne la donnée locale (informations uniquement locales, ex. catégorie)
+    return (await this.fetch(reference)) ?? serveur;
+  }
+
+  /** Récupérer une transaction en local */
+  fetch(reference: string): Promise<Transaction | null> {
+    return this.repoLocal.get(reference);
+  }
+
+  async reject(transaction: Transaction, reason: string): Promise<Transaction> {
+    const updated = await this.repoRemote.reject(transaction, reason);
+    await this.repoLocal.save(updated);
+    return (await this.repoLocal.get(updated.endToEndId))!;
+  }
+}

package/src/modules/transactions/ports/input/participant_input_port.ts

@@ -0,0 +1,9 @@
+import type { Participant } from '../../domain/models/participant/participant';
+
+export interface ParticipantInputPort {
+  /** Récupérer la liste des participants (remote) */
+  search(): Promise<Participant[]>;
+
+  /** Lister les participants (local) */
+  list(): Promise<Participant[]>;
+}

package/src/modules/transactions/ports/input/transaction_input_port.ts

@@ -0,0 +1,45 @@
+import type { Stream } from '../../../../core/stream';
+import type { Transaction } from '../../domain/models/transaction';
+import type { TransactionCancelReason } from '../../domain/models/transaction_cancel_reason';
+import type { TransactionListe } from '../../domain/models/transaction_liste';
+import type { TransactionRejectReason } from '../../domain/models/transaction_reject_reason';
+import type { TransactionConfirmCommand } from '../../domain/models/transaction_send/transaction_confirm_command';
+import type { TransactionSendCommand } from '../../domain/models/transaction_send/transaction_send_command';
+import type { TransactionSendCommandSchedule } from '../../domain/models/transaction_send/transaction_send_command_schedule';
+import type { TransactionListParams } from '../output/transaction_output_port';
+
+/** Expose les services offerts dans la gestion des transactions */
+export interface TransactionInputPort {
+  /** Lister les transactions (local) */
+  list(params: TransactionListParams): Promise<TransactionListe>;
+
+  /** Rechercher (remote) */
+  search(params: TransactionListParams): Promise<TransactionListe>;
+
+  /** Initier une transaction */
+  initiate(command: TransactionSendCommand): Promise<Transaction>;
+
+  /** Confirmer une transaction */
+  confirm(command: TransactionConfirmCommand): Promise<Stream<Transaction>>;
+
+  /** Programmer une transaction */
+  schedule(endToEndId: string, command: TransactionSendCommandSchedule): Promise<Transaction>;
+
+  /** Mettre à jour les détails d'une transaction (local) */
+  update(transaction: Transaction): Promise<void>;
+
+  /** Retourner les fonds après une transaction reçue */
+  returnFunds(transaction: Transaction): Promise<Stream<Transaction>>;
+
+  /** Demander l'annulation d'une transaction */
+  cancel(transaction: Transaction, reason: TransactionCancelReason): Promise<Transaction>;
+
+  /** Récupérer une transaction à partir de la référence sur le serveur */
+  get(reference: string): Promise<Transaction>;
+
+  /** Récupérer une transaction à partir de la référence en local */
+  fetch(reference: string): Promise<Transaction | null>;
+
+  /** Rejeter une transaction : annulation ou paiement */
+  reject(transaction: Transaction, reason: TransactionRejectReason): Promise<Transaction>;
+}

package/src/modules/transactions/ports/output/participant_output_port.ts

@@ -0,0 +1,9 @@
+import type { Participant } from '../../domain/models/participant/participant';
+
+export interface ParticipantOutputPort {
+  /** Récupérer la liste des participants (remote) */
+  search(): Promise<Participant[]>;
+
+  /** Lister les participants (local) */
+  list(): Promise<Participant[]>;
+}

package/src/modules/transactions/ports/output/transaction_output_port.ts

@@ -0,0 +1,60 @@
+import type { Stream } from '../../../../core/stream';
+import type { Transaction } from '../../domain/models/transaction';
+import type { TransactionCancelReason } from '../../domain/models/transaction_cancel_reason';
+import type { TransactionListe } from '../../domain/models/transaction_liste';
+import type { TransactionConfirmCommand } from '../../domain/models/transaction_send/transaction_confirm_command';
+import type { TransactionSendCommand } from '../../domain/models/transaction_send/transaction_send_command';
+import type { TransactionSendCommandSchedule } from '../../domain/models/transaction_send/transaction_send_command_schedule';
+
+/** Critères de liste / recherche de transactions */
+export type TransactionListParams = {
+  compte: string;
+  compteAlias?: string;
+  /** Numéro de page (number) ou curseur (string) */
+  page?: number | string | null;
+  limit?: number;
+  sortBy?: string;
+  fields?: string;
+  sens?: string[];
+  dateOperationDebut?: Date;
+  dateOperationFin?: Date;
+  categories?: string[];
+  subscriptionId?: string;
+  keyword?: string;
+};
+
+/** Interagir avec le système de sauvegarde des transactions */
+export interface TransactionOutputPort {
+  /** Lister les transactions (local) */
+  list(params: TransactionListParams): Promise<TransactionListe>;
+
+  /** Rechercher des transactions (remote) */
+  search(params: TransactionListParams): Promise<TransactionListe>;
+
+  /** Initier une transaction */
+  initiate(command: TransactionSendCommand): Promise<Transaction>;
+
+  /** Confirmer une transaction */
+  confirm(command: TransactionConfirmCommand): Promise<Stream<Transaction>>;
+
+  /** Programmer une transaction */
+  schedule(endToEndId: string, command: TransactionSendCommandSchedule): Promise<Transaction>;
+
+  /** Enregistrer une transaction */
+  update(transaction: Transaction): Promise<void>;
+
+  /** Retourner les fonds après une transaction reçue */
+  returnFunds(transaction: Transaction): Promise<Stream<Transaction>>;
+
+  /** Demander l'annulation d'une transaction */
+  cancel(transaction: Transaction, reason: TransactionCancelReason): Promise<Transaction>;
+
+  /** Récupérer une transaction à partir de la référence sur le serveur */
+  get(reference: string): Promise<Transaction>;
+
+  /** Récupérer une transaction à partir de la référence en local */
+  fetch(reference: string): Promise<Transaction | null>;
+
+  /** Rejeter une transaction */
+  reject(transaction: Transaction, reason: string): Promise<Transaction>;
+}