@pi-spi/app 0.0.0-stage → 1.2.1

package/src/core/api_mock.ts

@@ -0,0 +1,640 @@
+import type { AxiosInstance, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+
+import { mockJsonFiles } from './api_mock_data';
+import { Logger } from './logger';
+import type { PiSpiSdkConfig } from './pi_spi_sdk_config';
+
+type Json = Record<string, any>;
+
+/**
+ * Simple API Mock interceptor.
+ * Only for demo purposes.
+ *
+ * Côté axios, il remplace l'adapter HTTP du client : aucune requête ne
+ * quitte le téléphone, et chaque réponse est construite à partir des
+ * fichiers de `assets/json/` (les mêmes que dans le SDK Flutter). Comme
+ * avec `handler.resolve()` en Dio, les réponses mockées ne passent pas par
+ * la validation du statut HTTP : un 404 mocké arrive tel quel à `Api.get`.
+ */
+export class MockInterceptor {
+  static readonly logger = new Logger();
+
+  static readonly httpGet = 'GET';
+  static readonly httpPost = 'POST';
+  static readonly httpDelete = 'DELETE';
+  static readonly httpPut = 'PUT';
+
+  static apiResponses: Record<string, string> = {
+    path: 'jsonFile',
+    '/participants': 'transferts/get_participants.json',
+  };
+
+  static readonly transactions: Record<string, string> = {
+    // Transferts
+    ESNB00120230818141522TRANS633Alias9: 'transferts/get_transfert_emis_alias.json',
+    ECIB00020240221183554TRANSreIBAN1e0: 'transferts/get_transfert_recu_iban.json',
+    ESNB0012023082415355TRANSEmCNvhUk9e: 'transferts/get_transfert_emis_compte.json',
+    ESNB0012023021915355TRANSrecAlias7a: 'transferts/get_transfert_recu_alias.json',
+    ESNB00120240518153554TRANS401Factk9: 'transferts/get_transfert_emis_401.json',
+    ESNB00120240105153554CancelpNvhUk9e: 'transferts/get_annulation.json',
+    ESNB00120230219153554KXvozkpNvhUccc: 'transferts/get_echouee.json',
+
+    // RTP
+    ESNB00120230221153554RTPok1pNvhUk9e: 'transferts/get_rtp_initiee.json',
+    ESNB00120230221153554RTPre631vhUk9e: 'transferts/get_rtp_recue_631.json',
+    ESNB00120240518153554RTPre631Split1: 'transferts/get_rtp_recue_631_split.json',
+    ESNB00120240518153554RTPre500PICO01: 'transferts/get_rtp_recue_500_pico.json',
+    ESNB00120240518153554RTPre500PICASH: 'transferts/get_rtp_recue_500_picash.json',
+    ESNB00120240518153554RTPre500DebitD: 'transferts/get_rtp_recue_500_debitdiff.json',
+    ESNB00120240518153554RTPre521DebitD: 'transferts/get_rtp_recue_521_debitdiff.json',
+    ESNB00120240518153554RTPre401vhUk9e: 'transferts/get_rtp_recue_401.json',
+
+    // Default (ajouté à la fin)
+    default: 'transferts/get_transfert_emis_alias.json',
+  };
+
+  /** Liste des souscriptions (gardée en mémoire après le premier GET, pour refléter les suppressions). */
+  subscriptions?: Json;
+
+  /**
+   * Alias du démo, par compte (un compte absent de cette map n'a pas
+   * d'alias). Permet au parcours de création d'alias (avec ses propres
+   * mocks POST/PUT) d'être réellement accessible pour un compte donné,
+   * au lieu d'être court-circuité par un alias systématiquement déjà
+   * existant — et au carrousel multi-comptes de l'accueil de refléter un
+   * état différent par compte (voir HomeCompteCarousel).
+   */
+  private readonly demoAliasByCompte = new Map<string, Json>();
+
+  /**
+   * Association cle d'alias → compte, pour retrouver le bon compte à
+   * effacer de {@link demoAliasByCompte} sur DELETE /alias/{cle} (l'API ne
+   * prend que la cle, pas le compte).
+   */
+  private readonly demoAliasCleToCompte = new Map<string, string>();
+
+  /**
+   * Comptes déjà "résolus" au moins une fois (amorcés avec
+   * get_alias.json, ou confirmés sans alias) — pour ne jamais ré-amorcer
+   * un alias qu'on vient de supprimer, tout en ne le faisant qu'une seule
+   * fois par compte.
+   */
+  private readonly resolvedComptes = new Set<string>();
+
+  /** [config] : la configuration du SDK (comptes de l'hôte, compte par défaut). */
+  constructor(private readonly config: PiSpiSdkConfig) {}
+
+  attach(client: AxiosInstance): void {
+    client.defaults.adapter = (options) => this.onRequest(options);
+  }
+
+  /** Copie fraîche d'un fichier de `assets/json/` (comme un `jsonDecode` à chaque lecture en Dart). */
+  async retrieveData(resourcePath: string): Promise<any> {
+    const data = mockJsonFiles[resourcePath];
+    if (data === undefined) throw new Error(`Fichier de démo introuvable : assets/json/${resourcePath}`);
+    return JSON.parse(JSON.stringify(data));
+  }
+
+  async onRequest(options: InternalAxiosRequestConfig): Promise<AxiosResponse> {
+    const path = options.url ?? '';
+    // Réponse spécifique pour les requêtes /alias
+    if (path.startsWith('/alias')) {
+      return this.alias(options);
+    }
+    // Réponse spécifique pour les requêtes sur les comptes
+    else if (path.startsWith('/comptes')) {
+      return this.comptes(options);
+    }
+    // Réponse spécifique pour les requêtes sur les transactions
+    else if (path.startsWith('/transferts')) {
+      return this.transferts(options);
+    }
+    // Réponse spécifique pour les requêtes sur les subscriptions
+    else if (path.startsWith('/souscriptions')) {
+      return this.subscriptionsResource(options);
+    }
+    //
+    else if (path.startsWith('/notifications')) {
+      return this.notifications(options);
+    }
+    //
+    else if (path.startsWith('/otps')) {
+      return response(options, 200);
+    }
+    //
+    else {
+      const filePath = MockInterceptor.apiResponses[path];
+      if (filePath == null) {
+        return response(options, 404);
+      }
+      return response(options, 200, await this.retrieveData(filePath));
+    }
+  }
+
+  /** Mock Alias Resource */
+  private async alias(options: InternalAxiosRequestConfig): Promise<AxiosResponse> {
+    const path = options.url ?? '';
+    const method = method_(options);
+    if (method === MockInterceptor.httpPost) {
+      // Accédez au contenu du corps de la requête
+      const requestBody = body(options);
+
+      if (path === '/alias/revendications') {
+        const data = await this.retrieveData('alias/revendications_post.json');
+        return delayed(500, () => response(options, 201, data));
+      }
+      // Creer alias
+      else {
+        const type = String(requestBody.type);
+        const data = await this.retrieveData(
+          `alias/${method.toLowerCase()}_${path.substring(1)}_${type.toLowerCase()}.json`,
+        );
+        // Un alias SHID est immédiatement finalisé (pas de confirmation
+        // OTP, contrairement au MBNO confirmé via PUT plus bas).
+        if (type.toLowerCase() === 'shid') {
+          const compte = String(requestBody.compte);
+          // Le fixture a un "compte" figé : on le remplace par le vrai
+          // compte demandé, sinon Alias.compte ne correspondrait plus à
+          // Di.activeCompte (ex. redirect de /home, carrousel, etc.).
+          data.compte = compte;
+          this.demoAliasByCompte.set(compte, data);
+          this.demoAliasCleToCompte.set(String(data.cle), compte);
+          this.resolvedComptes.add(compte);
+        }
+        return delayed(500, () => response(options, 201, data));
+      }
+    }
+    // PUT
+    else if (method === MockInterceptor.httpPut) {
+      const requestBody = body(options);
+
+      if (path.startsWith('/alias/revendications')) {
+        // Accepter ou rejeter revendication
+        if (path.endsWith('reponses')) {
+          return response(options, 200, await this.retrieveData('alias/revendications_put_reponses.json'));
+        }
+        // Confirmer rejet revendication
+        else {
+          return response(options, 200, await this.retrieveData('alias/revendications_put_rejets.json'));
+        }
+      } else {
+        const cle = requestBody.cle;
+        // Simulate Bad request code otp invalide
+        if (cle === '+2250788495430') {
+          return response(options, 400);
+        }
+        // Le numéro de téléphone existe déjà
+        else if (cle === '+221775177020') {
+          return response(options, 403);
+        }
+        // Serveur indisponible
+        else if (cle === '+221775177021') {
+          return response(options, 503);
+        }
+        //
+        else {
+          // Confirmation OTP réussie : l'alias MBNO est maintenant créé.
+          const data = await this.retrieveData('alias/post_alias_mbno.json');
+          const compte = String(requestBody.compte);
+          // Le fixture a un "compte" figé : on le remplace par le vrai
+          // compte demandé (voir plus haut).
+          data.compte = compte;
+          this.demoAliasByCompte.set(compte, data);
+          this.demoAliasCleToCompte.set(String(data.cle), compte);
+          this.resolvedComptes.add(compte);
+          return response(options, 201, data);
+        }
+      }
+    }
+    // Delete alias
+    else if (method === MockInterceptor.httpDelete) {
+      // Le path est /alias/{cle} : on retrouve le compte correspondant
+      // pour l'effacer de demoAliasByCompte.
+      const cle = lastSegment(path);
+      const compte = this.demoAliasCleToCompte.get(cle);
+      this.demoAliasCleToCompte.delete(cle);
+      if (compte != null) this.demoAliasByCompte.delete(compte);
+      return delayed(1000, () => response(options, 204));
+    }
+    // Mock recupere alias user : seul le compte par défaut de l'hôte
+    // (currentAccount, ou comptes[0] à défaut — le même calcul que
+    // Di.activeCompte au démarrage) démarre avec un alias déjà existant
+    // (get_alias.json), pour préserver le comportement par défaut du
+    // reste de la démo (QR code, transferts, ...). Tous les autres
+    // comptes démarrent sans alias, y compris celui choisi en premier
+    // dans l'écran de sélection. Ça permet au carrousel multi-comptes de
+    // l'accueil de réellement montrer un compte sans alias. Si
+    // l'utilisateur supprime l'alias amorcé, ou pour tout compte sans
+    // alias, on renvoie vraiment 404 pour que le parcours de création
+    // (avec ses propres mocks POST/PUT) soit réellement accessible.
+    else if (method === MockInterceptor.httpGet && !path.startsWith('/alias/revendications')) {
+      const compte = lastSegment(path);
+      if (!this.resolvedComptes.has(compte)) {
+        this.resolvedComptes.add(compte);
+        const defaultCompte = this.config.user.currentAccount ?? this.config.user.comptes[0].numero;
+        if (compte === defaultCompte) {
+          const data = await this.retrieveData('alias/get_alias.json');
+          data.compte = compte;
+          this.demoAliasByCompte.set(compte, data);
+          this.demoAliasCleToCompte.set(String(data.cle), compte);
+        }
+      }
+      const alias = this.demoAliasByCompte.get(compte);
+      if (alias == null) {
+        return response(options, 404);
+      }
+      return response(options, 200, alias);
+    }
+    // Get /alias/revendications
+    else {
+      if (path.startsWith('/alias/revendications')) {
+        const data = await this.retrieveData(`alias/revendications_${path.split('/')[3]}.json`);
+        return response(options, 200, data);
+      } else {
+        // Pour dire que le client n'a pas d'alias
+        return response(options, 404);
+      }
+    }
+  }
+
+  /** Mock Comptes Resource */
+  private async comptes(options: InternalAxiosRequestConfig): Promise<AxiosResponse> {
+    const path = options.url ?? '';
+    if (method_(options) === MockInterceptor.httpGet) {
+      const isSolde = path.endsWith('soldes');
+      const resource = isSolde ? 'solde' : 'details';
+      const data = await this.retrieveData(`comptes/get_compte_${resource}.json`);
+      if (isSolde) {
+        // /comptes/{compte}/soldes : le fixture a un solde figé, on le
+        // remplace par celui du compte réellement demandé (fourni par
+        // l'hôte via PiSpiCompte), sinon tous les comptes du carrousel
+        // afficheraient le même solde.
+        const compte = path.split('/')[2];
+        const matching = this.config.user.comptes.find((c) => c.numero === compte);
+        if (matching) {
+          data.solde = matching.solde;
+        }
+      }
+      return response(options, 200, data);
+    } else {
+      return response(options, 404);
+    }
+  }
+
+  /** Mock Transferts Resource */
+  private async transferts(options: InternalAxiosRequestConfig): Promise<AxiosResponse> {
+    const path = options.url ?? '';
+    const method = method_(options);
+    // Liste des transaction
+    if (method === MockInterceptor.httpGet) {
+      let data: Json | undefined;
+      // Details d'une transaction
+      if (path.endsWith('details')) {
+        data = await this.detailsTransfert(options);
+      }
+      // Liste des transactions
+      else {
+        const res = await this.retrieveData('transferts/get_transferts_search.json');
+        let transactions: Json[] = res.data;
+        // Sort list
+        transactions.sort((a, b) => Date.parse(b.dateOperation) - Date.parse(a.dateOperation));
+        const params: Json = options.params ?? {};
+        const sens = params.sens as string | string[] | undefined;
+        const dateDebut = params.dateDebut as string | undefined;
+        const dateFin = params.dateFin as string | undefined;
+        const subscriptionId = params.subscriptionId as string | undefined;
+        // Filter by Sens
+        if (sens != null) {
+          const hasDebit = sens.includes('debit');
+          const hasCredit = sens.includes('credit');
+          if (hasDebit && !hasCredit) {
+            transactions = transactions.filter((tx) => tx.sens === 'debit');
+          } else if (hasCredit && !hasDebit) {
+            transactions = transactions.filter((tx) => tx.sens === 'credit');
+          }
+        }
+        // Filter by date debut
+        if (dateDebut != null) {
+          transactions = transactions.filter((tx) => Date.parse(tx.dateOperation) >= Date.parse(dateDebut));
+        }
+        // Filter by date fin
+        if (dateFin != null) {
+          transactions = transactions.filter((tx) => Date.parse(tx.dateOperation) <= Date.parse(dateFin));
+        }
+        // Filtrer par abonnement
+        if (subscriptionId != null) {
+          transactions = transactions.filter((tx) => tx.subscriptionId === subscriptionId);
+          return delayed(1000, () =>
+            response(options, 200, {
+              data: transactions,
+              meta: { total: transactions.length, limit: 1, page: 0 },
+            }),
+          );
+        }
+        // Limit
+        const limit = Number(params.limit ?? 5);
+        const page = Number(params.page ?? 0);
+        data = {
+          data: transactions.slice(page * limit, page * limit + limit),
+          meta: { total: res.meta.total, limit, page },
+        };
+      }
+      return delayed(1000, () => response(options, 200, data));
+    }
+    // Initier un transfert
+    else if (method === MockInterceptor.httpPost) {
+      // Accédez au contenu du corps de la requête
+      const requestBody = body(options);
+      let responseFile: string | undefined;
+      // Simuler paiement par qrcode
+      if (requestBody.canal === '000') {
+        responseFile = 'post_transfert_qrcode';
+      }
+      // RTP
+      else if (requestBody.canal === '631') {
+        responseFile = 'post_rtp_201';
+      }
+      // Transfert : simuler transfert par alias
+      else if (requestBody.alias != null) {
+        responseFile = 'post_transfert_alias';
+      }
+      // Simuler transfert par iban
+      else if (requestBody.iban != null) {
+        responseFile = 'post_transfert_iban';
+      }
+      // Simuler transfert par othr
+      else if (requestBody.othr != null) {
+        responseFile = 'post_transfert_othr';
+      }
+
+      const data = await this.retrieveData(`transferts/${responseFile}.json`);
+      return delayed(300, () => response(options, 201, data));
+    }
+    // Confirmer transfert
+    // (apres recherche d'alias ou accepter demande de paiement)
+    else if (method === MockInterceptor.httpPut) {
+      // Accédez au contenu du corps de la requête
+      const requestBody = body(options);
+      let data: Json | undefined;
+      // Retours de fonds
+      if (path.endsWith('retours')) {
+        // Simuler Solde insuffisant
+        if (path.includes('ESNB00120240221153554SoldekpNvhUk9e')) {
+          return delayed(1000, () => response(options, 403, problem403('Solde insuffisant', 'solde')));
+        }
+        // Simuler Delai dépassé pour le retour de fonds
+        if (path.includes('ESNB00120240101153554DelaikpNvhUk9e')) {
+          return delayed(1000, () => response(options, 403, problem403('Délai dépassé', 'date')));
+        }
+        // Simuler Delai dépassé pour le statut retour deja effectué
+        if (path.includes('ESNB00120240101153554StatutpNvhUk9e')) {
+          return delayed(1000, () => response(options, 403, problem403('Déjà retourné', 'statut')));
+        }
+        // Simuler retour de fonds
+        else {
+          data = await this.retrieveData('transferts/put_return.json');
+        }
+      }
+      // Annulation
+      else if (path.endsWith('annulations')) {
+        data = await this.retrieveData('transferts/put_annulation.json');
+      }
+      // Rejets
+      else if (path.endsWith('rejets')) {
+        data = await this.detailsTransfert(options);
+        // Demande d'annulation (y compris les scénarios de démo, dont la référence ne contient pas « Cancel »)
+        if (data != null && data.annulationDate != null) {
+          data.annulationStatut = 'rejete';
+          data.annulationStatutRaison = requestBody.raison;
+        }
+        if (data != null && path.includes('RTP')) {
+          data.statut = 'rejete';
+          data.statutRaison = requestBody.raison;
+        }
+      }
+      // Confirmer transfert
+      else {
+        if (path.includes('RTP')) {
+          data = await this.detailsTransfert(options);
+        } else {
+          data = await this.retrieveData('transferts/put_confirmation.json');
+        }
+      }
+      return delayed(1000, () => response(options, 200, data));
+    } else {
+      return response(options, 404);
+    }
+  }
+
+  /**
+   * Demandes d'annulation reçues des notifications de démo (scénarios de
+   * rejet du retour de fonds) : chacune est servie à partir de
+   * `get_annulation.json`, avec sa propre référence, son montant et son
+   * demandeur. Sans cela, ces demandes retombaient sur le transfert par
+   * défaut, sans boutons Rejeter / Accepter.
+   */
+  static readonly cancelScenarios: Record<string, { montant: number; clientNom: string }> = {
+    ESNB00120240221153554SoldekpNvhUk9e: { montant: 5000000, clientNom: 'SeiniRejet SoldePouye' },
+    ESNB00120240101153554DelaikpNvhUk9e: { montant: 1000, clientNom: 'ChrisRejet Delai' },
+    ESNB00120240101153554StatutpNvhUk9e: { montant: 1000, clientNom: 'DouRejet Statut' },
+    ESNB00120240101153554Destinataire9e: { montant: 1000, clientNom: 'DouRejet Destinataire' },
+    ESNB00120240101153554Participant19e: { montant: 1000, clientNom: 'DouRejet Lui même' },
+  };
+
+  /** Retourne les details d'un transfert */
+  private async detailsTransfert(options: InternalAxiosRequestConfig): Promise<Json | undefined> {
+    const path = options.url ?? '';
+    const scenario = Object.keys(MockInterceptor.cancelScenarios).find((k) => path.includes(k));
+    if (scenario != null) {
+      const data = await this.retrieveData('transferts/get_annulation.json');
+      return { ...data, ...MockInterceptor.cancelScenarios[scenario], endToEndId: scenario };
+    }
+    const key = Object.keys(MockInterceptor.transactions).find((k) => path.includes(k)) ?? 'default';
+    const data = await this.retrieveData(MockInterceptor.transactions[key]);
+    return key.includes('RTP') ? shiftRtpDates(data) : data;
+  }
+
+  /** Mock Subscriptions Resource */
+  private async subscriptionsResource(options: InternalAxiosRequestConfig): Promise<AxiosResponse> {
+    const path = options.url ?? '';
+    const method = method_(options);
+    if (method === MockInterceptor.httpPost) {
+      const requestBody = body(options);
+      let data: Json;
+      if (requestBody.dateFin != null) {
+        data = await this.retrieveData('transferts/put_abonnement_fin.json');
+      } else if (requestBody.frequence != null) {
+        data = await this.retrieveData('transferts/put_abonnement_frequence.json');
+      } else {
+        data = await this.retrieveData('transferts/put_abonnement_once.json');
+      }
+      return delayed(1000, () => response(options, 200, data));
+    }
+    // Lister
+    else if (method === MockInterceptor.httpGet) {
+      if (this.subscriptions == null) {
+        this.subscriptions = await this.retrieveData('subscriptions/get_liste.json');
+      }
+      const data = JSON.parse(JSON.stringify(this.subscriptions));
+      return delayed(1000, () => response(options, 200, data));
+    }
+    // Desactiver Reactiver
+    else if (method === MockInterceptor.httpPut) {
+      const id = path.split('/')[2];
+      const res = await this.retrieveData('subscriptions/get_liste.json');
+      const transactions: Json[] = res.data;
+      const tx = transactions.find((t) => t.endToEndId === id);
+      if (tx == null) return response(options, 404);
+      if (path.endsWith('desactivations')) {
+        tx.statut = 'desactive';
+      } else if (path.endsWith('reactivations')) {
+        tx.statut = 'initie';
+      }
+      // Note
+      else {
+        tx.motif = body(options).motif;
+      }
+      return delayed(1000, () => response(options, 200, tx));
+    }
+    // Supprimer
+    else if (method === MockInterceptor.httpDelete) {
+      const id = path.split('/')[2];
+      if (this.subscriptions != null) {
+        this.subscriptions.data = (this.subscriptions.data as Json[]).filter((s) => s.endToEndId !== id);
+      }
+      return delayed(1000, () => response(options, 204));
+    }
+    // Default not found
+    else {
+      return response(options, 404);
+    }
+  }
+
+  /** Mock Notifications Resource */
+  /**
+   * Notifications lues pendant la session de démo (id → date de lecture),
+   * pour que « Non lues », les anneaux et le badge reflètent les lectures.
+   */
+  private readonly readNotifications = new Map<string, string>();
+
+  /** Notifications de démo d'une option de filtre, avec les lectures de la session */
+  private async notificationsFor(option: string): Promise<Json[] | null> {
+    let list: Json[];
+    // « Tous » et « Non lues » : toutes les notifications (get_liste.json),
+    // les autres options : get_liste_by_type.json
+    if (option === 'TOUT' || option === 'NON_LUE') {
+      list = (await this.retrieveData('notifications/get_liste.json')).data;
+    } else {
+      const byType = (await this.retrieveData('notifications/get_liste_by_type.json'))[option];
+      if (byType == null) return null;
+      list = byType.data;
+    }
+    for (const n of list) {
+      const read = this.readNotifications.get(n.id);
+      if (read != null) n.dateLecture = read;
+    }
+    return option === 'NON_LUE' ? list.filter((n) => n.dateLecture == null) : list;
+  }
+
+  /** Mock Notifications Resource */
+  private async notifications(options: InternalAxiosRequestConfig): Promise<AxiosResponse> {
+    const path = options.url ?? '';
+    const method = method_(options);
+    if (method === MockInterceptor.httpGet && path.endsWith('/non-lues')) {
+      const unread = (await this.notificationsFor('NON_LUE')) ?? [];
+      return delayed(1000, () => response(options, 200, { total: unread.length }));
+    }
+    // Get liste
+    else if (method === MockInterceptor.httpGet) {
+      const params: Json = options.params ?? {};
+      const notificationsList = await this.notificationsFor(String(params.option ?? 'TOUT'));
+      if (notificationsList == null) {
+        return delayed(1000, () => response(options, 200, { data: [], meta: { total: 0, limit: 20 } }));
+      }
+      const limit = Number(params.limit ?? 5);
+      const page = Number(params.page ?? 0);
+      notificationsList.sort((a, b) => Date.parse(b.dateAction) - Date.parse(a.dateAction));
+      const toReturn: Json = {
+        data: notificationsList.slice(page * limit, page * limit + limit),
+        meta: { total: notificationsList.length, limit, page },
+      };
+      return delayed(1000, () => response(options, 200, toReturn));
+    }
+    // Marquer comme lu
+    else if (method === MockInterceptor.httpPut) {
+      const data = await this.retrieveData('notifications/get_liste.json');
+      const id = path.split('/')[2];
+      const notif = (data.data as Json[]).find((e) => e.id === id);
+      if (notif == null) return response(options, 404);
+      notif.dateLecture = this.readNotifications.get(id) ?? new Date().toISOString();
+      this.readNotifications.set(id, notif.dateLecture);
+      return delayed(1000, () => response(options, 200, notif));
+    }
+    // Other
+    else {
+      return response(options, 404);
+    }
+  }
+}
+
+function method_(options: InternalAxiosRequestConfig): string {
+  return (options.method ?? 'get').toUpperCase();
+}
+
+/** Corps de la requête, déjà sérialisé en JSON par axios avant l'adapter. */
+function body(options: InternalAxiosRequestConfig): Json {
+  const data = options.data;
+  if (data == null) return {};
+  if (typeof data === 'string') {
+    try {
+      return JSON.parse(data);
+    } catch {
+      return {};
+    }
+  }
+  return data as Json;
+}
+
+function lastSegment(path: string): string {
+  const segments = path.split('/');
+  return decodeURIComponent(segments[segments.length - 1]);
+}
+
+/**
+ * Demandes de paiement de démo : les dates des fixtures sont figées et
+ * finissent toutes par expirer. On les décale toutes du même écart pour
+ * que la demande date d'hier, en gardant les intervalles d'origine
+ * (expiration, réponse...).
+ */
+function shiftRtpDates(data: Json | undefined): Json | undefined {
+  if (data?.dateDemande == null) return data;
+  const offset = Date.now() - 24 * 3600 * 1000 - Date.parse(data.dateDemande);
+  for (const field of ['dateDemande', 'dateExpiration', 'dateReponse', 'dateOperation']) {
+    if (data[field] != null) data[field] = new Date(Date.parse(data[field]) + offset).toISOString();
+  }
+  return data;
+}
+
+function problem403(detail: string, name: string): Json {
+  return {
+    type: 'about:blank',
+    title: 'Forbidden',
+    status: 403,
+    detail,
+    'invalid-params': { name },
+  };
+}
+
+function response(options: InternalAxiosRequestConfig, status: number, data?: unknown): AxiosResponse {
+  return {
+    data,
+    status,
+    statusText: String(status),
+    headers: {},
+    config: options,
+  };
+}
+
+function delayed<T>(ms: number, build: () => T): Promise<T> {
+  return new Promise((resolve) => setTimeout(() => resolve(build()), ms));
+}