From efbb08b92062452e51849fa360592a450b0b8ab5 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 17:59:11 -0300 Subject: [PATCH 1/7] =?UTF-8?q?fix(US-221b):=20report=20de=20la=20capture?= =?UTF-8?q?=20convertie=20sur=20les=20soldes=20par=20jambe=20(D1)=20et=20r?= =?UTF-8?q?approchement=20des=20encaissements=20prouv=C3=A9s=20(D2)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Migration 0146 : à la conversion gardée d'une CAPTURE, la capture prouvée est rattachée au trip né et portée sur chaque jambe à son montant explicite (commande settlement_cmd_apply_conversion_capture, cmd_money_owner), mouvement CAPTURE et COLLECTION de l'assureur, dans la même transaction ; rejeu sans double report. finance_trip_leg_facts tient tout trip ayant un encaissement prouvé. Preuve L0 PA/USD (TJ01) et PY/PYG (TJ08a), fixture 9936, ADR-170. Agent-Role: argent Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- apps/api/src/modules/fin/README.md | 2 +- changelog.d/US-221-report-capture.md | 5 + .../ADR-170-report-de-la-capture-convertie.md | 31 + docs/team/handoffs/US-221.md | 25 + packages/db/README.md | 10 + ...146_settlement_conversion_capture_legs.sql | 875 ++++++++++++++++++ packages/db/security-definer-allowlist.json | 7 + packages/db/src/errors.test.ts | 2 + packages/db/src/errors.ts | 2 + ...est_us221b_conversion_capture_fixtures.sql | 68 ++ packages/db/test/int/stl-schema.test.ts | 11 +- .../l0/l0-us221b-conversion-capture.test.ts | 457 +++++++++ packages/db/vitest.l0.config.ts | 3 + 13 files changed, 1495 insertions(+), 3 deletions(-) create mode 100644 changelog.d/US-221-report-capture.md create mode 100644 docs/adr/ADR-170-report-de-la-capture-convertie.md create mode 100644 docs/team/handoffs/US-221.md create mode 100644 packages/db/migrations/0146_settlement_conversion_capture_legs.sql create mode 100644 packages/db/test-migrations/9936_test_us221b_conversion_capture_fixtures.sql create mode 100644 packages/db/test/l0/l0-us221b-conversion-capture.test.ts diff --git a/apps/api/src/modules/fin/README.md b/apps/api/src/modules/fin/README.md index 9f4339a8..be3f3f40 100644 --- a/apps/api/src/modules/fin/README.md +++ b/apps/api/src/modules/fin/README.md @@ -17,7 +17,7 @@ FIN ne calcule ni le règlement ni les jambes (STL), et ne déplace pas de fonds ## Rapprochement de l'argent (US-047, ADR-087) -`internal/money-reconciliation.ts` : tâche périodique du travailleur `reconciliation` (24 h, PROPOSÉ ; déclarée dans `apps/api/src/worker-tasks.ts`). En lecture seule, sur toute la base, elle relit les versions de règlement (`core.settlement_settlement`, `core.settlement_settlement_leg`) et les soldes par jambe (`core.settlement_trip_leg_balance`) : politiques `worker_money_read` de 0027 et 0036. Onze contrôles (codes PROPOSÉS) : `SETTLEMENT_LEGS_INCOMPLETE`, `SETTLEMENT_LEG_NEGATIVE`, `SETTLEMENT_LEGS_SUM`, `SETTLEMENT_HOST_LEG`, `SETTLEMENT_REFUND_BALANCE`, `SETTLEMENT_VARIATIONS_REFUND`, `SETTLEMENT_VERSION_CHAIN`, `LEG_BALANCE_OVERDRAWN` et, depuis US-217a (ADR-161), `TRIP_CAPTURE_LEGS` (Σ capturé = Σ des encaissements portés = Σ de leurs jambes), `TRIP_SETTLED_TOTAL` (total payé de la version en tête = encaissé), `STATEMENT_HOST_LEG` (jambe HOST du relevé de l'hôte = jambe HOST attendue, lue d'une autre source), sur les faits par trip de `core.finance_trip_leg_facts()` (0137 ; requête `tripLegFactsSql`, source `TRIP_LEG_FACTS_SOURCE`, montants et pays seulement). Leurs règles et leurs sources (08 E1, E4, E7 ; 17 §2.9, §3.2.8) sont dans l'en-tête du fichier. Le rapport ne contient que des comptes par contrôle et par pays. Tout écart lève une alerte P1 `FIN_MONEY_RECONCILIATION` par pays (runbook `docs/ops/MONITORING.md`). Un contexte autre que ce travailleur lève `MoneyReconciliationContractError` (jamais de zéros trompeurs). Les requêtes d'agrégat (`settlementAggregatesSql`, `legBalanceAggregatesSql`) lisent leurs tables en CTE (`SETTLEMENT_SOURCE`, `SETTLEMENT_LEG_SOURCE`, `LEG_BALANCE_SOURCE`) : le test d'intégration y ajoute une ligne en écart pour prouver la détection sur PostgreSQL réel, et la tâche n'utilise que les tables. Depuis US-227, quatorze contrôles (section suivante). +`internal/money-reconciliation.ts` : tâche périodique du travailleur `reconciliation` (24 h, PROPOSÉ ; déclarée dans `apps/api/src/worker-tasks.ts`). En lecture seule, sur toute la base, elle relit les versions de règlement (`core.settlement_settlement`, `core.settlement_settlement_leg`) et les soldes par jambe (`core.settlement_trip_leg_balance`) : politiques `worker_money_read` de 0027 et 0036. Onze contrôles (codes PROPOSÉS) : `SETTLEMENT_LEGS_INCOMPLETE`, `SETTLEMENT_LEG_NEGATIVE`, `SETTLEMENT_LEGS_SUM`, `SETTLEMENT_HOST_LEG`, `SETTLEMENT_REFUND_BALANCE`, `SETTLEMENT_VARIATIONS_REFUND`, `SETTLEMENT_VERSION_CHAIN`, `LEG_BALANCE_OVERDRAWN` et, depuis US-217a (ADR-161), `TRIP_CAPTURE_LEGS` (Σ capturé = Σ des encaissements portés = Σ de leurs jambes), `TRIP_SETTLED_TOTAL` (total payé de la version en tête = encaissé), `STATEMENT_HOST_LEG` (jambe HOST du relevé de l'hôte = jambe HOST attendue, lue d'une autre source), sur les faits par trip de `core.finance_trip_leg_facts()` (0137 ; requête `tripLegFactsSql`, source `TRIP_LEG_FACTS_SOURCE`, montants et pays seulement ; depuis US-221b, 0146, ADR-170 : tout trip ayant un encaissement prouvé est examiné et « encaissé » compte les encaissements portés ou prouvés, si bien qu'un encaissement prouvé jamais porté ressort en `TRIP_CAPTURE_LEGS`). Leurs règles et leurs sources (08 E1, E4, E7 ; 17 §2.9, §3.2.8) sont dans l'en-tête du fichier. Le rapport ne contient que des comptes par contrôle et par pays. Tout écart lève une alerte P1 `FIN_MONEY_RECONCILIATION` par pays (runbook `docs/ops/MONITORING.md`). Un contexte autre que ce travailleur lève `MoneyReconciliationContractError` (jamais de zéros trompeurs). Les requêtes d'agrégat (`settlementAggregatesSql`, `legBalanceAggregatesSql`) lisent leurs tables en CTE (`SETTLEMENT_SOURCE`, `SETTLEMENT_LEG_SOURCE`, `LEG_BALANCE_SOURCE`) : le test d'intégration y ajoute une ligne en écart pour prouver la détection sur PostgreSQL réel, et la tâche n'utilise que les tables. Depuis US-227, quatorze contrôles (section suivante). ## Jambe de l'assureur au rapprochement (US-227, ADR-165) diff --git a/changelog.d/US-221-report-capture.md b/changelog.d/US-221-report-capture.md new file mode 100644 index 00000000..6ff0e384 --- /dev/null +++ b/changelog.d/US-221-report-capture.md @@ -0,0 +1,5 @@ +lot: L2 +module: Règlement et finance + +- Corrigé : le paiement d'un voyage réservé par le checkout est désormais porté, au moment même de la réservation, sur la part de l'hôte, de l'assureur, de la taxe et de Kmino, chacune à son montant exact, et la part de l'assureur entre dans son registre ; une confirmation rejouée ne le porte jamais deux fois (US-221) +- Corrigé : le contrôle de nuit de l'argent voit tout voyage dont le paiement est prouvé, même s'il n'a pas été porté sur ses parts, et le signale alors comme un écart (US-221) diff --git a/docs/adr/ADR-170-report-de-la-capture-convertie.md b/docs/adr/ADR-170-report-de-la-capture-convertie.md new file mode 100644 index 00000000..0e1aaa50 --- /dev/null +++ b/docs/adr/ADR-170-report-de-la-capture-convertie.md @@ -0,0 +1,31 @@ +# ADR-170 — Report de la capture d'un checkout sur les soldes par jambe du trip réservé, à la conversion + +- **Statut** : PROPOSÉ (US-221 partie 221b, agent argent / back-end, claude-opus-5-5, 2026-11-18). Revues exigées : code, architecture, sécurité, argent, QA (`docs/team/review-requirements.json`) ; argent, RLS / rôles, `SECURITY DEFINER` et concurrence sur un autre modèle que l'auteur. À reporter dans 17 §2.5 étape 4 (la conversion d'une `CAPTURE` porte la capture sur les soldes), §2.3 (commande `settlement_cmd_apply_conversion_capture`, politiques de conversion de `cmd_money_owner`) et §2.9. +- **Corrige** : défauts D1 et D2 de la passation US-221 (PR #245, ex-#243). +- **Complète** : ADR-139 (paiement par jambes, preuve par webhook), ADR-161 (faits de l'invariant par jambe), ADR-165 (écriture `COLLECTION` du registre de l'assureur). +- **Sources** : 08 E7 règles 1, 2 et 10 (jambes explicites, jamais un prorata ; soldes par trip et jambe), vecteurs TJ01 (USD), TJ08a (PYG) ; 17 v6 §2.5 étape 4, §2.9 (« soldes modifiés seulement par les commandes `settlement.cmd_*`, dans la transaction qui reçoit la preuve »), §4.3 point 8. + +## Contexte + +`core.booking_convert_payment` (0126) crée le trip `BOOKED` d'un hold payé et prouvé, sans rattacher l'opération de capture au trip (`payment_operation.trip_id` reste `NULL`). `core.settlement_cmd_apply_leg_movement` (0123), seul report sur les soldes, refuse une opération sans trip (`leg_movement_unsupported`) et n'est appelé en production que pour un remboursement. Résultat pour tout trip réservé par le vrai checkout : `trip_leg_balance` vide, aucune écriture `COLLECTION` au registre de l'assureur, aucune source de capture pour le reçu de l'hôte, et un remboursement ultérieur impossible à reporter (D1). Comme `core.finance_trip_leg_facts` (0137) ne retenait que les trips ayant un solde ou un règlement, le rapprochement de nuit ne voyait pas ces encaissements (D2). + +## Décision + +1. **Report dans la transaction de la conversion** : après la création du trip, de la disposition `CONVERSION` et du hold `CONVERTED`, la conversion d'une `CAPTURE` appelle `core.settlement_cmd_apply_conversion_capture(opération)`. Un refus annule toute la conversion (aucun trip sans ses soldes) ; la tâche `booking_conversion` compte l'erreur et réessaie. Une `AUTH` (fixtures) n'encaisse rien : aucun report. +2. **Commande dédiée** (`cmd_money_owner`, `SECURITY DEFINER`, `EXECUTE` `app_worker`, travailleurs `booking_conversion`, `disposition_sweeper`, `payment_intent_sweeper`) plutôt qu'un élargissement de `settlement_cmd_apply_leg_movement` (travailleur `payment_command`) : le périmètre est fermé à la capture d'un hold converti. Sous le verrou du trip : disposition `CONVERSION` exigée, `DUPLICATE` si un mouvement existe déjà, opération `CAPTURE` de loyer `SUCCEEDED` **prouvée**, même devise et même pays que le trip, quatre jambes ≥ 0 de Σ = montant, garde de détention de fonds de 0123 (`funds_holding_enabled`, fail-closed). Puis rattachement de l'opération et de ses jambes au trip, quatre soldes créés à zéro, `captured_minor` de chaque jambe = **sa** jambe de l'opération (montant explicite, égal au devis figé contrôlé à l'étape 2 de la conversion), mouvement `CAPTURE` (le déclencheur de 0143 écrit la `COLLECTION` de la jambe `INSURER`). Contrôle final : opération et jambes rattachées, chaque solde = sa jambe, sinon refus (une ligne filtrée par la RLS ne passe jamais en silence). +3. **Droits au plus juste, miroir exact** : `cmd_money_owner` lit la disposition (quatre colonnes) et reçoit `UPDATE (trip_id)` de l'opération et des jambes. Politiques ajoutées, réservées aux trois travailleurs de conversion : rattachement d'une `CAPTURE` prouvée sans trip au trip de **sa** disposition `CONVERSION` ; mouvement `CAPTURE` de l'opération de la disposition du trip ; solde créé à zéro puis `captured_minor` = jambe de cette opération, tout autre cumul nul. Déclencheurs (tous rôles, sur un changement de `trip_id`) : `trip_id` d'une opération ou d'une jambe ne passe que de `NULL` au trip de la conversion, sans autre changement (`operation_trip_attach_invalid` ⇒ `INVARIANT_VIOLATION`). +4. **Rejeu idempotent** : une conversion rejouée (`REPLAY`) d'une `CAPTURE` appelle la même commande, qui rend `DUPLICATE` ; elle rattrape une conversion antérieure à 0146 jamais portée. `settlement_cmd_apply_leg_movement` rejoué sur la capture rend `DUPLICATE` (mouvement unique par opération). +5. **Rapprochement (D2)** : un trip est tenu dès qu'il a un encaissement **prouvé** (`CAPTURE`, `MIT_CHARGE`, `DEBT_COLLECTION` du périmètre du loyer, `SUCCEEDED`, preuve rattachée), rattaché au trip ou à sa disposition `CONVERSION`. « Encaissé » = Σ des encaissements portés **ou** prouvés : un encaissement prouvé jamais porté ressort en `TRIP_CAPTURE_LEGS` (Σ capturé ≠ Σ encaissé) et en `STATEMENT_HOST_LEG` (aucune ligne de relevé). Un encaissement non prouvé n'est pas un encaissement (ADR-139). + +## Alternatives écartées + +- **Élargir `settlement_cmd_apply_leg_movement` aux travailleurs de conversion** : ouvrirait remboursements, réaffectations et versements à des travailleurs qui n'en ont pas l'usage ; la commande dédiée ne sait que porter une capture convertie. +- **Report différé par la boîte d'envoi monétaire** (`payment_command`) : un trip `BOOKED` existerait sans soldes entre deux tâches, et le consommateur `payment_command` n'est pas déclaré avant le lot C ; 17 §2.9 demande le report dans la transaction qui reçoit la preuve. +- **Changer le nom du travailleur dans la transaction** pour réutiliser la commande existante : usurpation du contexte de session, refusée. +- **Garder la conversion et lever une alerte** si le report échoue : laisserait un trip réservé sans soldes ; fail-closed retenu (aucun trip sans ses soldes), l'opération reste due et visible par le rapprochement (D2). + +## Limites et conséquences (suites) + +- Aucune reprise des conversions antérieures à 0146 par migration (aucune donnée de production en bêta) : rattrapage au rejeu de la conversion, et le rapprochement les signale (D2). +- Le parcours doré d'US-221 (PR #245) : son test `it.fails` « D2 (défaut) » passe désormais (à retirer à sa fusion) ; « D1 (défaut) » appelle `settlement_cmd_apply_leg_movement` sur la capture et attend `APPLIED` : il obtient `DUPLICATE` (capture déjà portée à la conversion) et doit être réécrit sur les soldes, comme la preuve L0 de cette story. +- Annulation du trip converti par le vrai chemin (`TripCancellationProcessor` sans `tripOf`), contrat et constancia du trip réservé : suites de la passation US-221 (trous 1 et 2), débloquées. diff --git a/docs/team/handoffs/US-221.md b/docs/team/handoffs/US-221.md new file mode 100644 index 00000000..c6b99b3b --- /dev/null +++ b/docs/team/handoffs/US-221.md @@ -0,0 +1,25 @@ +# Passation US-221 — partie 221b : report de la capture convertie (D1, D2) + +> La partie principale d'US-221 (parcours dorés « réservation », PR #245, ex-#243) a sa propre passation dans ce fichier sur sa branche ; à la fusion de la seconde des deux PR, les deux parties se mettent bout à bout (221 d'abord, puis cette section). + +Agent argent / back-end, claude-opus-5-5. Branche `story/US-221-report-capture`, partie d'`origin/main` (f91ef0fc, après #240), worktree `../wt/US-221b`. Migration **0146** (`0146_settlement_conversion_capture_legs`, à renuméroter à la suite de main à chaque fusion : #242 et #244 passent avant), fixture **9936**, **ADR-170**. Aucun texte visible (aucun catalogue). + +Revues exigées (`node scripts/ci/check-story-reviews.mjs --branch story/US-221-report-capture --base origin/main --root . --author-model claude-opus-5-5`) : voir le rapport de PR (argent, RLS / rôles, `SECURITY DEFINER` et concurrence sur un autre modèle que l'auteur). + +## Ce qui est livré + +- **D1** : `core.booking_convert_payment` (corps de 0126 recopié) appelle, dans la transaction de la conversion d'une `CAPTURE`, la nouvelle commande `core.settlement_cmd_apply_conversion_capture(uuid)` (cmd_money_owner, SECURITY DEFINER, EXECUTE app_worker, travailleurs de conversion) : rattachement de l'opération et de ses jambes au trip de la disposition `CONVERSION`, quatre soldes, chaque jambe à son montant explicite (jambe de l'opération = devis figé, contrôlé à l'étape 2), mouvement `CAPTURE`, `COLLECTION` de l'assureur (déclencheur de 0143). Rejeu : `DUPLICATE` (aucun double report) ; un `REPLAY` rattrape une conversion antérieure non portée. Un refus annule la conversion (fail-closed : aucun trip sans ses soldes). +- **D2** : `core.finance_trip_leg_facts()` (corps de 0137 recopié) tient tout trip ayant un encaissement prouvé (rattaché au trip ou à sa disposition `CONVERSION`) ; « encaissé » = portés ou prouvés : un encaissement prouvé jamais porté ressort en `TRIP_CAPTURE_LEGS` et `STATEMENT_HOST_LEG`. +- Droits et gardes : politiques `cmd_money_conversion_*` (miroir exact de la capture), déclencheurs `operation_trip_attach_guard` / `operation_leg_trip_attach_guard` (`operation_trip_attach_invalid` ⇒ `INVARIANT_VIOLATION`). +- Preuves : `packages/db/test/l0/l0-us221b-conversion-capture.test.ts` (groupe isolé, données commitées, vraies commandes sous app_api / app_worker, L0-05 par `connectAs`), PA / USD (TJ01) et PY / PYG (TJ08a), attendus tirés de `check_legs.py` (`python -I -X utf8`) et recoupés avec l'export. Test de sécurité modifié : `packages/db/test/int/stl-schema.test.ts` (inventaire des écrivains de `trip_leg_balance` : deux politiques de conversion ajoutées, commentaire ligne à ligne). + +## Lien avec la PR #245 (parcours dorés) + +- Non fusionnée au moment de cette PR : D1 et D2 sont couverts par le test L0 ci-dessus. +- À la fusion de la seconde PR : retirer `it.fails` de « D2 (défaut) » (il passe désormais) ; réécrire « D1 (défaut) » : il appelle `settlement_cmd_apply_leg_movement` sur la capture et attend `APPLIED`, or la capture est déjà portée à la conversion (`DUPLICATE`) ; l'attendu devient les soldes du trip = jambes de l'oracle juste après la conversion, puis prolonger le segment B (annulation par le vrai chemin, contrat, constancia). + +## Reste + +1. Revues exigées. +2. Renuméroter 0146 à la suite de main à chaque fusion (#242, #244) et recopier `docs/architecture/schema.md` de la sortie du job « base de données ». +3. Suites : 17 §2.5 étape 4, §2.3, §2.9 à compléter par ADR-170 (demande de fusion de spécification). diff --git a/packages/db/README.md b/packages/db/README.md index 29dd454a..785f6734 100644 --- a/packages/db/README.md +++ b/packages/db/README.md @@ -1062,3 +1062,13 @@ Migration `0144_booking_meeting_place`. Fixture `9939_test_us514_meeting_place_f - **Adresse bornée** : `core.catalog_guest_meeting_point` (0106) et `core.booking_guest_trips` (0136) remplacés à signature identique : l'adresse exacte n'est plus rendue au-delà de la fin prévue du trip + `review_window_days` du pays (paramètre absent ou mal formé ⇒ jamais). Aucune copie de l'adresse, rien à purger. - **Droits** : `SELECT (country_code, scheduled_end)` de `booking_trip` à catalog_cmd_owner ; politiques ajoutées `catalog_cmd_meeting_read`, `cmd_hold_meeting_read` sur `config_param_value` (clé `review_window_days`). - **Preuves** : `test/l0/l0-us514-meeting-place.test.ts` (PA USD, PY PYG : one-way, adresse après réservation seulement, borne de la fenêtre dans chaque état, paramètre absent, lieu non modifiable par aucun rôle, droits). + +## Report de la capture convertie (US-221 partie 221b ; défauts D1 et D2 d'US-221 ; 08 E7 règles 1, 2, 10 ; ADR-170) + +Migration `0146_settlement_conversion_capture_legs`. Fixture `9936_test_us221b_conversion_capture_fixtures.sql` (encaissement prouvé jamais porté sur un trip de fixture, transaction annulée ; état de rattachement et de report d'une opération). + +- **Conversion** : `core.booking_convert_payment` (0126) remplacé à signature, propriétaire et droits identiques : la conversion d'une `CAPTURE` appelle, dans sa transaction, `core.settlement_cmd_apply_conversion_capture(uuid)` (cmd_money_owner, EXECUTE app_worker, travailleurs `booking_conversion`, `disposition_sweeper`, `payment_intent_sweeper`) : rattachement de l'opération et de ses jambes au trip de la disposition `CONVERSION`, chaque jambe portée à son montant explicite, mouvement `CAPTURE` (écriture `COLLECTION` de l'assureur par 0143) ; `DUPLICATE` au rejeu ; un refus annule la conversion. +- **Droits** : `SELECT (operation_id, hold_id, disposition, trip_id)` de `booking_payment_disposition` et `UPDATE (trip_id)` de `payment_payment_operation` et `payment_payment_operation_leg` à cmd_money_owner ; politiques `cmd_money_conversion_attach`, `cmd_money_conversion_ins`, `cmd_money_conversion_upd` (travailleurs de conversion, miroir exact de la capture) ; déclencheurs `operation_trip_attach_guard`, `operation_leg_trip_attach_guard` (tous rôles). +- **Rapprochement** : `core.finance_trip_leg_facts()` (0137) remplacé : tout trip ayant un encaissement prouvé est tenu ; « encaissé » = encaissements portés ou prouvés. +- **Codes** : `operation_trip_attach_invalid` ⇒ `INVARIANT_VIOLATION` ; refus du report sous les noms de 0123 (`leg_movement_unsupported`, `leg_movement_unproven`, `leg_movement_not_succeeded`, `leg_funds_holding_disabled`). +- **Preuves** : `test/l0/l0-us221b-conversion-capture.test.ts` (TJ01 PA USD, TJ08a PY PYG ; groupe isolé) ; inventaire des écrivains de `trip_leg_balance` mis à jour (`test/int/stl-schema.test.ts`). diff --git a/packages/db/migrations/0146_settlement_conversion_capture_legs.sql b/packages/db/migrations/0146_settlement_conversion_capture_legs.sql new file mode 100644 index 00000000..6e5918ca --- /dev/null +++ b/packages/db/migrations/0146_settlement_conversion_capture_legs.sql @@ -0,0 +1,875 @@ +-- 0146 — STL / AVL / FIN : la capture prouvée d'un hold converti est rattachée au trip né de la +-- conversion et reportée sur ses soldes par jambe, dans la même transaction ; le rapprochement voit +-- tout trip qui a un encaissement prouvé. +-- US-221 partie 221b (agent argent / back-end) ; défauts D1 et D2 de la passation US-221 (PR #245) ; +-- 08 E7 règles 1, 2 et 10 (jambes explicites, jamais un prorata ; soldes par trip et jambe) ; +-- vecteurs TJ01 (USD), TJ08a (PYG) ; 17 v6 §2.3 (`cmd_money_owner`, RLS-25), §2.5 étape 4 +-- (conversion gardée), §2.9 (« soldes modifiés seulement par les commandes settlement.cmd_*, dans la +-- transaction qui reçoit la preuve »), §4.3 point 8 ; ADR-139 (preuve), ADR-161 (faits de +-- l'invariant par jambe), ADR-165 (registre de l'assureur), ADR-170 (cette migration). Appliquée sous +-- `migrator`, en une transaction. +-- +-- D1 : `core.booking_convert_payment` (0126) créait le trip sans rattacher la capture +-- (`payment_operation.trip_id` restait NULL) et `core.settlement_cmd_apply_leg_movement` (0123) la +-- refusait (`leg_movement_unsupported`) : soldes par jambe vides, aucune écriture COLLECTION au +-- registre de l'assureur. D2 : `core.finance_trip_leg_facts` (0137) ne lisait que les trips ayant +-- des soldes ou un règlement : un encaissement prouvé jamais porté passait le rapprochement. +-- +-- Cette migration : +-- 1. droits de `cmd_money_owner` : lecture de la disposition de paiement (colonnes sans donnée +-- personnelle) ; `UPDATE (trip_id)` de l'opération et de ses jambes, seulement par une nouvelle +-- politique réservée aux travailleurs de conversion (opération CAPTURE de loyer, SUCCEEDED, +-- prouvée, sans trip, rattachée au trip de SA disposition CONVERSION) ; +-- 2. déclencheurs (tous rôles, sur un changement de `trip_id`) : `trip_id` d'une opération ou +-- d'une jambe ne change que de NULL au trip de la disposition CONVERSION de l'opération, sans +-- rien changer d'autre dans la même mise à jour ; +-- 3. politiques d'écriture des soldes et des mouvements pour les travailleurs de conversion, +-- MIROIR EXACT de la preuve : mouvement CAPTURE de l'opération de la disposition CONVERSION du +-- trip ; soldes créés à zéro, puis `captured_minor` = jambe de cette opération, rien d'autre ; +-- 4. commande `core.settlement_cmd_apply_conversion_capture(uuid)` (`cmd_money_owner`, +-- SECURITY DEFINER, EXECUTE `app_worker`, travailleurs booking_conversion, disposition_sweeper, +-- payment_intent_sweeper) : sous le verrou du trip, rattache la capture et ses jambes au trip, +-- reporte CHAQUE jambe avec son montant explicite (celui de l'opération, égal au devis figé, +-- contrôlé par la conversion), écrit le mouvement CAPTURE (le déclencheur de 0143 écrit la +-- COLLECTION de la jambe INSURER) ; idempotente (`DUPLICATE`) ; mêmes refus que le report de +-- 0123 (preuve, périmètre, quatre jambes, Σ jambes = montant, détention de fonds) ; +-- 5. `core.finance_trip_leg_facts()` (corps de 0137 recopié, blocs marqués US-221b) : un trip est +-- tenu dès qu'il a un encaissement PROUVÉ (opération CAPTURE, MIT_CHARGE ou DEBT_COLLECTION du +-- périmètre du loyer, SUCCEEDED, preuve rattachée), rattaché au trip ou à sa disposition +-- CONVERSION ; « encaissé » = Σ des encaissements prouvés (et non plus seulement des portés) : +-- un encaissement prouvé jamais porté ressort en `TRIP_CAPTURE_LEGS` ; +-- 6. `core.booking_convert_payment(uuid)` (corps de 0126 recopié, blocs marqués US-221b) : la +-- conversion d'une CAPTURE appelle la commande 4 dans la même transaction (un refus annule la +-- conversion : aucun trip sans ses soldes, la tâche réessaie et compte l'erreur) ; un rejeu +-- (REPLAY) d'une conversion antérieure non portée la reporte (rattrapage idempotent). +-- +-- Aucune autre commande n'est modifiée ; aucun interrupteur lu autrement que par +-- `core.config_go_live` (fail-closed) ; aucun texte visible ; aucun montant reçu en paramètre. +-- +-- Codes (packages/db/src/errors.ts, existants) : +-- leg_movement_unsupported (55000) → INVARIANT_VIOLATION ; +-- leg_movement_unproven (55000) → PAYMENT_UNPROVEN ; +-- leg_funds_holding_disabled (55000) → INVARIANT_VIOLATION ; +-- operation_trip_attach_invalid (23000, nouveau, déclencheurs) → INVARIANT_VIOLATION. +-- +-- Expand / contract : droits, politiques, déclencheurs et fonction AJOUTÉS ; deux fonctions +-- remplacées à signature, propriétaire et droits identiques ; rien n'est retiré. +-- +-- Retour arrière : +-- (réappliquer core.booking_convert_payment de 0126 et core.finance_trip_leg_facts de 0137) +-- DROP FUNCTION core.settlement_cmd_apply_conversion_capture(uuid); +-- DROP TRIGGER operation_trip_attach_guard ON core.payment_payment_operation; +-- DROP TRIGGER operation_leg_trip_attach_guard ON core.payment_payment_operation_leg; +-- DROP FUNCTION core.payment_guard_operation_trip_attach(), core.payment_guard_leg_trip_attach(); +-- DROP POLICY cmd_money_conversion_attach ON core.payment_payment_operation; +-- DROP POLICY cmd_money_conversion_attach ON core.payment_payment_operation_leg; +-- DROP POLICY cmd_money_conversion_ins ON core.settlement_leg_movement; +-- DROP POLICY cmd_money_conversion_ins ON core.settlement_trip_leg_balance; +-- DROP POLICY cmd_money_conversion_upd ON core.settlement_trip_leg_balance; +-- DROP POLICY cmd_money_sel ON core.booking_payment_disposition; +-- REVOKE UPDATE (trip_id) ON core.payment_payment_operation, core.payment_payment_operation_leg +-- FROM cmd_money_owner; +-- REVOKE SELECT (operation_id, hold_id, disposition, trip_id) ON core.booking_payment_disposition +-- FROM cmd_money_owner; + +-- 1. Droits de cmd_money_owner (sous migrator, propriétaire des tables) --------------------------- + +GRANT SELECT (operation_id, hold_id, disposition, trip_id) ON core.booking_payment_disposition + TO cmd_money_owner; +CREATE POLICY cmd_money_sel ON core.booking_payment_disposition FOR SELECT TO cmd_money_owner + USING (true); + +GRANT UPDATE (trip_id) ON core.payment_payment_operation TO cmd_money_owner; +GRANT UPDATE (trip_id) ON core.payment_payment_operation_leg TO cmd_money_owner; + +-- rattachement de la capture : travailleurs de conversion seulement, CAPTURE de loyer SUCCEEDED et +-- prouvée, sans trip ; le trip posé est celui de la disposition CONVERSION de l'opération +CREATE POLICY cmd_money_conversion_attach ON core.payment_payment_operation FOR UPDATE + TO cmd_money_owner + USING (app.actor_kind() = 'WORKER' + AND app.worker_name() IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') + AND trip_id IS NULL AND hold_id IS NOT NULL AND kind = 'CAPTURE' AND purpose = 'RENT' + AND status = 'SUCCEEDED' AND proof_type IS NOT NULL) + WITH CHECK (app.actor_kind() = 'WORKER' + AND app.worker_name() IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') + AND kind = 'CAPTURE' AND purpose = 'RENT' AND status = 'SUCCEEDED' + AND proof_type IS NOT NULL + AND EXISTS (SELECT 1 FROM core.booking_payment_disposition AS d + WHERE d.operation_id = payment_payment_operation.id + AND d.hold_id = payment_payment_operation.hold_id + AND d.disposition = 'CONVERSION' + AND d.trip_id = payment_payment_operation.trip_id)); + +CREATE POLICY cmd_money_conversion_attach ON core.payment_payment_operation_leg FOR UPDATE + TO cmd_money_owner + USING (app.actor_kind() = 'WORKER' + AND app.worker_name() IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') + AND trip_id IS NULL) + WITH CHECK (app.actor_kind() = 'WORKER' + AND app.worker_name() IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') + AND EXISTS (SELECT 1 + FROM core.payment_payment_operation AS o + JOIN core.booking_payment_disposition AS d + ON d.operation_id = o.id AND d.disposition = 'CONVERSION' + WHERE o.id = payment_payment_operation_leg.operation_id + AND o.trip_id = payment_payment_operation_leg.trip_id + AND d.trip_id = payment_payment_operation_leg.trip_id)); + +-- 2. Déclencheurs de rattachement (tous rôles) ---------------------------------------------------- + +CREATE FUNCTION core.payment_guard_operation_trip_attach() + RETURNS trigger + LANGUAGE plpgsql + SET search_path = pg_catalog, pg_temp +AS $fn$ +BEGIN + -- trip_id ne change que de NULL au trip de la disposition CONVERSION de l'opération, seul + IF OLD.trip_id IS NOT NULL + OR NEW.trip_id IS NULL + OR NEW.status IS DISTINCT FROM OLD.status + OR NEW.proof_type IS DISTINCT FROM OLD.proof_type + OR NEW.provider_reference IS DISTINCT FROM OLD.provider_reference + OR NEW.amount_minor IS DISTINCT FROM OLD.amount_minor + OR NEW.hold_id IS DISTINCT FROM OLD.hold_id + OR NOT EXISTS (SELECT 1 FROM core.booking_payment_disposition AS d + WHERE d.operation_id = NEW.id AND d.disposition = 'CONVERSION' + AND d.trip_id = NEW.trip_id) THEN + RAISE EXCEPTION 'payment_operation: trip_id is attached once, to the trip of its conversion' + USING ERRCODE = 'integrity_constraint_violation', + CONSTRAINT = 'operation_trip_attach_invalid'; + END IF; + RETURN NEW; +END +$fn$; +COMMENT ON FUNCTION core.payment_guard_operation_trip_attach() IS + 'Déclencheur operation_trip_attach_guard : trip_id d''une opération ne passe que de NULL au trip ' + 'de sa disposition CONVERSION, sans autre changement. US-221 (221b, ADR-170).'; +REVOKE ALL ON FUNCTION core.payment_guard_operation_trip_attach() FROM PUBLIC; +CREATE TRIGGER operation_trip_attach_guard + BEFORE UPDATE OF trip_id ON core.payment_payment_operation + FOR EACH ROW WHEN (OLD.trip_id IS DISTINCT FROM NEW.trip_id) + EXECUTE FUNCTION core.payment_guard_operation_trip_attach(); + +CREATE FUNCTION core.payment_guard_leg_trip_attach() + RETURNS trigger + LANGUAGE plpgsql + SET search_path = pg_catalog, pg_temp +AS $fn$ +BEGIN + -- au rattachement, rien d'autre ne change : trip_id passe de NULL au trip de son opération + IF OLD.trip_id IS NOT NULL + OR NEW.trip_id IS NULL + OR (NEW.operation_id, NEW.leg, NEW.org_id, NEW.country_code, NEW.amount_minor, + NEW.beneficiary_ref, NEW.created_at) + IS DISTINCT FROM + (OLD.operation_id, OLD.leg, OLD.org_id, OLD.country_code, OLD.amount_minor, + OLD.beneficiary_ref, OLD.created_at) + OR NOT EXISTS (SELECT 1 FROM core.payment_payment_operation AS o + WHERE o.id = NEW.operation_id AND o.trip_id = NEW.trip_id) THEN + RAISE EXCEPTION 'payment_operation_leg: legs are immutable, trip_id follows its operation once' + USING ERRCODE = 'integrity_constraint_violation', + CONSTRAINT = 'operation_trip_attach_invalid'; + END IF; + RETURN NEW; +END +$fn$; +COMMENT ON FUNCTION core.payment_guard_leg_trip_attach() IS + 'Déclencheur operation_leg_trip_attach_guard : trip_id d''une jambe ne passe que de NULL au trip ' + 'de son opération, sans autre changement. US-221 (221b, ADR-170).'; +REVOKE ALL ON FUNCTION core.payment_guard_leg_trip_attach() FROM PUBLIC; +CREATE TRIGGER operation_leg_trip_attach_guard + BEFORE UPDATE OF trip_id ON core.payment_payment_operation_leg + FOR EACH ROW WHEN (OLD.trip_id IS DISTINCT FROM NEW.trip_id) + EXECUTE FUNCTION core.payment_guard_leg_trip_attach(); + +-- 3. Soldes et mouvements : miroir exact de la capture convertie ----------------------------------- + +CREATE POLICY cmd_money_conversion_ins ON core.settlement_leg_movement FOR INSERT + TO cmd_money_owner + WITH CHECK (app.actor_kind() = 'WORKER' + AND app.worker_name() IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') + AND kind = 'CAPTURE' AND segment_no = 1 + AND EXISTS (SELECT 1 + FROM core.booking_payment_disposition AS d + JOIN core.payment_payment_operation AS o ON o.id = d.operation_id + WHERE d.operation_id = settlement_leg_movement.operation_id + AND d.trip_id = settlement_leg_movement.trip_id + AND d.disposition = 'CONVERSION' + AND o.trip_id = settlement_leg_movement.trip_id + AND o.kind = 'CAPTURE' AND o.status = 'SUCCEEDED' + AND o.proof_type IS NOT NULL)); + +CREATE POLICY cmd_money_conversion_ins ON core.settlement_trip_leg_balance FOR INSERT + TO cmd_money_owner + WITH CHECK (app.actor_kind() = 'WORKER' + AND app.worker_name() IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') + AND captured_minor = 0 AND refunded_minor = 0 AND reallocated_in_minor = 0 + AND reallocated_out_minor = 0 AND released_minor = 0 AND NOT frozen + AND EXISTS (SELECT 1 FROM core.booking_payment_disposition AS d + WHERE d.trip_id = settlement_trip_leg_balance.trip_id + AND d.disposition = 'CONVERSION')); + +CREATE POLICY cmd_money_conversion_upd ON core.settlement_trip_leg_balance FOR UPDATE + TO cmd_money_owner + USING (app.actor_kind() = 'WORKER' + AND app.worker_name() IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') + AND captured_minor = 0 AND refunded_minor = 0 AND reallocated_in_minor = 0 + AND reallocated_out_minor = 0 AND released_minor = 0 AND NOT frozen + AND EXISTS (SELECT 1 FROM core.booking_payment_disposition AS d + WHERE d.trip_id = settlement_trip_leg_balance.trip_id + AND d.disposition = 'CONVERSION')) + WITH CHECK (app.actor_kind() = 'WORKER' + AND app.worker_name() IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') + AND refunded_minor = 0 AND reallocated_in_minor = 0 + AND reallocated_out_minor = 0 AND released_minor = 0 AND NOT frozen + AND captured_minor = (SELECT g.amount_minor + FROM core.booking_payment_disposition AS d + JOIN core.payment_payment_operation_leg AS g + ON g.operation_id = d.operation_id + WHERE d.trip_id = settlement_trip_leg_balance.trip_id + AND d.disposition = 'CONVERSION' + AND g.leg = settlement_trip_leg_balance.leg)); + +-- 4. Commande de report de la capture convertie (famille cmd_money) -------------------------------- +GRANT CREATE ON SCHEMA core TO cmd_money_owner; +SET LOCAL ROLE cmd_money_owner; + +-- Appelée par core.booking_convert_payment, dans la transaction de la conversion. Montants LUS +-- (jambes de l'opération, contrôlées égales au devis figé par la conversion), jamais reçus. +CREATE FUNCTION core.settlement_cmd_apply_conversion_capture(p_operation_id uuid) + RETURNS text + LANGUAGE plpgsql + VOLATILE + SECURITY DEFINER + SET search_path = pg_catalog, pg_temp +AS $fn$ +DECLARE + v_trip_id uuid; + v_org uuid; + v_country text; + v_trip_cur text; + v_mode text; + v_n integer; + v_sum bigint; + r_op record; +BEGIN + IF app.actor_kind() IS DISTINCT FROM 'WORKER' OR app.worker_name() IS NULL + OR app.worker_name() NOT IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') THEN + RAISE EXCEPTION 'settlement: conversion capture reserved to the conversion workers' + USING ERRCODE = 'insufficient_privilege'; + END IF; + + SELECT d.trip_id INTO v_trip_id + FROM core.booking_payment_disposition AS d + WHERE d.operation_id = p_operation_id AND d.disposition = 'CONVERSION'; + IF v_trip_id IS NULL THEN + RAISE EXCEPTION 'settlement: operation % has no conversion', p_operation_id + USING ERRCODE = 'object_not_in_prerequisite_state', + CONSTRAINT = 'leg_movement_unsupported'; + END IF; + + -- verrou du trip : un seul écrivain des soldes du trip à la fois (17 §2.9, §4.3 point 1) + SELECT t.org_id, t.country_code, t.currency INTO v_org, v_country, v_trip_cur + FROM core.booking_trip AS t WHERE t.id = v_trip_id FOR UPDATE; + + IF EXISTS (SELECT 1 FROM core.settlement_leg_movement AS m WHERE m.operation_id = p_operation_id) THEN + RETURN 'DUPLICATE'; + END IF; + + -- opération relue SOUS le verrou du trip + SELECT o.trip_id, o.kind, o.purpose, o.status, o.proof_type, o.currency, o.amount_minor, + o.psp_account_id, o.country_code + INTO r_op + FROM core.payment_payment_operation AS o WHERE o.id = p_operation_id; + IF r_op.kind IS DISTINCT FROM 'CAPTURE' OR r_op.purpose IS DISTINCT FROM 'RENT' + OR r_op.currency IS DISTINCT FROM v_trip_cur OR r_op.country_code IS DISTINCT FROM v_country + OR r_op.psp_account_id IS NULL + OR (r_op.trip_id IS NOT NULL AND r_op.trip_id <> v_trip_id) THEN + RAISE EXCEPTION 'settlement: operation % is outside the converted capture perimeter', + p_operation_id + USING ERRCODE = 'object_not_in_prerequisite_state', + CONSTRAINT = 'leg_movement_unsupported'; + END IF; + IF r_op.status <> 'SUCCEEDED' THEN + RAISE EXCEPTION 'settlement: operation % is %, not SUCCEEDED', p_operation_id, r_op.status + USING ERRCODE = 'object_not_in_prerequisite_state', + CONSTRAINT = 'leg_movement_not_succeeded'; + END IF; + IF r_op.proof_type IS NULL THEN + RAISE EXCEPTION 'settlement: operation % has no attached proof', p_operation_id + USING ERRCODE = 'object_not_in_prerequisite_state', CONSTRAINT = 'leg_movement_unproven'; + END IF; + -- quatre jambes explicites, Σ jambes = montant capturé (08 E7 règles 1 et 2 ; jamais un prorata) + SELECT pg_catalog.count(*)::integer, pg_catalog.sum(l.amount_minor)::bigint INTO v_n, v_sum + FROM core.payment_payment_operation_leg AS l WHERE l.operation_id = p_operation_id; + IF v_n <> 4 OR v_sum IS DISTINCT FROM r_op.amount_minor + OR EXISTS (SELECT 1 FROM core.payment_payment_operation_leg AS l + WHERE l.operation_id = p_operation_id AND l.amount_minor < 0) THEN + RAISE EXCEPTION 'settlement: operation % has % legs summing to %, 4 legs = % expected', + p_operation_id, v_n, v_sum, r_op.amount_minor + USING ERRCODE = 'object_not_in_prerequisite_state', + CONSTRAINT = 'leg_movement_unsupported'; + END IF; + -- fonds détenus par Kmino (mode autre que SPLIT_AT_SOURCE) seulement si + -- funds_holding_enabled[pays] (17 §0.1, lecture fail-closed) : même garde que 0123 + SELECT a.collection_mode INTO v_mode FROM core.payment_psp_account AS a + WHERE a.id = r_op.psp_account_id; + IF v_mode IS DISTINCT FROM 'SPLIT_AT_SOURCE' + AND NOT core.config_go_live('funds_holding_enabled', v_country) THEN + RAISE EXCEPTION 'settlement: funds holding is disabled for %', v_country + USING ERRCODE = 'object_not_in_prerequisite_state', + CONSTRAINT = 'leg_funds_holding_disabled'; + END IF; + + -- rattachement de la capture et de ses jambes au trip né de la conversion (déclencheurs de 2) + IF r_op.trip_id IS NULL THEN + UPDATE core.payment_payment_operation AS o SET trip_id = v_trip_id + WHERE o.id = p_operation_id AND o.trip_id IS NULL; + END IF; + UPDATE core.payment_payment_operation_leg AS l SET trip_id = v_trip_id + WHERE l.operation_id = p_operation_id AND l.trip_id IS NULL; + + -- quatre lignes de solde du segment (bêta : segment 1), créées à zéro ; une ligne déjà portée + -- par un autre encaissement refuse le report (politique cmd_money_conversion_upd : fail-closed) + INSERT INTO core.settlement_trip_leg_balance (trip_id, segment_no, leg, org_id, country_code, currency) + SELECT v_trip_id, 1, l.leg, v_org, v_country, v_trip_cur + FROM unnest(ARRAY['HOST', 'INSURER', 'TAX_THIRD_PARTY', 'PLATFORM']) AS l(leg) + ON CONFLICT (trip_id, segment_no, leg) DO NOTHING; + + -- chaque jambe reçoit SON montant explicite (jambe de l'opération), jamais un prorata + UPDATE core.settlement_trip_leg_balance AS b + SET captured_minor = b.captured_minor + l.amount_minor + FROM core.payment_payment_operation_leg AS l + WHERE l.operation_id = p_operation_id + AND b.trip_id = v_trip_id AND b.segment_no = 1 AND b.leg = l.leg + AND l.amount_minor <> 0; + + -- une ligne filtrée par la RLS (solde déjà porté, jambe gelée) ne doit pas passer en silence : + -- l'opération rattachée et chaque solde = sa jambe, sinon refus (fail-closed) + IF NOT EXISTS (SELECT 1 FROM core.payment_payment_operation AS o + WHERE o.id = p_operation_id AND o.trip_id = v_trip_id) + OR EXISTS (SELECT 1 FROM core.payment_payment_operation_leg AS l + WHERE l.operation_id = p_operation_id + AND l.trip_id IS DISTINCT FROM v_trip_id) + OR (SELECT pg_catalog.count(*) + FROM core.payment_payment_operation_leg AS l + JOIN core.settlement_trip_leg_balance AS b + ON b.trip_id = v_trip_id AND b.segment_no = 1 AND b.leg = l.leg + WHERE l.operation_id = p_operation_id + AND b.captured_minor = l.amount_minor AND b.refunded_minor = 0 + AND b.reallocated_in_minor = 0 AND b.reallocated_out_minor = 0 + AND b.released_minor = 0 AND NOT b.frozen) <> 4 THEN + RAISE EXCEPTION 'settlement: trip % already carries leg movements, capture % not reported', + v_trip_id, p_operation_id + USING ERRCODE = 'object_not_in_prerequisite_state', + CONSTRAINT = 'leg_movement_unsupported'; + END IF; + + -- mouvement CAPTURE (idempotence par opération) ; insurer_ledger_collection_posted (0143) écrit + -- la COLLECTION de la jambe INSURER dans la même transaction + INSERT INTO core.settlement_leg_movement (operation_id, trip_id, segment_no, country_code, kind) + VALUES (p_operation_id, v_trip_id, 1, v_country, 'CAPTURE'); + RETURN 'APPLIED'; +END +$fn$; +COMMENT ON FUNCTION core.settlement_cmd_apply_conversion_capture(uuid) IS + 'Report de la capture prouvée d''un hold converti (17 §2.5 étape 4, §2.9) : rattachement au trip ' + 'de la disposition CONVERSION, chaque jambe à son montant explicite, mouvement CAPTURE (COLLECTION ' + 'de l''assureur par 0143) ; DUPLICATE si déjà porté. Travailleurs booking_conversion, ' + 'disposition_sweeper, payment_intent_sweeper (EXECUTE app_worker). US-221 (221b, ADR-170).'; +REVOKE ALL ON FUNCTION core.settlement_cmd_apply_conversion_capture(uuid) FROM PUBLIC; +GRANT EXECUTE ON FUNCTION core.settlement_cmd_apply_conversion_capture(uuid) TO app_worker; + +-- 5. Faits de l'invariant par jambe (corps de 0137 recopié ; blocs marqués US-221b) --------------- +CREATE OR REPLACE FUNCTION core.finance_trip_leg_facts() + RETURNS TABLE (trip_id uuid, country_code text, currency text, captured_minor bigint, + collected_minor bigint, collected_legs_minor bigint, + head_total_paid_minor bigint, expected_host_minor bigint, + statement_host_minor bigint) + LANGUAGE plpgsql + STABLE + SECURITY DEFINER + SET search_path = pg_catalog, pg_temp +AS $fn$ +#variable_conflict use_column +BEGIN + IF app.actor_kind() IS DISTINCT FROM 'WORKER' + OR app.worker_name() IS DISTINCT FROM 'reconciliation' THEN + RAISE EXCEPTION 'finance: leg facts are read by the reconciliation worker only' + USING ERRCODE = 'insufficient_privilege'; + END IF; + RETURN QUERY + WITH enc AS ( + -- US-221b (D2) : encaissements du trip = ceux qui sont portés sur les soldes UNION ceux qui + -- sont PROUVÉS (SUCCEEDED, preuve rattachée, périmètre du loyer), rattachés au trip ou à sa + -- disposition CONVERSION ; un encaissement prouvé jamais porté est donc vu (et en écart) + SELECT m.trip_id, m.operation_id AS op_id + FROM core.settlement_leg_movement AS m + WHERE m.segment_no = 1 AND m.kind IN ('CAPTURE', 'MIT_CHARGE', 'DEBT_COLLECTION') + UNION + SELECT COALESCE(o.trip_id, d.trip_id), o.id + FROM core.payment_payment_operation AS o + LEFT JOIN core.booking_payment_disposition AS d + ON d.operation_id = o.id AND d.disposition = 'CONVERSION' + WHERE o.status = 'SUCCEEDED' AND o.proof_type IS NOT NULL + AND o.kind IN ('CAPTURE', 'MIT_CHARGE', 'DEBT_COLLECTION') + AND o.purpose IN ('RENT', 'RENT_SHORTFALL', 'NO_SHOW_RETENTION') + AND COALESCE(o.trip_id, d.trip_id) IS NOT NULL + ), + held AS ( + SELECT b.trip_id AS id FROM core.settlement_trip_leg_balance AS b WHERE b.segment_no = 1 + UNION + SELECT s.trip_id FROM core.settlement_settlement AS s WHERE s.segment_no = 1 + UNION + SELECT e.trip_id FROM enc AS e + ), + tr AS ( + SELECT t.id, t.org_id, t.country_code, t.currency + FROM core.booking_trip AS t + JOIN held AS x ON x.id = t.id + ), + orgs AS (SELECT DISTINCT y.org_id FROM tr AS y), + lines AS ( + SELECT l.trip_id, l.amount_minor + FROM orgs AS o + CROSS JOIN LATERAL core.finance_earning_lines(o.org_id) AS l + WHERE l.line_kind IN ('EARNING', 'CXL_EARNING') + ), + cap AS ( + SELECT b.trip_id, + pg_catalog.sum(b.captured_minor)::bigint AS captured, + pg_catalog.sum(b.captured_minor) FILTER (WHERE b.leg = 'HOST')::bigint AS host + FROM core.settlement_trip_leg_balance AS b + WHERE b.segment_no = 1 + GROUP BY b.trip_id + ), + ops AS ( + -- US-221b : encaissements portés ou prouvés (mêmes natures que captured_minor) + SELECT e.trip_id, + pg_catalog.sum(o.amount_minor)::bigint AS amount, + pg_catalog.sum((SELECT pg_catalog.sum(g.amount_minor) + FROM core.payment_payment_operation_leg AS g + WHERE g.operation_id = o.id))::bigint AS legs, + pg_catalog.sum((SELECT g.amount_minor + FROM core.payment_payment_operation_leg AS g + WHERE g.operation_id = o.id AND g.leg = 'HOST'))::bigint AS host + FROM enc AS e + JOIN core.payment_payment_operation AS o ON o.id = e.op_id + GROUP BY e.trip_id + ), + head AS ( + SELECT DISTINCT ON (s.trip_id) s.trip_id, s.total_paid_minor, s.host_from_guest_minor + FROM core.settlement_settlement AS s + WHERE s.segment_no = 1 + ORDER BY s.trip_id, s.version DESC + ) + SELECT tr.id, tr.country_code, tr.currency, + COALESCE(c.captured, 0)::bigint, + op.amount, op.legs, + h.total_paid_minor, + -- jambe HOST attendue, lue d'une AUTRE source que le relevé : en-tête du règlement + -- (hostFromGuest), sinon jambes HOST des encaissements, sinon solde capturé + CASE WHEN h.trip_id IS NOT NULL THEN h.host_from_guest_minor + WHEN op.trip_id IS NOT NULL THEN op.host + ELSE c.host END, + ln.amount_minor + FROM tr + LEFT JOIN cap AS c ON c.trip_id = tr.id + LEFT JOIN ops AS op ON op.trip_id = tr.id + LEFT JOIN head AS h ON h.trip_id = tr.id + LEFT JOIN lines AS ln ON ln.trip_id = tr.id; +END +$fn$; +COMMENT ON FUNCTION core.finance_trip_leg_facts() IS + 'Faits de l''invariant par jambe, par trip tenu (soldes, règlement ou encaissement prouvé) : Σ ' + 'capturé, Σ des encaissements portés ou prouvés et de leurs jambes, total payé de la version en ' + 'tête, jambe HOST attendue et jambe HOST du relevé. Travailleur reconciliation seulement ' + '(EXECUTE app_worker). US-217 (217a, ADR-161), US-221 (221b, ADR-170).'; + +RESET ROLE; +REVOKE CREATE ON SCHEMA core FROM cmd_money_owner; + +-- 6. Conversion gardée (corps de 0126 recopié ; blocs marqués US-221b) --------------------------- +CREATE OR REPLACE FUNCTION core.booking_convert_payment(p_operation_id uuid) + RETURNS jsonb + LANGUAGE plpgsql + VOLATILE + SET search_path = pg_catalog, pg_temp +AS $fn$ +DECLARE + v_guest uuid; + v_vehicle uuid; + v_now timestamptz; + v_tolerance integer; + v_grace integer; + v_reason text; + v_late boolean; + v_trip uuid := pg_catalog.gen_random_uuid(); + v_try integer := 0; + v_conflict boolean; + v_constraint text; + v_legs_ok boolean; + v_foreign boolean; + v_same_paid boolean; + v_unpaid uuid[]; + v_h2 uuid; + n integer; + r_op record; + r_disp record; + r_hold record; + r_terms record; + r_occ record; +BEGIN + IF app.actor_kind() IS DISTINCT FROM 'WORKER' OR app.worker_name() IS NULL + OR app.worker_name() NOT IN ('booking_conversion', 'disposition_sweeper', + 'payment_intent_sweeper') THEN + RAISE EXCEPTION 'conversion: forbidden' + USING ERRCODE = 'insufficient_privilege', CONSTRAINT = 'conversion_forbidden'; + END IF; + SELECT op.hold_id, op.status, op.purpose, op.kind, op.amount_minor, op.currency, + op.country_code, op.proof_type + INTO r_op + FROM core.payment_payment_operation op + WHERE op.id = p_operation_id; + IF NOT FOUND OR r_op.hold_id IS NULL OR r_op.purpose <> 'RENT' + OR r_op.kind NOT IN ('AUTH', 'CAPTURE') THEN + RETURN pg_catalog.jsonb_build_object('outcome', 'NOT_APPLICABLE'); + END IF; + IF r_op.status <> 'SUCCEEDED' THEN + RETURN pg_catalog.jsonb_build_object('outcome', 'NOT_SUCCEEDED', 'status', r_op.status); + END IF; + -- US-223 (S-02, RC-5) : SUCCEEDED sans preuve rattachée (réponse d'API) ⇒ aucun trip ; la + -- conversion attend le webhook signé (ou la lecture d'un compte de bac à sable) + IF r_op.proof_type IS NULL THEN + RETURN pg_catalog.jsonb_build_object('outcome', 'NOT_PROVEN'); + END IF; + -- US-223c (17 §2.5 « Hold de demande REQUEST ») : l'autorisation prouvée d'une demande n'est + -- jamais convertie ni compensée (aucune disposition) : la demande attend l'hôte (AWAITING_HOST), + -- ou, si le hold n'est plus vivant, l'autorisation est annulée (VOID total) ; seule la CAPTURE + -- de l'acceptation devient un trip + IF r_op.kind = 'AUTH' AND EXISTS (SELECT 1 FROM core.booking_checkout_hold ch + WHERE ch.id = r_op.hold_id AND ch.kind = 'REQUEST') THEN + RETURN core.booking_request_authorized(p_operation_id); + END IF; + -- voyageur et véhicule : colonnes gardées, jamais modifiées (lues avant les verrous) + SELECT ch.guest_user_id, ch.vehicle_id INTO v_guest, v_vehicle + FROM core.booking_checkout_hold ch WHERE ch.id = r_op.hold_id; + IF v_guest IS NULL THEN + RETURN pg_catalog.jsonb_build_object('outcome', 'NOT_APPLICABLE'); + END IF; + + -- 0. verrous voyageur puis véhicule (ordre global, VERIF_16-M2) ; rejeu exact + PERFORM pg_catalog.pg_advisory_xact_lock(pg_catalog.hashtextextended('guest:' || v_guest::text, 0)); + PERFORM pg_catalog.pg_advisory_xact_lock(pg_catalog.hashtextextended('veh:' || v_vehicle::text, 0)); + SELECT d.disposition, d.trip_id, d.hold_compensation_id INTO r_disp + FROM core.booking_payment_disposition d WHERE d.operation_id = p_operation_id; + IF FOUND THEN + IF r_disp.disposition = 'COMPENSATION' THEN + -- preuve tardive d'une opération déjà compensée (C13, E2) : journalisée, ignorée + INSERT INTO core.outbox_outbox_event + (type, schema_version, aggregate_type, aggregate_id, aggregate_version, country_code, + actor_role, correlation_id, payload, partition_key) + VALUES ('booking.payment.late_ignored', 1, 'checkout_hold', r_op.hold_id, 4, r_op.country_code, + 'SYSTEM', pg_catalog.gen_random_uuid(), + pg_catalog.jsonb_build_object('hold_id', r_op.hold_id, 'operation_id', p_operation_id, + 'hold_compensation_id', r_disp.hold_compensation_id), + r_op.hold_id::text); + END IF; + -- US-221b : rejeu d'une conversion de CAPTURE : report idempotent sur les soldes par jambe + -- (DUPLICATE si déjà porté ; rattrape une conversion antérieure à 0146, jamais portée) + IF r_disp.disposition = 'CONVERSION' AND r_op.kind = 'CAPTURE' THEN + PERFORM core.settlement_cmd_apply_conversion_capture(p_operation_id); + END IF; + RETURN pg_catalog.jsonb_build_object('outcome', 'REPLAY', 'disposition', r_disp.disposition, + 'tripId', r_disp.trip_id, + 'compensationId', r_disp.hold_compensation_id); + END IF; + + -- 1. verrou de ligne du hold, SANS prédicat de statut (la tâche d'expiration le saute) + SELECT ch.id, ch.status, ch.occupancy_id, ch.org_id, ch.country_code, ch.review_required, + ch.reviewed_at + INTO r_hold + FROM core.booking_checkout_hold ch + WHERE ch.id = r_op.hold_id + FOR UPDATE; + IF r_hold.status = 'CONVERTED' THEN + -- autre opération que celle qui a converti (sinon REPLAY) : jamais un second rattachement + RETURN core.booking_open_compensation(r_hold.id, p_operation_id, 'DUPLICATE_PAYMENT'); + ELSIF r_hold.status = 'COMPENSATED' THEN + -- jamais de trip, même si le créneau est redevenu libre (VERIF_16-N1) + RETURN core.booking_open_compensation(r_hold.id, p_operation_id, + 'LATE_PAYMENT_AFTER_COMPENSATION'); + END IF; + IF r_hold.review_required AND r_hold.reviewed_at IS NULL THEN + RAISE EXCEPTION 'conversion: review pending' + USING ERRCODE = 'object_not_in_prerequisite_state', CONSTRAINT = 'conversion_review_pending'; + END IF; + + -- 2. preuve contre le devis accepté ; 2 bis : début, catalogue, hôte, voyageur + v_tolerance := core.booking_param_int('conversion_start_tolerance_minutes', r_hold.country_code); + v_grace := core.booking_param_int('sweep_grace_s', r_hold.country_code); + IF v_tolerance IS NULL OR v_grace IS NULL THEN + RAISE EXCEPTION 'conversion: parameter missing' + USING ERRCODE = 'object_not_in_prerequisite_state', CONSTRAINT = 'hold_param_missing'; + END IF; + v_now := platform.now(); + SELECT t.amount_minor, t.currency, t.legs, t.scheduled_start, t.scheduled_end, t.timezone + INTO r_terms + FROM core.booking_hold_payment_terms(r_hold.id) AS t; + SELECT pg_catalog.lower(vo.period) AS lo, pg_catalog.upper(vo.period) AS hi INTO r_occ + FROM core.booking_vehicle_occupancy vo WHERE vo.id = r_hold.occupancy_id; + SELECT pg_catalog.count(*) = 4 + AND pg_catalog.bool_and(CASE WHEN (r_terms.legs ->> l.leg) ~ '^[0-9]{1,18}$' + THEN l.amount_minor = (r_terms.legs ->> l.leg)::bigint + ELSE false END) + AND CASE WHEN pg_catalog.jsonb_typeof(r_terms.legs) = 'object' + THEN (SELECT pg_catalog.count(*) FROM pg_catalog.jsonb_object_keys(r_terms.legs)) = 4 + ELSE false END + INTO v_legs_ok + FROM core.payment_payment_operation_leg l + WHERE l.operation_id = p_operation_id; + IF r_terms.amount_minor IS NULL OR r_terms.timezone IS NULL + OR r_op.country_code IS DISTINCT FROM r_hold.country_code + OR r_op.amount_minor IS DISTINCT FROM r_terms.amount_minor + OR r_op.currency IS DISTINCT FROM r_terms.currency + OR v_legs_ok IS NOT TRUE + OR r_terms.scheduled_start IS DISTINCT FROM r_occ.lo + OR r_terms.scheduled_end IS NULL OR r_terms.scheduled_end <= r_terms.scheduled_start + OR r_terms.scheduled_end > r_occ.hi THEN + v_reason := 'ELIGIBILITY_CHANGED'; -- devis invalidé ou preuve ≠ devis (iv) + ELSIF r_terms.scheduled_start < v_now - pg_catalog.make_interval(mins => v_tolerance) THEN + v_reason := 'START_PASSED'; -- (i) : jamais un trip après son début + ELSIF core.booking_conversion_eligibility(r_hold.id) <> 'ELIGIBLE' THEN + v_reason := 'ELIGIBILITY_CHANGED'; -- (ii), (iii) + END IF; + IF v_reason IS NOT NULL THEN + RETURN core.booking_open_compensation(r_hold.id, p_operation_id, v_reason); + END IF; + + -- 3. conversion (ACTIVE, PAYMENT_IN_FLIGHT : même si expires_at est dépassé) ou ré-acquisition + -- sous la contrainte (EXPIRED, RELEASED) ; d'abord l'expiration ciblée 2a, partie véhicule, + -- sous le verrou du véhicule déjà tenu (VERIF_17 T3, C4 bis) + v_late := r_hold.status IN ('EXPIRED', 'RELEASED'); + IF v_late THEN + -- 2a : texte EXPIRY_2A_SQL de test/support/expiry-2a.ts, partie véhicule seule + WITH t AS (SELECT platform.now() AS ts), + due AS ( + SELECT h.id, h.occupancy_id + FROM core.booking_checkout_hold h, t + WHERE (h.vehicle_id = v_vehicle OR h.guest_user_id = NULL::uuid) + AND h.status IN ('ACTIVE', 'PAYMENT_IN_FLIGHT') + AND h.expires_at <= t.ts + AND (h.payment_in_flight_until IS NULL OR h.payment_in_flight_until <= t.ts) + AND NOT EXISTS (SELECT 1 FROM core.payment_payment_operation o + WHERE o.hold_id = h.id AND o.purpose = 'RENT' + AND ( ( o.status IN ('PENDING','SUBMITTED','UNKNOWN') + AND (h.last_polled_at IS NULL OR h.last_polled_at < h.payment_in_flight_until) + AND t.ts < h.payment_in_flight_until + make_interval(secs => v_grace) ) + OR ( o.status = 'SUCCEEDED' + AND NOT EXISTS (SELECT 1 FROM core.booking_payment_disposition d + WHERE d.operation_id = o.id) ) )) + FOR UPDATE OF h SKIP LOCKED + ), expired AS ( + UPDATE core.booking_checkout_hold SET status = 'EXPIRED', expired_at = (SELECT ts FROM t) + WHERE id IN (SELECT id FROM due) + RETURNING occupancy_id + ) + UPDATE core.booking_vehicle_occupancy + SET active = false, deactivated_reason = 'HOLD_EXPIRED' + WHERE id IN (SELECT occupancy_id FROM expired) + AND kind = 'HOLD'; + END IF; + + LOOP + v_try := v_try + 1; + v_conflict := false; + -- bloc = SAVEPOINT reacquire : toute erreur annule l'occupation, le trip et la disposition + BEGIN + UPDATE core.booking_vehicle_occupancy + SET kind = 'TRIP', active = true, expires_at = NULL, deactivated_reason = NULL, + ref_type = 'TRIP', ref_id = v_trip + WHERE id = r_hold.occupancy_id AND kind = 'HOLD'; + GET DIAGNOSTICS n = ROW_COUNT; + IF n <> 1 THEN + v_reason := 'INVARIANT_VIOLATION'; -- occupation absente ou déjà TRIP + ELSE + -- 4. trip BOOKED (SM-1 HOLD -> BOOKED), occupation du voyageur (sans tampon) + INSERT INTO core.booking_trip + (id, guest_user_id, org_id, vehicle_id, country_code, currency, timezone, + scheduled_start, scheduled_end, status, source_hold_id) + VALUES (v_trip, v_guest, r_hold.org_id, v_vehicle, r_hold.country_code, r_op.currency, + r_terms.timezone, r_terms.scheduled_start, r_terms.scheduled_end, 'BOOKED', + r_hold.id); + INSERT INTO core.booking_guest_occupancy (id, guest_user_id, period, active, trip_id) + VALUES (pg_catalog.gen_random_uuid(), v_guest, + pg_catalog.tstzrange(r_terms.scheduled_start, r_terms.scheduled_end, '[)'), true, + v_trip); + -- US-223 (N-160) : version de prix n° 1 du trip = devis engagé au checkout du hold + -- (aucune ligne pour un hold sans checkout) + PERFORM core.pricing_bind_checkout_trip(v_trip); + -- 5. disposition CONVERSION (PK : XOR) puis hold CONVERTED + INSERT INTO core.booking_payment_disposition (operation_id, hold_id, disposition, trip_id) + VALUES (p_operation_id, r_hold.id, 'CONVERSION', v_trip); + UPDATE core.booking_checkout_hold + SET status = 'CONVERTED', converted_trip_id = v_trip, + conversion_operation_id = p_operation_id + WHERE id = r_hold.id; + INSERT INTO core.outbox_outbox_event + (type, schema_version, aggregate_type, aggregate_id, aggregate_version, country_code, + actor_role, correlation_id, payload, partition_key) + SELECT e.type, 1, e.agg_type, e.agg_id, e.version, r_hold.country_code, 'SYSTEM', + pg_catalog.gen_random_uuid(), e.payload, e.partition + FROM (VALUES + ('booking.hold.converted', 'checkout_hold', r_hold.id, 3, + pg_catalog.jsonb_build_object('hold_id', r_hold.id, 'trip_id', v_trip, + 'operation_id', p_operation_id, + 'reacquired', v_late), + r_hold.id::text), + ('booking.trip.booked', 'trip', v_trip, 0, + pg_catalog.jsonb_build_object('trip_id', v_trip, 'hold_id', r_hold.id, + 'vehicle_id', v_vehicle, 'org_id', r_hold.org_id, + 'scheduled_start', r_terms.scheduled_start, + 'scheduled_end', r_terms.scheduled_end), + v_trip::text), + ('booking.hold.reacquired', 'checkout_hold', r_hold.id, 3, + pg_catalog.jsonb_build_object('hold_id', r_hold.id, 'trip_id', v_trip, + 'previous_status', r_hold.status), + r_hold.id::text)) + AS e(type, agg_type, agg_id, version, payload, partition) + WHERE e.type <> 'booking.hold.reacquired' OR v_late; + -- US-221b (D1) : la CAPTURE prouvée est rattachée au trip né et reportée sur chaque jambe + -- (montant explicite de l'opération = devis figé, contrôlé à l'étape 2), mouvement CAPTURE + -- et COLLECTION de l'assureur, dans CETTE transaction ; un refus annule la conversion. + -- Une AUTH (fixtures de la conversion) n'encaisse rien : aucun report. + IF r_op.kind = 'CAPTURE' THEN + PERFORM core.settlement_cmd_apply_conversion_capture(p_operation_id); + END IF; + END IF; + EXCEPTION WHEN exclusion_violation THEN + GET STACKED DIAGNOSTICS v_constraint = CONSTRAINT_NAME; + IF v_constraint = 'guest_no_overlap' THEN + v_reason := 'GUEST_OVERLAP'; -- le voyageur a déjà un trip sur ces dates + ELSIF v_constraint = 'vehicle_occupancy_no_overlap' THEN + v_conflict := true; + ELSE + RAISE; + END IF; + END; + + IF v_reason IS NOT NULL THEN + RETURN core.booking_open_compensation(r_hold.id, p_operation_id, v_reason); + END IF; + IF NOT v_conflict THEN + RETURN pg_catalog.jsonb_build_object('outcome', 'CONVERTED', 'tripId', v_trip, + 'reacquired', v_late); + END IF; + IF NOT v_late OR v_try > 1 THEN + RETURN core.booking_open_compensation( + r_hold.id, p_operation_id, + CASE WHEN NOT v_late THEN 'INVARIANT_VIOLATION' + WHEN r_hold.status = 'RELEASED' THEN 'SLOT_LOST_AFTER_RELEASE' + ELSE 'SLOT_LOST_AFTER_EXPIRY' END); + END IF; + + -- Résolution selon l'occupation en conflit (VERIF_17-A4), lue sous le verrou du véhicule : + -- autre voyageur, blocage, tampon, trip d'un tiers ⇒ SLOT_LOST_* ; + -- hold du même voyageur déjà payé, ou trip du même voyageur ⇒ DUPLICATE_PAYMENT ; + -- seulement des holds vivants NON payés du même voyageur ⇒ supplantés (RELEASED, + -- SUPERSEDED_BY_PAID_HOLD, CANCEL_ORDER de leurs ordres vivants), puis UNE nouvelle tentative. + -- « Priorité au payeur » (reacquire_preempts_unpaid_hold, M13) : non retenue, non construite. + SELECT COALESCE(pg_catalog.bool_or(c.cls = 'FOREIGN'), false), + COALESCE(pg_catalog.bool_or(c.cls = 'SAME_PAID'), false), + pg_catalog.array_agg(c.hold_id) FILTER (WHERE c.cls = 'SAME_UNPAID') + INTO v_foreign, v_same_paid, v_unpaid + FROM (SELECT vo.id, + CASE + WHEN vo.kind = 'HOLD' AND h2.guest_user_id = v_guest + AND h2.status IN ('ACTIVE', 'PAYMENT_IN_FLIGHT') + AND EXISTS (SELECT 1 FROM core.payment_payment_operation o2 + WHERE o2.hold_id = h2.id AND o2.purpose = 'RENT' + AND o2.status = 'SUCCEEDED') + THEN 'SAME_PAID' + WHEN vo.kind = 'HOLD' AND h2.guest_user_id = v_guest + AND h2.status IN ('ACTIVE', 'PAYMENT_IN_FLIGHT') + THEN 'SAME_UNPAID' + WHEN vo.kind = 'TRIP' AND tr.guest_user_id = v_guest + THEN 'SAME_PAID' + ELSE 'FOREIGN' + END AS cls, + h2.id AS hold_id + FROM core.booking_vehicle_occupancy vo + LEFT JOIN core.booking_checkout_hold h2 + ON vo.kind = 'HOLD' AND h2.occupancy_id = vo.id + LEFT JOIN core.booking_trip tr + ON vo.kind = 'TRIP' AND tr.id = vo.ref_id + WHERE vo.vehicle_id = v_vehicle AND vo.active AND vo.id <> r_hold.occupancy_id + AND vo.period && (SELECT o.period FROM core.booking_vehicle_occupancy o + WHERE o.id = r_hold.occupancy_id)) AS c; + + IF v_foreign OR (NOT v_same_paid AND v_unpaid IS NULL) THEN + RETURN core.booking_open_compensation( + r_hold.id, p_operation_id, + CASE WHEN r_hold.status = 'RELEASED' THEN 'SLOT_LOST_AFTER_RELEASE' + ELSE 'SLOT_LOST_AFTER_EXPIRY' END); + END IF; + IF v_same_paid THEN + RETURN core.booking_open_compensation(r_hold.id, p_operation_id, 'DUPLICATE_PAYMENT'); + END IF; + + FOREACH v_h2 IN ARRAY v_unpaid LOOP + WITH released AS ( + UPDATE core.booking_checkout_hold + SET status = 'RELEASED', released_at = v_now, release_reason = 'SUPERSEDED_BY_PAID_HOLD' + WHERE id = v_h2 AND status IN ('ACTIVE', 'PAYMENT_IN_FLIGHT') + RETURNING id, occupancy_id, vehicle_id, org_id, country_code + ), occupancy AS ( + UPDATE core.booking_vehicle_occupancy vo + SET active = false, deactivated_reason = 'HOLD_RELEASED' + FROM released + WHERE vo.id = released.occupancy_id AND vo.kind = 'HOLD' AND vo.active + ) + INSERT INTO core.outbox_outbox_event + (type, schema_version, aggregate_type, aggregate_id, aggregate_version, country_code, + actor_role, correlation_id, payload, partition_key) + SELECT 'booking.hold.released', 1, 'checkout_hold', released.id, 2, released.country_code, + 'SYSTEM', pg_catalog.gen_random_uuid(), + pg_catalog.jsonb_build_object('hold_id', released.id, 'vehicle_id', released.vehicle_id, + 'org_id', released.org_id, + 'reason', 'SUPERSEDED_BY_PAID_HOLD', + 'superseded_by', r_hold.id), + released.id::text + FROM released; + -- ordres vivants de H2 : annulation par la boîte d'envoi si la capacité est validée + INSERT INTO core.payment_payment_command + (id, operation_kind, idem_plain, operation_id, hold_id, country_code, partition_key) + SELECT pg_catalog.gen_random_uuid(), 'CANCEL_ORDER', + 'hold:' || v_h2::text || ':CANCEL:' || o.id::text || ':a1', + o.id, v_h2, o.country_code, v_h2::text + FROM core.payment_payment_operation o + WHERE o.hold_id = v_h2 AND o.purpose = 'RENT' + AND o.status IN ('PENDING', 'SUBMITTED', 'UNKNOWN') + AND o.provider_reference IS NOT NULL + AND core.payment_capability_bool(o.provider, o.country_code, o.method, + 'SUPPORTS_ORDER_CANCEL') + ON CONFLICT ON CONSTRAINT payment_command_idem_unique DO NOTHING; + END LOOP; + END LOOP; +END +$fn$; +COMMENT ON FUNCTION core.booking_convert_payment(uuid) IS + 'Conversion atomique et gardée (17 §2.5 étape 4) : trip BOOKED ou compensation, jamais les deux ; ' + 'aucun trip sans preuve rattachée (NOT_PROVEN) ; version de prix n° 1 = devis du checkout ; ' + 'autorisation d''une demande : attente de l''hôte ou VOID (booking_request_authorized). ' + 'conversion d''une CAPTURE : rattachement au trip et report sur les soldes par jambe ' + '(settlement_cmd_apply_conversion_capture), dans la même transaction. ' + 'Travailleurs booking_conversion, disposition_sweeper, payment_intent_sweeper. US-024, US-223, ' + 'US-221 (221b).'; diff --git a/packages/db/security-definer-allowlist.json b/packages/db/security-definer-allowlist.json index 2db6dc98..200c7d53 100644 --- a/packages/db/security-definer-allowlist.json +++ b/packages/db/security-definer-allowlist.json @@ -589,6 +589,13 @@ "execute": ["app_worker"], "story": "US-061, US-223" }, + { + "signature": "core.settlement_cmd_apply_conversion_capture(uuid)", + "family": "cmd_money", + "owner": "cmd_money_owner", + "execute": ["app_worker"], + "story": "US-221" + }, { "signature": "core.settlement_cmd_approve_finance_action(bytea,uuid)", "family": "cmd_money", diff --git a/packages/db/src/errors.test.ts b/packages/db/src/errors.test.ts index e2a97ae6..8d1123a4 100644 --- a/packages/db/src/errors.test.ts +++ b/packages/db/src/errors.test.ts @@ -115,6 +115,8 @@ describe('translateDbError (17 §2.5 2d, §4.4, L0-08)', () => { ['42501', 'ops_monitor_forbidden', 'FORBIDDEN'], ['23505', 'payment_command_idem_unique', 'DISPOSITION_EXISTS'], ['23505', 'payment_operation_provider_reference_unique', 'PAYMENT_SUBJECT_MISMATCH'], + // rattachement de la capture convertie à son trip (0146, US-221 partie 221b) + ['23000', 'operation_trip_attach_invalid', 'INVARIANT_VIOLATION'], ])('%s sur %s → %s, sans détail', (code, constraint, expected) => { const translated = translateDbError(pgError({ code, constraint })); expect(translated).toEqual({ code: expected, retryable: false }); diff --git a/packages/db/src/errors.ts b/packages/db/src/errors.ts index bba44c08..15c0c4bd 100644 --- a/packages/db/src/errors.ts +++ b/packages/db/src/errors.ts @@ -401,6 +401,8 @@ export const CONSTRAINT_CODES: Readonly diff --git a/packages/db/test-migrations/9936_test_us221b_conversion_capture_fixtures.sql b/packages/db/test-migrations/9936_test_us221b_conversion_capture_fixtures.sql new file mode 100644 index 00000000..1e5511ca --- /dev/null +++ b/packages/db/test-migrations/9936_test_us221b_conversion_capture_fixtures.sql @@ -0,0 +1,68 @@ +-- 9936 — fixtures des preuves du report de la capture convertie (US-221 partie 221b, migration +-- 0146, ADR-170). TESTS SEULEMENT. +-- +-- JAMAIS appliquée hors tests : seul le harnais ajoute test-migrations/, et seulement à la base +-- jetable principale `rueda_test_*`. +-- +-- Rôle (SECURITY DEFINER sous migrator, search_path figé ; aucun SQL dynamique) : +-- 1. `us221b_proven_capture` : encaissement PROUVÉ (CAPTURE de loyer SUCCEEDED, preuve +-- WEBHOOK_SIGNED, quatre jambes données par l'appelant, montant = Σ jambes) rattaché à un trip +-- de fixture et JAMAIS porté sur les soldes : la forme qu'avait un trip réservé avant 0146 +-- (défaut D2 de la passation US-221) ; appelée SEULEMENT dans une transaction annulée ; +-- 2. `us221b_capture_state` : rattachement et report d'une opération (trip de l'opération et de +-- ses jambes, mouvements), lecture des preuves sous app_worker. +-- AUCUNE fixture n'écrit un interrupteur de mise en service (17 §0.1). +-- +-- Retour arrière : DROP FUNCTION test_fixture.us221b_proven_capture(uuid, uuid, jsonb), +-- test_fixture.us221b_capture_state(uuid). + +CREATE FUNCTION test_fixture.us221b_proven_capture(p_operation_id uuid, p_trip_id uuid, + p_legs jsonb) + RETURNS void + LANGUAGE plpgsql + SECURITY DEFINER + SET search_path = pg_catalog, pg_temp +AS $fn$ +DECLARE + t record; +BEGIN + SELECT x.org_id, x.country_code, x.currency INTO t FROM core.booking_trip AS x + WHERE x.id = p_trip_id; + INSERT INTO core.payment_payment_operation + (id, trip_id, psp_account_id, country_code, provider, kind, purpose, amount_minor, currency, + attempt_no, status, idem_plain, idem_sent, proof_type) + SELECT p_operation_id, p_trip_id, test_fixture.fixture_psp_account(t.country_code), + t.country_code, 'FAKE', 'CAPTURE', 'RENT', + (SELECT pg_catalog.sum((l.value #>> '{}')::bigint) + FROM pg_catalog.jsonb_each(p_legs) AS l), + t.currency, 1, 'SUCCEEDED', pg_catalog.format('us221b:%s', p_operation_id), + pg_catalog.format('us221b:%s', p_operation_id), 'WEBHOOK_SIGNED'; + INSERT INTO core.payment_payment_operation_leg + (operation_id, leg, org_id, trip_id, country_code, amount_minor) + SELECT p_operation_id, l.key, t.org_id, p_trip_id, t.country_code, (l.value #>> '{}')::bigint + FROM pg_catalog.jsonb_each(p_legs) AS l; +END +$fn$; + +CREATE FUNCTION test_fixture.us221b_capture_state(p_operation_id uuid) + RETURNS TABLE (operation_trip_id uuid, legs_trip_ids uuid[], movements integer, + movement_kind text) + LANGUAGE sql + STABLE + SECURITY DEFINER + SET search_path = pg_catalog, pg_temp +AS $fn$ + SELECT o.trip_id, + ARRAY(SELECT DISTINCT l.trip_id FROM core.payment_payment_operation_leg AS l + WHERE l.operation_id = o.id), + (SELECT pg_catalog.count(*)::integer FROM core.settlement_leg_movement AS m + WHERE m.operation_id = o.id), + (SELECT m.kind FROM core.settlement_leg_movement AS m WHERE m.operation_id = o.id) + FROM core.payment_payment_operation AS o + WHERE o.id = p_operation_id +$fn$; + +REVOKE ALL ON FUNCTION test_fixture.us221b_proven_capture(uuid, uuid, jsonb), + test_fixture.us221b_capture_state(uuid) FROM PUBLIC; +GRANT EXECUTE ON FUNCTION test_fixture.us221b_proven_capture(uuid, uuid, jsonb), + test_fixture.us221b_capture_state(uuid) TO app_worker; diff --git a/packages/db/test/int/stl-schema.test.ts b/packages/db/test/int/stl-schema.test.ts index 702d0078..1c367cce 100644 --- a/packages/db/test/int/stl-schema.test.ts +++ b/packages/db/test/int/stl-schema.test.ts @@ -95,7 +95,9 @@ describe('schéma STL (US-018, 0027)', () => { if (r.cmd === 'a' || r.cmd === 'w') expect(r.roles, label).toBe('cmd_money_owner'); expect(['app_api', 'app_worker', 'cmd_money_owner'], label).toContain(r.roles); } - // trip_leg_balance : un seul écrivain, cmd_apply_leg_movement (US-061, 0039) + // trip_leg_balance : écrivains cmd_apply_leg_movement (US-061, 0039) et, depuis US-221b + // (0146, ADR-170), le report de la capture convertie (cmd_apply_conversion_capture) : ses + // politiques sont réservées aux travailleurs de conversion et miroir exact de la capture expect( rows .filter( @@ -104,7 +106,12 @@ describe('schéma STL (US-018, 0027)', () => { ) .map((r) => `${r.pol}:${r.cmd}:${r.roles}`) .sort(), - ).toEqual(['cmd_money_ins:a:cmd_money_owner', 'cmd_money_upd:w:cmd_money_owner']); + ).toEqual([ + 'cmd_money_conversion_ins:a:cmd_money_owner', + 'cmd_money_conversion_upd:w:cmd_money_owner', + 'cmd_money_ins:a:cmd_money_owner', + 'cmd_money_upd:w:cmd_money_owner', + ]); }); }); diff --git a/packages/db/test/l0/l0-us221b-conversion-capture.test.ts b/packages/db/test/l0/l0-us221b-conversion-capture.test.ts new file mode 100644 index 00000000..dd90a374 --- /dev/null +++ b/packages/db/test/l0/l0-us221b-conversion-capture.test.ts @@ -0,0 +1,457 @@ +/** + * US-221 partie 221b — report de la capture d'un checkout sur les soldes par jambe du trip réservé + * (migration 0146, ADR-170 ; défauts D1 et D2 de la passation US-221 ; 08 E7 règles 1, 2 et 10 ; + * 17 v6 §2.5 étape 4, §2.9). + * + * D1 : à la conversion gardée, la CAPTURE prouvée est rattachée au trip né et reportée sur CHAQUE + * jambe avec son montant explicite (jamais un prorata), dans la même transaction ; COLLECTION de la + * jambe INSURER au registre de l'assureur ; rejeu sans double report. + * D2 : un trip qui a un encaissement prouvé jamais porté est vu par les faits de l'invariant par + * jambe du rapprochement (Σ capturé ≠ Σ encaissé). + * + * Attendus : vecteurs TJ01 (USD) et TJ08a (PYG) de l'oracle Python (`docs/specs/tools/check_legs.py`, + * `python -I -X utf8` : « TJ01 (USD) : 131,25 / 25,50 / 0,00 / 99,91 / 256,66 » et « TJ08a (PYG) : + * 787 500 / 105 000 / 0 / 545 550 / 1 438 050 »), recoupés avec l'export `golden_vectors.json`. + * + * Données COMMITÉES (deux sessions, conversion et balayages sur toute la base) : ce fichier tourne + * seul, après les autres (projet isolé de vitest.l0.config.ts), dans sa propre période d'horloge + * virtuelle (2056). Aucun interrupteur de mise en service n'est touché : le devis engagé au checkout + * est posé par la fixture 9969 ; tout le reste passe par les VRAIES commandes, sous les rôles de + * production (assertion L0-05 par connectAs) : pose du hold, T1, T2 (app_api), preuve + * (webhook_ingest), conversion (booking_conversion), lectures (payment_command, reconciliation). + */ +import { legVector, loadGoldenVectors } from '@rueda/money/golden-vectors'; +import type pg from 'pg'; +import { afterEach, beforeEach, describe, expect, it } from 'vitest'; +import { commandCallSql } from '../../src/index.ts'; +import { connectAs, releaseClient } from '../../src/testing/index.ts'; +import { at, COUNTRIES, inTx, uuid } from '../support/avl.ts'; +import type { CountryCase, Worker } from '../support/avl.ts'; +import { ensureParties, placeHoldCommand, registerVehicles } from '../support/concurrency.ts'; +import { legsJson } from '../support/pay.ts'; +import { insertTrip } from '../support/settlement.ts'; + +const LONG = 120_000; +const LEGS = ['HOST', 'INSURER', 'TAX_THIRD_PARTY', 'PLATFORM'] as const; +type Legs = Record<(typeof LEGS)[number], bigint>; + +// Oracle Python (check_legs.py), unités mineures : jamais le code testé +const ORACLE: Readonly> = { + USD: { + id: 'TJ01', + legs: { HOST: 13125n, INSURER: 2550n, TAX_THIRD_PARTY: 0n, PLATFORM: 9991n }, + total: 25666n, + }, + PYG: { + id: 'TJ08a', + legs: { HOST: 787500n, INSURER: 105000n, TAX_THIRD_PARTY: 0n, PLATFORM: 545550n }, + total: 1438050n, + }, +}; +const oracleOf = (c: CountryCase) => ORACLE[c.currency]!; + +const ERA0 = Date.parse('2056-04-02T10:00:00.000Z'); +const era = (n: number): string => new Date(ERA0 + n * 3 * 86_400_000).toISOString(); + +type Json = Record; + +let api: pg.Client; +let worker: pg.Client; + +beforeEach(async () => { + api = await connectAs('app_api'); + worker = await connectAs('app_worker'); +}); + +afterEach(async () => { + await releaseClient(worker); + await releaseClient(api); +}); + +interface World { + readonly orgId: string; + readonly vehicle: string; + readonly guest: string; + readonly account: string; +} + +/** Hôte, véhicule, voyageur au conducteur approuvé, compte FAKE, capacités bloquantes validées. */ +async function world(c: CountryCase, from: string): Promise { + const orgId = uuid(); + const vehicle = uuid(); + const guest = uuid(); + const account = await inTx(api, { virtualNow: from, commit: true }, async (tx) => { + await ensureParties(tx, [guest], orgId, c); + await registerVehicles(tx, [vehicle], orgId, c); + await tx.query('SELECT test_fixture.us209_driver($1, $2, $3::date, $4::date, $5)', [ + guest, + c.country, + '1990-01-01', + '2070-12-31', + c.country, + ]); + const { rows } = await tx.query<{ capability: string; kind: string }>( + `SELECT capability, kind FROM core.payment_psp_capability_catalog WHERE blocking <> 'NO'`, + ); + for (const r of rows) { + const value = r.kind === 'bool' ? true : r.kind === 'int' ? 1 : 'FAKE_HMAC_SHA256'; + await tx.query( + `SELECT test_fixture.us024_set_capability('FAKE', $1, '*', $2, $3::jsonb, + 'VALIDATED_SANDBOX', $4::timestamptz)`, + [c.country, r.capability, JSON.stringify(value), at(from, -60)], + ); + } + const a = await tx.query<{ id: string }>('SELECT test_fixture.us024_psp_account($1) AS id', [ + c.country, + ]); + return a.rows[0]!.id; + }); + return { orgId, vehicle, guest, account }; +} + +async function guestCall( + guest: string, + fn: string, + args: { value: unknown; type: string }[], + when: string, +): Promise { + return inTx(api, { virtualNow: when, commit: true }, async (tx) => { + const { text, values } = commandCallSql({ kind: 'GUEST', actorId: guest }, fn, args); + return (await tx.query<{ result: T }>(text, values)).rows[0]?.result as T; + }); +} + +async function workerSql( + name: Worker, + when: string | undefined, + sql: string, + params: unknown[], + commit = true, +): Promise { + return inTx( + worker, + { worker: name, ...(when !== undefined ? { virtualNow: when } : {}), commit }, + async (tx) => (await tx.query(sql, params)).rows, + ); +} + +/** Hold posé par la vraie commande, devis engagé aux jambes de l'oracle (fixture 9969), T1, T2. */ +async function paidHold( + c: CountryCase, + w: World, + T0: string, +): Promise<{ hold: string; op: string }> { + const start = at(T0, 3 * 24 * 60); + const end = at(start, 2 * 24 * 60); + const hold = await inTx(api, { virtualNow: T0, commit: true }, (tx) => + placeHoldCommand(tx, { + slot: { vehicleId: w.vehicle, orgId: w.orgId, start, end, bufferHours: 2 }, + guestId: w.guest, + }), + ); + const o = oracleOf(c); + await inTx(api, { virtualNow: T0, commit: true }, (tx) => + tx.query( + `SELECT test_fixture.us223_checkout_acceptance($1, $2::bigint, $3, $4::jsonb, + $5::timestamptz, $6::timestamptz)`, + [hold, o.total.toString(), c.currency, legsJson(o.legs), start, end], + ), + ); + const s = await guestCall( + w.guest, + 'core.booking_cmd_start_payment', + [ + { value: hold, type: 'uuid' }, + { value: w.account, type: 'uuid' }, + { value: 'CARD', type: 'text' }, + ], + at(T0, 1), + ); + // ordre au PSP : montant explicite de CHAQUE jambe (08 E7 règle 2) + expect(s).toMatchObject({ + outcome: 'NEW_ORDER', + amountMinor: o.total.toString(), + currency: c.currency, + legs: Object.fromEntries(LEGS.map((l) => [l, o.legs[l].toString()])), + }); + const op = s['operationId'] as string; + expect( + await guestCall( + w.guest, + 'core.booking_cmd_record_order', + [ + { value: hold, type: 'uuid' }, + { value: op, type: 'uuid' }, + { value: `fake-${uuid()}`, type: 'text' }, + { value: at(T0, 6), type: 'timestamptz' }, + ], + at(T0, 1), + ), + ).toBe('RECORDED'); + return { hold, op }; +} + +const webhook = async (op: string, when: string): Promise => + ( + await workerSql<{ o: string }>( + 'webhook_ingest', + when, + `SELECT core.payment_cmd_apply_operation_status($1, 'SUCCEEDED', 'WEBHOOK', + test_fixture.us049_signed_webhook($1, 'SUCCEEDED'), NULL) AS o`, + [op], + ) + )[0]!.o; + +const convert = async (op: string, when: string): Promise => + ( + await workerSql<{ r: Json }>( + 'booking_conversion', + when, + 'SELECT core.booking_convert_payment($1) AS r', + [op], + ) + )[0]!.r; + +interface Balance { + leg: string; + captured: string; + refunded: string; + reallocated_in: string; + reallocated_out: string; + released: string; +} + +const balances = async (trip: string): Promise> => + Object.fromEntries( + ( + await workerSql( + 'payment_command', + undefined, + `SELECT leg, captured_minor::text AS captured, refunded_minor::text AS refunded, + reallocated_in_minor::text AS reallocated_in, + reallocated_out_minor::text AS reallocated_out, released_minor::text AS released + FROM core.settlement_trip_leg_balance WHERE trip_id = $1 AND segment_no = 1`, + [trip], + false, + ) + ).map((r) => [r.leg, r]), + ); + +const captureState = async (op: string) => + ( + await workerSql<{ + operation_trip_id: string | null; + legs_trip_ids: string[]; + movements: number; + movement_kind: string | null; + }>( + 'payment_command', + undefined, + `SELECT operation_trip_id::text AS operation_trip_id, + legs_trip_ids::text[] AS legs_trip_ids, movements, movement_kind + FROM test_fixture.us221b_capture_state($1)`, + [op], + false, + ) + )[0]!; + +const collections = async (trip: string) => + ( + await workerSql<{ reason: string; amount_minor: string; operation_id: string }>( + 'payment_command', + undefined, + 'SELECT reason, amount_minor, operation_id FROM test_fixture.us227_entries($1)', + [trip], + false, + ) + ).filter((e) => e.reason === 'COLLECTION'); + +interface Facts { + captured: string; + collected: string | null; + collected_legs: string | null; + expected_host: string | null; + statement_host: string | null; +} + +const FACTS_SQL = `SELECT captured_minor::text AS captured, collected_minor::text AS collected, + collected_legs_minor::text AS collected_legs, + expected_host_minor::text AS expected_host, + statement_host_minor::text AS statement_host + FROM core.finance_trip_leg_facts() WHERE trip_id = $1::uuid`; + +async function asReconciliation(tx: pg.ClientBase): Promise { + await tx.query( + `SELECT pg_catalog.set_config('app.actor_kind', 'WORKER', true), + pg_catalog.set_config('app.worker_name', 'reconciliation', true)`, + ); +} + +async function sqlstate(tx: pg.ClientBase, sql: string, params: unknown[]) { + await tx.query('SAVEPOINT s'); + try { + await tx.query(sql, params); + return 'OK'; + } catch (error) { + const e = error as { code?: string; constraint?: string }; + return `${e.code ?? '?'}:${e.constraint ?? ''}`; + } finally { + await tx.query('ROLLBACK TO SAVEPOINT s'); + } +} + +describe('US-221b — attendus de l’oracle recoupés avec l’export des vecteurs', () => { + it('TJ01 (USD) et TJ08a (PYG) : Σ jambes = total ; export = oracle', async () => { + // L0-05 : assertion de rôle faite par connectAs dans beforeEach (app_api, app_worker) + expect(worker).toBeDefined(); + const set = loadGoldenVectors(); + for (const c of COUNTRIES) { + const o = oracleOf(c); + const v = legVector(set, o.id); + expect(v.currency).toBe(c.currency); + expect(v.totalMinor).toBe(o.total); + expect({ ...v.legsMinor }).toEqual(o.legs); + expect(LEGS.reduce((s, l) => s + o.legs[l], 0n)).toBe(o.total); + } + }); +}); + +describe.each(COUNTRIES)( + 'US-221b — capture convertie portée par jambe ($country, $currency)', + (c) => { + const o = oracleOf(c); + const idx = COUNTRIES.indexOf(c) * 10; + + it( + 'D1 : conversion gardée ⇒ capture rattachée au trip, soldes = jambes explicites de l’oracle (Σ = total), mouvement CAPTURE, COLLECTION de l’assureur ; rejeux ⇒ aucun double report', + async () => { + const T0 = era(idx + 1); + const w = await world(c, T0); + const { op } = await paidHold(c, w, T0); + expect(await webhook(op, at(T0, 2))).toBe('APPLIED'); + const r = await convert(op, at(T0, 3)); + expect(r).toMatchObject({ outcome: 'CONVERTED', reacquired: false }); + const trip = r['tripId'] as string; + + // rattachement (opération et jambes) et report, dans la transaction de la conversion + expect(await captureState(op)).toEqual({ + operation_trip_id: trip, + legs_trip_ids: [trip], + movements: 1, + movement_kind: 'CAPTURE', + }); + const b = await balances(trip); + expect(Object.keys(b).sort()).toEqual([...LEGS].sort()); + for (const leg of LEGS) { + expect(b[leg], leg).toEqual({ + leg, + captured: o.legs[leg].toString(), + refunded: '0', + reallocated_in: '0', + reallocated_out: '0', + released: '0', + }); + } + expect(LEGS.reduce((s, l) => s + BigInt(b[l]!.captured), 0n)).toBe(o.total); + expect(await collections(trip)).toEqual([ + { reason: 'COLLECTION', amount_minor: o.legs.INSURER.toString(), operation_id: op }, + ]); + + // rejeux : conversion (REPLAY), webhook (DUPLICATE), report de 0123 (DUPLICATE) + expect(await convert(op, at(T0, 4))).toMatchObject({ outcome: 'REPLAY', tripId: trip }); + expect(await webhook(op, at(T0, 4))).toBe('DUPLICATE'); + expect( + ( + await workerSql<{ r: string }>( + 'payment_command', + at(T0, 5), + 'SELECT core.settlement_cmd_apply_leg_movement($1) AS r', + [op], + ) + )[0]!.r, + ).toBe('DUPLICATE'); + expect((await captureState(op)).movements).toBe(1); + expect(await balances(trip)).toEqual(b); + expect(await collections(trip)).toHaveLength(1); + + // le rapprochement voit le trip : Σ capturé = Σ encaissé = Σ jambes = total ; HOST = HOST + await inTx(worker, {}, async (tx) => { + await asReconciliation(tx); + const { rows } = await tx.query(FACTS_SQL, [trip]); + expect(rows).toEqual([ + { + captured: o.total.toString(), + collected: o.total.toString(), + collected_legs: o.total.toString(), + expected_host: o.legs.HOST.toString(), + statement_host: o.legs.HOST.toString(), + }, + ]); + }); + }, + LONG, + ); + + it( + 'garde : report refusé hors des travailleurs de conversion (42501) et pour une opération sans conversion (leg_movement_unsupported) ; app_api sans EXECUTE', + async () => { + const T0 = era(idx + 2); + const w = await world(c, T0); + const { op } = await paidHold(c, w, T0); + expect(await webhook(op, at(T0, 2))).toBe('APPLIED'); + const call = 'SELECT core.settlement_cmd_apply_conversion_capture($1)'; + for (const name of ['payment_command', 'reconciliation', 'webhook_ingest'] as const) { + await inTx(worker, {}, async (tx) => { + await tx.query( + `SELECT pg_catalog.set_config('app.actor_kind', 'WORKER', true), + pg_catalog.set_config('app.worker_name', $1, true)`, + [name], + ); + expect(await sqlstate(tx, call, [op]), name).toBe('42501:'); + }); + } + // opération prouvée mais non convertie : aucune disposition CONVERSION ⇒ refus + await inTx(worker, { worker: 'booking_conversion', virtualNow: at(T0, 3) }, async (tx) => { + expect(await sqlstate(tx, call, [op])).toBe('55000:leg_movement_unsupported'); + }); + await inTx(api, {}, async (tx) => { + expect(await sqlstate(tx, call, [op])).toBe('42501:'); + }); + // rien n'a été porté ni rattaché + expect(await captureState(op)).toMatchObject({ operation_trip_id: null, movements: 0 }); + // la vraie conversion porte ensuite la capture (aucune opération prouvée laissée sans + // disposition dans la base partagée) + const r = await convert(op, at(T0, 4)); + expect(r).toMatchObject({ outcome: 'CONVERTED' }); + expect(await captureState(op)).toMatchObject({ + operation_trip_id: r['tripId'], + movements: 1, + }); + }, + LONG, + ); + + it('D2 : un encaissement prouvé jamais porté (forme d’avant 0146) est vu par le rapprochement, en écart (Σ capturé 0 ≠ Σ encaissé)', async () => { + await inTx(worker, {}, async (tx) => { + const trip = await insertTrip(tx, c, 9000 + idx); + const op = uuid(); + await tx.query('SELECT test_fixture.us221b_proven_capture($1, $2, $3::jsonb)', [ + op, + trip.id, + legsJson(o.legs), + ]); + await asReconciliation(tx); + const { rows } = await tx.query(FACTS_SQL, [trip.id]); + expect(rows).toEqual([ + { + captured: '0', + collected: o.total.toString(), + collected_legs: o.total.toString(), + expected_host: o.legs.HOST.toString(), + statement_host: null, + }, + ]); + }); + }); + }, +); diff --git a/packages/db/vitest.l0.config.ts b/packages/db/vitest.l0.config.ts index ce86d8e8..d84ada30 100644 --- a/packages/db/vitest.l0.config.ts +++ b/packages/db/vitest.l0.config.ts @@ -56,6 +56,9 @@ const ISOLATED = [ // US-227 : trips, contrat d'assureur de test (période passée), bordereaux et décisions FINANCE // VALIDÉS (deux rôles), compte PSP ACTIVE du pays partagé (fixture 9800) 'test/l0/l0-us227-insurer-ledger.test.ts', + // US-221b : paiement prouvé puis conversion (report de la capture sur les soldes par jambe), à + // deux sessions, données commitées, compte PSP ACTIVE du pays partagé (comme US-223a) + 'test/l0/l0-us221b-conversion-capture.test.ts', ]; const C11 = ['test/l0/l0-c11-fuzz.test.ts']; // US-049 : les attaques de la red team (test/redteam//) tournent seules, après tous les autres From 6af9444c7c2b619faaf483b6b4ae095448455dc7 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:01:48 -0300 Subject: [PATCH 2/7] =?UTF-8?q?docs(US-221b):=20schema.md=20recopi=C3=A9?= =?UTF-8?q?=20de=20la=20sortie=20du=20job=20=C2=AB=20base=20de=20donn?= =?UTF-8?q?=C3=A9es=20=C2=BB=20(0146)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Agent-Role: argent Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- docs/architecture/schema.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/docs/architecture/schema.md b/docs/architecture/schema.md index 86e487a2..d29c172d 100644 --- a/docs/architecture/schema.md +++ b/docs/architecture/schema.md @@ -7,7 +7,7 @@ Lu dans le catalogue (`pg_catalog`) d'une base jetable du banc, après les seule ## Synthèse -- 146 migrations ; 128 tables ; 3 vues ; 722 politiques RLS ; 290 fonctions `SECURITY DEFINER` ; 251 autres fonctions. +- 147 migrations ; 128 tables ; 3 vues ; 728 politiques RLS ; 291 fonctions `SECURITY DEFINER` ; 253 autres fonctions. - Tables sans RLS `ENABLE` + `FORCE` : aucune. - Rôles applicatifs avec `SUPERUSER` ou `BYPASSRLS` : aucun. @@ -161,6 +161,7 @@ Lu dans le catalogue (`pg_catalog`) d'une base jetable du banc, après les seule | `0143_settlement_insurer_ledger` | STL / FIN : jambe de l'assureur — registre `insurer_ledger`, bordereau mensuel à double | | `0144_booking_meeting_place` | AVL / CAT : lieux de prise et de retour (US-514 ; 19 US-514 ; 16 BKG-016 ; 08 BR-BOOK-09 ; | | `0145_finance_receipt_alignment` | FIN : alignement des reçus et du relevé des gains sur les décisions écrites d'US-217 | +| `0146_settlement_conversion_capture_legs` | STL / AVL / FIN : la capture prouvée d'un hold converti est rattachée au trip né de la | ## Rôles @@ -1013,6 +1014,7 @@ Index : Politiques RLS : - `cmd_hold_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `true` +- `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `integrity_read` (SELECT, PERMISSIVE, integrity_owner) USING `true` - `migrator_all` (ALL, PERMISSIVE, migrator) USING `true` WITH CHECK `true` - `worker_insert_conversion` (INSERT, PERMISSIVE, app_worker) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])))` @@ -4339,6 +4341,7 @@ Politiques RLS : - `cmd_hold_request_auth_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'GUEST'::text) AND (purpose = 'RENT'::text) AND (kind = 'AUTH'::text) AND (status = 'PENDING'::text) AND (trip_id IS NULL) AND (psp_account_id IS NOT NULL) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.guest_user_id = app.actor_id()) AND (h.kind = 'REQUEST'::text) AND (h.status = 'PAYMENT_IN_FLIGHT'::text)))))` - `cmd_hold_request_pay_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((purpose = 'RENT'::text) AND (status = 'PENDING'::text) AND (trip_id IS NULL) AND (psp_account_id IS NOT NULL) AND (((kind = 'CAPTURE'::text) AND (app.actor_kind() = 'HOST'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id()) AND (h.status = 'PAYMENT_IN_FLIGHT'::text) AND (h.request_respond_by IS NOT NULL))))) OR ((kind = 'VOID'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (((app.actor_kind() = 'HOST'::text) AND (h.org_id = app.org_id())) OR ((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['hold_expiry'::text, 'booking_conversion'::text]))))))))))` - `cmd_hold_request_pay_upd` (UPDATE, PERMISSIVE, cmd_hold_owner) USING `((app.actor_kind() = 'HOST'::text) AND (purpose = 'RENT'::text) AND (kind = 'CAPTURE'::text) AND (status = 'PENDING'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id())))))` WITH CHECK `((app.actor_kind() = 'HOST'::text) AND (status = 'SUBMITTED'::text))` +- `cmd_money_conversion_attach` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (trip_id IS NULL) AND (hold_id IS NOT NULL) AND (kind = 'CAPTURE'::text) AND (purpose = 'RENT'::text) AND (status = 'SUCCEEDED'::text) AND (proof_type IS NOT NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (kind = 'CAPTURE'::text) AND (purpose = 'RENT'::text) AND (status = 'SUCCEEDED'::text) AND (proof_type IS NOT NULL) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.operation_id = payment_payment_operation.id) AND (d.hold_id = payment_payment_operation.hold_id) AND (d.disposition = 'CONVERSION'::text) AND (d.trip_id = payment_payment_operation.trip_id)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text) AND (status = 'PENDING'::text) AND (psp_account_id IS NOT NULL))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `cmd_money_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['payment_command'::text, 'webhook_ingest'::text])) AND (psp_account_id IS NOT NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (psp_account_id IS NOT NULL))` @@ -4353,6 +4356,7 @@ Politiques RLS : Déclencheurs : +- `operation_trip_attach_guard` : `CREATE TRIGGER operation_trip_attach_guard BEFORE UPDATE OF trip_id ON core.payment_payment_operation FOR EACH ROW WHEN (old.trip_id IS DISTINCT FROM new.trip_id) EXECUTE FUNCTION core.payment_guard_operation_trip_attach()` - `payment_operation_legs_check` : `CREATE CONSTRAINT TRIGGER payment_operation_legs_check AFTER INSERT ON core.payment_payment_operation DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION core.payment_assert_operation_legs()` - `refund_instance_gate` : `CREATE TRIGGER refund_instance_gate BEFORE UPDATE OF status ON core.payment_payment_operation FOR EACH ROW EXECUTE FUNCTION core.payment_refund_instance_gate()` - `refund_instance_sync` : `CREATE TRIGGER refund_instance_sync AFTER UPDATE OF status ON core.payment_payment_operation FOR EACH ROW WHEN (new.kind = 'REFUND'::text) EXECUTE FUNCTION core.payment_refund_instance_sync()` @@ -4425,6 +4429,7 @@ Politiques RLS : - `cmd_hold_leg_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'GUEST'::text) AND (trip_id IS NULL) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.status = 'PENDING'::text) AND (o.purpose = 'RENT'::text) AND (h.guest_user_id = app.actor_id())))))` - `cmd_hold_leg_sel` (SELECT, PERMISSIVE, cmd_hold_owner) USING `((app.actor_kind() = 'GUEST'::text) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (h.guest_user_id = app.actor_id())))))` - `cmd_hold_request_leg_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'HOST'::text) AND (trip_id IS NULL) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.kind = 'CAPTURE'::text) AND (o.status = 'PENDING'::text) AND (o.purpose = 'RENT'::text) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id())))))` +- `cmd_money_conversion_attach` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (trip_id IS NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_payment_disposition d ON (((d.operation_id = o.id) AND (d.disposition = 'CONVERSION'::text)))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.trip_id = payment_payment_operation_leg.trip_id) AND (d.trip_id = payment_payment_operation_leg.trip_id)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `host_view_read` (SELECT, PERMISSIVE, host_view_owner) USING `true` @@ -4437,6 +4442,7 @@ Politiques RLS : Déclencheurs : +- `operation_leg_trip_attach_guard` : `CREATE TRIGGER operation_leg_trip_attach_guard BEFORE UPDATE OF trip_id ON core.payment_payment_operation_leg FOR EACH ROW WHEN (old.trip_id IS DISTINCT FROM new.trip_id) EXECUTE FUNCTION core.payment_guard_leg_trip_attach()` - `payment_operation_leg_release_guard` : `CREATE TRIGGER payment_operation_leg_release_guard AFTER INSERT ON core.payment_payment_operation_leg REFERENCING NEW TABLE AS new_legs FOR EACH STATEMENT EXECUTE FUNCTION core.payment_operation_leg_release_guard()` - `payment_operation_legs_check` : `CREATE CONSTRAINT TRIGGER payment_operation_legs_check AFTER INSERT ON core.payment_payment_operation_leg DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION core.payment_assert_operation_legs()` @@ -5663,6 +5669,7 @@ Index : Politiques RLS : +- `cmd_money_conversion_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (kind = 'CAPTURE'::text) AND (segment_no = 1) AND (EXISTS ( SELECT 1 FROM (core.booking_payment_disposition d JOIN core.payment_payment_operation o ON ((o.id = d.operation_id))) WHERE ((d.operation_id = settlement_leg_movement.operation_id) AND (d.trip_id = settlement_leg_movement.trip_id) AND (d.disposition = 'CONVERSION'::text) AND (o.trip_id = settlement_leg_movement.trip_id) AND (o.kind = 'CAPTURE'::text) AND (o.status = 'SUCCEEDED'::text) AND (o.proof_type IS NOT NULL)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `migrator_all` (ALL, PERMISSIVE, migrator) USING `true` WITH CHECK `true` @@ -6006,6 +6013,8 @@ Index : Politiques RLS : +- `cmd_money_conversion_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text)))))` +- `cmd_money_conversion_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text)))))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (captured_minor = ( SELECT g.amount_minor FROM (core.booking_payment_disposition d JOIN core.payment_payment_operation_leg g ON ((g.operation_id = d.operation_id))) WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text) AND (g.leg = settlement_trip_leg_balance.leg)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `cmd_money_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` @@ -6664,6 +6673,7 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.settlement_assert_balanced()` | `trigger` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_money_owner: EXECUTE | | `core.settlement_assert_cancellation_refunded()` | `trigger` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_money_owner: EXECUTE | | `core.settlement_cancellation_of(p_settlement_id uuid)` | `TABLE(id uuid, trip_id uuid, segment_no integer, version integer, supersedes_id uuid, kind text, requested_reason text, reason text, origin text, target_state text, inputs jsonb, superseded boolean)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_hold_owner: EXECUTE ; cmd_money_owner: EXECUTE | +| `core.settlement_cmd_apply_conversion_capture(p_operation_id uuid)` | `text` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_apply_leg_movement(p_operation_id uuid)` | `text` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_approve_finance_action(p_token_hash bytea, p_approval_id uuid)` | `TABLE(outcome text, approval_id uuid)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_api: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_draft_insurer_bordereaux(p_month text)` | `TABLE(outcome text, country text, bordereau uuid, lines integer, total bigint)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | @@ -6885,6 +6895,8 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.payment_capability_bool(p_provider text, p_country text, p_method text, p_capability text)` | `boolean` | `migrator` | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE ; migrator: EXECUTE | | `core.payment_capability_int(p_provider text, p_country text, p_method text, p_capability text)` | `integer` | `migrator` | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE ; migrator: EXECUTE | | `core.payment_capability_value(p_provider text, p_country text, p_method text, p_capability text)` | `jsonb` | `migrator` | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE ; migrator: EXECUTE | +| `core.payment_guard_leg_trip_attach()` | `trigger` | `migrator` | migrator: EXECUTE | +| `core.payment_guard_operation_trip_attach()` | `trigger` | `migrator` | migrator: EXECUTE | | `core.payment_missing_blocking_capabilities(p_provider text, p_country text, p_mode text)` | `text[]` | `migrator` | app_api: EXECUTE ; app_worker: EXECUTE ; cmd_hold_owner: EXECUTE ; cmd_money_owner: EXECUTE ; kyc_cmd_owner: EXECUTE ; migrator: EXECUTE | | `core.payment_operation_leg_release_guard()` | `trigger` | `migrator` | migrator: EXECUTE | | `core.payment_psp_account_fake_guard()` | `trigger` | `migrator` | migrator: EXECUTE | From 315b57200d1574473393d1edbad0144cd39126fd Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:26:05 -0300 Subject: [PATCH 3/7] =?UTF-8?q?fix(US-221b):=20faits=20D2=20born=C3=A9s=20?= =?UTF-8?q?=C3=A0=20la=20capture=20du=20hold=20converti=20(rapprochement?= =?UTF-8?q?=20de=20toute=20la=20base)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Compter aussi les encaissements rattachés directement au trip rendait la CI rouge (run 44397196230, guide d'installation) : les captures de trip prouvées des scènes de concurrence-webhook ne sont portées par rien avant la boîte d'envoi monétaire du lot C. Preuve D2 déplacée sur une capture convertie sans report (fixture 9936, transaction annulée). Agent-Role: argent Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- apps/api/src/modules/fin/README.md | 2 +- changelog.d/US-221-report-capture.md | 2 +- .../ADR-170-report-de-la-capture-convertie.md | 3 +- docs/team/handoffs/US-221.md | 2 +- packages/db/README.md | 4 +- ...146_settlement_conversion_capture_legs.sql | 35 +++++++------- ...est_us221b_conversion_capture_fixtures.sql | 44 ++++++----------- .../l0/l0-us221b-conversion-capture.test.ts | 47 +++++++++---------- 8 files changed, 61 insertions(+), 78 deletions(-) diff --git a/apps/api/src/modules/fin/README.md b/apps/api/src/modules/fin/README.md index be3f3f40..ce07ae03 100644 --- a/apps/api/src/modules/fin/README.md +++ b/apps/api/src/modules/fin/README.md @@ -17,7 +17,7 @@ FIN ne calcule ni le règlement ni les jambes (STL), et ne déplace pas de fonds ## Rapprochement de l'argent (US-047, ADR-087) -`internal/money-reconciliation.ts` : tâche périodique du travailleur `reconciliation` (24 h, PROPOSÉ ; déclarée dans `apps/api/src/worker-tasks.ts`). En lecture seule, sur toute la base, elle relit les versions de règlement (`core.settlement_settlement`, `core.settlement_settlement_leg`) et les soldes par jambe (`core.settlement_trip_leg_balance`) : politiques `worker_money_read` de 0027 et 0036. Onze contrôles (codes PROPOSÉS) : `SETTLEMENT_LEGS_INCOMPLETE`, `SETTLEMENT_LEG_NEGATIVE`, `SETTLEMENT_LEGS_SUM`, `SETTLEMENT_HOST_LEG`, `SETTLEMENT_REFUND_BALANCE`, `SETTLEMENT_VARIATIONS_REFUND`, `SETTLEMENT_VERSION_CHAIN`, `LEG_BALANCE_OVERDRAWN` et, depuis US-217a (ADR-161), `TRIP_CAPTURE_LEGS` (Σ capturé = Σ des encaissements portés = Σ de leurs jambes), `TRIP_SETTLED_TOTAL` (total payé de la version en tête = encaissé), `STATEMENT_HOST_LEG` (jambe HOST du relevé de l'hôte = jambe HOST attendue, lue d'une autre source), sur les faits par trip de `core.finance_trip_leg_facts()` (0137 ; requête `tripLegFactsSql`, source `TRIP_LEG_FACTS_SOURCE`, montants et pays seulement ; depuis US-221b, 0146, ADR-170 : tout trip ayant un encaissement prouvé est examiné et « encaissé » compte les encaissements portés ou prouvés, si bien qu'un encaissement prouvé jamais porté ressort en `TRIP_CAPTURE_LEGS`). Leurs règles et leurs sources (08 E1, E4, E7 ; 17 §2.9, §3.2.8) sont dans l'en-tête du fichier. Le rapport ne contient que des comptes par contrôle et par pays. Tout écart lève une alerte P1 `FIN_MONEY_RECONCILIATION` par pays (runbook `docs/ops/MONITORING.md`). Un contexte autre que ce travailleur lève `MoneyReconciliationContractError` (jamais de zéros trompeurs). Les requêtes d'agrégat (`settlementAggregatesSql`, `legBalanceAggregatesSql`) lisent leurs tables en CTE (`SETTLEMENT_SOURCE`, `SETTLEMENT_LEG_SOURCE`, `LEG_BALANCE_SOURCE`) : le test d'intégration y ajoute une ligne en écart pour prouver la détection sur PostgreSQL réel, et la tâche n'utilise que les tables. Depuis US-227, quatorze contrôles (section suivante). +`internal/money-reconciliation.ts` : tâche périodique du travailleur `reconciliation` (24 h, PROPOSÉ ; déclarée dans `apps/api/src/worker-tasks.ts`). En lecture seule, sur toute la base, elle relit les versions de règlement (`core.settlement_settlement`, `core.settlement_settlement_leg`) et les soldes par jambe (`core.settlement_trip_leg_balance`) : politiques `worker_money_read` de 0027 et 0036. Onze contrôles (codes PROPOSÉS) : `SETTLEMENT_LEGS_INCOMPLETE`, `SETTLEMENT_LEG_NEGATIVE`, `SETTLEMENT_LEGS_SUM`, `SETTLEMENT_HOST_LEG`, `SETTLEMENT_REFUND_BALANCE`, `SETTLEMENT_VARIATIONS_REFUND`, `SETTLEMENT_VERSION_CHAIN`, `LEG_BALANCE_OVERDRAWN` et, depuis US-217a (ADR-161), `TRIP_CAPTURE_LEGS` (Σ capturé = Σ des encaissements portés = Σ de leurs jambes), `TRIP_SETTLED_TOTAL` (total payé de la version en tête = encaissé), `STATEMENT_HOST_LEG` (jambe HOST du relevé de l'hôte = jambe HOST attendue, lue d'une autre source), sur les faits par trip de `core.finance_trip_leg_facts()` (0137 ; requête `tripLegFactsSql`, source `TRIP_LEG_FACTS_SOURCE`, montants et pays seulement ; depuis US-221b, 0146, ADR-170 : tout trip dont la disposition `CONVERSION` porte une capture prouvée est examiné et « encaissé » compte cette capture, si bien qu'une capture convertie jamais portée ressort en `TRIP_CAPTURE_LEGS`). Leurs règles et leurs sources (08 E1, E4, E7 ; 17 §2.9, §3.2.8) sont dans l'en-tête du fichier. Le rapport ne contient que des comptes par contrôle et par pays. Tout écart lève une alerte P1 `FIN_MONEY_RECONCILIATION` par pays (runbook `docs/ops/MONITORING.md`). Un contexte autre que ce travailleur lève `MoneyReconciliationContractError` (jamais de zéros trompeurs). Les requêtes d'agrégat (`settlementAggregatesSql`, `legBalanceAggregatesSql`) lisent leurs tables en CTE (`SETTLEMENT_SOURCE`, `SETTLEMENT_LEG_SOURCE`, `LEG_BALANCE_SOURCE`) : le test d'intégration y ajoute une ligne en écart pour prouver la détection sur PostgreSQL réel, et la tâche n'utilise que les tables. Depuis US-227, quatorze contrôles (section suivante). ## Jambe de l'assureur au rapprochement (US-227, ADR-165) diff --git a/changelog.d/US-221-report-capture.md b/changelog.d/US-221-report-capture.md index 6ff0e384..297bfbe3 100644 --- a/changelog.d/US-221-report-capture.md +++ b/changelog.d/US-221-report-capture.md @@ -2,4 +2,4 @@ lot: L2 module: Règlement et finance - Corrigé : le paiement d'un voyage réservé par le checkout est désormais porté, au moment même de la réservation, sur la part de l'hôte, de l'assureur, de la taxe et de Kmino, chacune à son montant exact, et la part de l'assureur entre dans son registre ; une confirmation rejouée ne le porte jamais deux fois (US-221) -- Corrigé : le contrôle de nuit de l'argent voit tout voyage dont le paiement est prouvé, même s'il n'a pas été porté sur ses parts, et le signale alors comme un écart (US-221) +- Corrigé : le contrôle de nuit de l'argent voit tout voyage réservé dont le paiement est prouvé, même s'il n'a pas été porté sur ses parts, et le signale alors comme un écart (US-221) diff --git a/docs/adr/ADR-170-report-de-la-capture-convertie.md b/docs/adr/ADR-170-report-de-la-capture-convertie.md index 0e1aaa50..10c715af 100644 --- a/docs/adr/ADR-170-report-de-la-capture-convertie.md +++ b/docs/adr/ADR-170-report-de-la-capture-convertie.md @@ -15,7 +15,7 @@ 2. **Commande dédiée** (`cmd_money_owner`, `SECURITY DEFINER`, `EXECUTE` `app_worker`, travailleurs `booking_conversion`, `disposition_sweeper`, `payment_intent_sweeper`) plutôt qu'un élargissement de `settlement_cmd_apply_leg_movement` (travailleur `payment_command`) : le périmètre est fermé à la capture d'un hold converti. Sous le verrou du trip : disposition `CONVERSION` exigée, `DUPLICATE` si un mouvement existe déjà, opération `CAPTURE` de loyer `SUCCEEDED` **prouvée**, même devise et même pays que le trip, quatre jambes ≥ 0 de Σ = montant, garde de détention de fonds de 0123 (`funds_holding_enabled`, fail-closed). Puis rattachement de l'opération et de ses jambes au trip, quatre soldes créés à zéro, `captured_minor` de chaque jambe = **sa** jambe de l'opération (montant explicite, égal au devis figé contrôlé à l'étape 2 de la conversion), mouvement `CAPTURE` (le déclencheur de 0143 écrit la `COLLECTION` de la jambe `INSURER`). Contrôle final : opération et jambes rattachées, chaque solde = sa jambe, sinon refus (une ligne filtrée par la RLS ne passe jamais en silence). 3. **Droits au plus juste, miroir exact** : `cmd_money_owner` lit la disposition (quatre colonnes) et reçoit `UPDATE (trip_id)` de l'opération et des jambes. Politiques ajoutées, réservées aux trois travailleurs de conversion : rattachement d'une `CAPTURE` prouvée sans trip au trip de **sa** disposition `CONVERSION` ; mouvement `CAPTURE` de l'opération de la disposition du trip ; solde créé à zéro puis `captured_minor` = jambe de cette opération, tout autre cumul nul. Déclencheurs (tous rôles, sur un changement de `trip_id`) : `trip_id` d'une opération ou d'une jambe ne passe que de `NULL` au trip de la conversion, sans autre changement (`operation_trip_attach_invalid` ⇒ `INVARIANT_VIOLATION`). 4. **Rejeu idempotent** : une conversion rejouée (`REPLAY`) d'une `CAPTURE` appelle la même commande, qui rend `DUPLICATE` ; elle rattrape une conversion antérieure à 0146 jamais portée. `settlement_cmd_apply_leg_movement` rejoué sur la capture rend `DUPLICATE` (mouvement unique par opération). -5. **Rapprochement (D2)** : un trip est tenu dès qu'il a un encaissement **prouvé** (`CAPTURE`, `MIT_CHARGE`, `DEBT_COLLECTION` du périmètre du loyer, `SUCCEEDED`, preuve rattachée), rattaché au trip ou à sa disposition `CONVERSION`. « Encaissé » = Σ des encaissements portés **ou** prouvés : un encaissement prouvé jamais porté ressort en `TRIP_CAPTURE_LEGS` (Σ capturé ≠ Σ encaissé) et en `STATEMENT_HOST_LEG` (aucune ligne de relevé). Un encaissement non prouvé n'est pas un encaissement (ADR-139). +5. **Rapprochement (D2)** : un trip est tenu dès que sa disposition `CONVERSION` porte une `CAPTURE` **prouvée** (`SUCCEEDED`, preuve rattachée). « Encaissé » = Σ des encaissements portés et de cette capture : une capture convertie jamais portée ressort en `TRIP_CAPTURE_LEGS` (Σ capturé ≠ Σ encaissé) et en `STATEMENT_HOST_LEG` (aucune ligne de relevé). Un encaissement non prouvé n'est pas un encaissement (ADR-139). Les encaissements rattachés directement au trip (`MIT_CHARGE`, `DEBT_COLLECTION`, capture d'un trip) restent jugés une fois portés : leur report après la preuve appartient à la boîte d'envoi monétaire (`payment_command`, non déclarée avant le lot C), et les compter avant créerait un écart de nuit à chaque preuve en attente de report (essai de la CI : scènes de `concurrence-webhook.int.test.ts`, run 44397196230). ## Alternatives écartées @@ -26,6 +26,7 @@ ## Limites et conséquences (suites) +- Encaissement rattaché directement au trip, prouvé mais non porté (MIT, recouvrement) : à faire entrer dans les faits avec le report à la preuve de la boîte d'envoi monétaire (lot C), avec un délai de grâce PROPOSÉ. - Aucune reprise des conversions antérieures à 0146 par migration (aucune donnée de production en bêta) : rattrapage au rejeu de la conversion, et le rapprochement les signale (D2). - Le parcours doré d'US-221 (PR #245) : son test `it.fails` « D2 (défaut) » passe désormais (à retirer à sa fusion) ; « D1 (défaut) » appelle `settlement_cmd_apply_leg_movement` sur la capture et attend `APPLIED` : il obtient `DUPLICATE` (capture déjà portée à la conversion) et doit être réécrit sur les soldes, comme la preuve L0 de cette story. - Annulation du trip converti par le vrai chemin (`TripCancellationProcessor` sans `tripOf`), contrat et constancia du trip réservé : suites de la passation US-221 (trous 1 et 2), débloquées. diff --git a/docs/team/handoffs/US-221.md b/docs/team/handoffs/US-221.md index c6b99b3b..3c5d34dd 100644 --- a/docs/team/handoffs/US-221.md +++ b/docs/team/handoffs/US-221.md @@ -9,7 +9,7 @@ Revues exigées (`node scripts/ci/check-story-reviews.mjs --branch story/US-221- ## Ce qui est livré - **D1** : `core.booking_convert_payment` (corps de 0126 recopié) appelle, dans la transaction de la conversion d'une `CAPTURE`, la nouvelle commande `core.settlement_cmd_apply_conversion_capture(uuid)` (cmd_money_owner, SECURITY DEFINER, EXECUTE app_worker, travailleurs de conversion) : rattachement de l'opération et de ses jambes au trip de la disposition `CONVERSION`, quatre soldes, chaque jambe à son montant explicite (jambe de l'opération = devis figé, contrôlé à l'étape 2), mouvement `CAPTURE`, `COLLECTION` de l'assureur (déclencheur de 0143). Rejeu : `DUPLICATE` (aucun double report) ; un `REPLAY` rattrape une conversion antérieure non portée. Un refus annule la conversion (fail-closed : aucun trip sans ses soldes). -- **D2** : `core.finance_trip_leg_facts()` (corps de 0137 recopié) tient tout trip ayant un encaissement prouvé (rattaché au trip ou à sa disposition `CONVERSION`) ; « encaissé » = portés ou prouvés : un encaissement prouvé jamais porté ressort en `TRIP_CAPTURE_LEGS` et `STATEMENT_HOST_LEG`. +- **D2** : `core.finance_trip_leg_facts()` (corps de 0137 recopié) tient tout trip dont la disposition `CONVERSION` porte une capture prouvée ; « encaissé » = portés et cette capture : une capture convertie jamais portée ressort en `TRIP_CAPTURE_LEGS` et `STATEMENT_HOST_LEG`. Périmètre volontairement borné au hold converti (formule de la passation US-221) : compter aussi les encaissements rattachés directement au trip a rendu la CI rouge (run 44397196230, job « guide d'installation » : les scènes de `concurrence-webhook.int.test.ts` laissent des captures de trip prouvées que rien ne porte avant la boîte d'envoi monétaire du lot C, et le rapprochement de toute la base les comptait) ; suite inscrite dans ADR-170. - Droits et gardes : politiques `cmd_money_conversion_*` (miroir exact de la capture), déclencheurs `operation_trip_attach_guard` / `operation_leg_trip_attach_guard` (`operation_trip_attach_invalid` ⇒ `INVARIANT_VIOLATION`). - Preuves : `packages/db/test/l0/l0-us221b-conversion-capture.test.ts` (groupe isolé, données commitées, vraies commandes sous app_api / app_worker, L0-05 par `connectAs`), PA / USD (TJ01) et PY / PYG (TJ08a), attendus tirés de `check_legs.py` (`python -I -X utf8`) et recoupés avec l'export. Test de sécurité modifié : `packages/db/test/int/stl-schema.test.ts` (inventaire des écrivains de `trip_leg_balance` : deux politiques de conversion ajoutées, commentaire ligne à ligne). diff --git a/packages/db/README.md b/packages/db/README.md index 785f6734..c396292b 100644 --- a/packages/db/README.md +++ b/packages/db/README.md @@ -1065,10 +1065,10 @@ Migration `0144_booking_meeting_place`. Fixture `9939_test_us514_meeting_place_f ## Report de la capture convertie (US-221 partie 221b ; défauts D1 et D2 d'US-221 ; 08 E7 règles 1, 2, 10 ; ADR-170) -Migration `0146_settlement_conversion_capture_legs`. Fixture `9936_test_us221b_conversion_capture_fixtures.sql` (encaissement prouvé jamais porté sur un trip de fixture, transaction annulée ; état de rattachement et de report d'une opération). +Migration `0146_settlement_conversion_capture_legs`. Fixture `9936_test_us221b_conversion_capture_fixtures.sql` (disposition `CONVERSION` sans report, forme d'avant 0146, transaction annulée ; état de rattachement et de report d'une opération). - **Conversion** : `core.booking_convert_payment` (0126) remplacé à signature, propriétaire et droits identiques : la conversion d'une `CAPTURE` appelle, dans sa transaction, `core.settlement_cmd_apply_conversion_capture(uuid)` (cmd_money_owner, EXECUTE app_worker, travailleurs `booking_conversion`, `disposition_sweeper`, `payment_intent_sweeper`) : rattachement de l'opération et de ses jambes au trip de la disposition `CONVERSION`, chaque jambe portée à son montant explicite, mouvement `CAPTURE` (écriture `COLLECTION` de l'assureur par 0143) ; `DUPLICATE` au rejeu ; un refus annule la conversion. - **Droits** : `SELECT (operation_id, hold_id, disposition, trip_id)` de `booking_payment_disposition` et `UPDATE (trip_id)` de `payment_payment_operation` et `payment_payment_operation_leg` à cmd_money_owner ; politiques `cmd_money_conversion_attach`, `cmd_money_conversion_ins`, `cmd_money_conversion_upd` (travailleurs de conversion, miroir exact de la capture) ; déclencheurs `operation_trip_attach_guard`, `operation_leg_trip_attach_guard` (tous rôles). -- **Rapprochement** : `core.finance_trip_leg_facts()` (0137) remplacé : tout trip ayant un encaissement prouvé est tenu ; « encaissé » = encaissements portés ou prouvés. +- **Rapprochement** : `core.finance_trip_leg_facts()` (0137) remplacé : tout trip dont la disposition `CONVERSION` porte une capture prouvée est tenu ; « encaissé » = encaissements portés et cette capture. - **Codes** : `operation_trip_attach_invalid` ⇒ `INVARIANT_VIOLATION` ; refus du report sous les noms de 0123 (`leg_movement_unsupported`, `leg_movement_unproven`, `leg_movement_not_succeeded`, `leg_funds_holding_disabled`). - **Preuves** : `test/l0/l0-us221b-conversion-capture.test.ts` (TJ01 PA USD, TJ08a PY PYG ; groupe isolé) ; inventaire des écrivains de `trip_leg_balance` mis à jour (`test/int/stl-schema.test.ts`). diff --git a/packages/db/migrations/0146_settlement_conversion_capture_legs.sql b/packages/db/migrations/0146_settlement_conversion_capture_legs.sql index 6e5918ca..b992c817 100644 --- a/packages/db/migrations/0146_settlement_conversion_capture_legs.sql +++ b/packages/db/migrations/0146_settlement_conversion_capture_legs.sql @@ -34,10 +34,11 @@ -- COLLECTION de la jambe INSURER) ; idempotente (`DUPLICATE`) ; mêmes refus que le report de -- 0123 (preuve, périmètre, quatre jambes, Σ jambes = montant, détention de fonds) ; -- 5. `core.finance_trip_leg_facts()` (corps de 0137 recopié, blocs marqués US-221b) : un trip est --- tenu dès qu'il a un encaissement PROUVÉ (opération CAPTURE, MIT_CHARGE ou DEBT_COLLECTION du --- périmètre du loyer, SUCCEEDED, preuve rattachée), rattaché au trip ou à sa disposition --- CONVERSION ; « encaissé » = Σ des encaissements prouvés (et non plus seulement des portés) : --- un encaissement prouvé jamais porté ressort en `TRIP_CAPTURE_LEGS` ; +-- tenu dès que sa disposition CONVERSION porte une CAPTURE PROUVÉE (SUCCEEDED, preuve +-- rattachée) ; « encaissé » = Σ des encaissements portés et de cette capture : une capture +-- convertie jamais portée ressort en `TRIP_CAPTURE_LEGS` (les encaissements rattachés +-- directement au trip, MIT et recouvrements, restent jugés une fois portés : leur report +-- après la preuve est celui de la boîte d'envoi monétaire, lot C) ; -- 6. `core.booking_convert_payment(uuid)` (corps de 0126 recopié, blocs marqués US-221b) : la -- conversion d'une CAPTURE appelle la commande 4 dans la même transaction (un refus annule la -- conversion : aucun trip sans ses soldes, la tâche réessaie et compte l'erreur) ; un rejeu @@ -409,21 +410,21 @@ BEGIN END IF; RETURN QUERY WITH enc AS ( - -- US-221b (D2) : encaissements du trip = ceux qui sont portés sur les soldes UNION ceux qui - -- sont PROUVÉS (SUCCEEDED, preuve rattachée, périmètre du loyer), rattachés au trip ou à sa - -- disposition CONVERSION ; un encaissement prouvé jamais porté est donc vu (et en écart) + -- US-221b (D2) : encaissements du trip = ceux qui sont portés sur les soldes UNION la capture + -- PROUVÉE (SUCCEEDED, preuve rattachée) qui a converti un hold en ce trip (disposition + -- CONVERSION) ; une capture convertie jamais portée est donc vue (et en écart). Un + -- encaissement rattaché directement au trip (MIT, recouvrement) est porté par la boîte d'envoi + -- monétaire après sa preuve (lot C) : hors de ces faits tant que ce report n'existe pas SELECT m.trip_id, m.operation_id AS op_id FROM core.settlement_leg_movement AS m WHERE m.segment_no = 1 AND m.kind IN ('CAPTURE', 'MIT_CHARGE', 'DEBT_COLLECTION') UNION - SELECT COALESCE(o.trip_id, d.trip_id), o.id - FROM core.payment_payment_operation AS o - LEFT JOIN core.booking_payment_disposition AS d - ON d.operation_id = o.id AND d.disposition = 'CONVERSION' - WHERE o.status = 'SUCCEEDED' AND o.proof_type IS NOT NULL - AND o.kind IN ('CAPTURE', 'MIT_CHARGE', 'DEBT_COLLECTION') - AND o.purpose IN ('RENT', 'RENT_SHORTFALL', 'NO_SHOW_RETENTION') - AND COALESCE(o.trip_id, d.trip_id) IS NOT NULL + SELECT d.trip_id, o.id + FROM core.booking_payment_disposition AS d + JOIN core.payment_payment_operation AS o ON o.id = d.operation_id + WHERE d.disposition = 'CONVERSION' + AND o.status = 'SUCCEEDED' AND o.proof_type IS NOT NULL + AND o.kind = 'CAPTURE' AND o.purpose = 'RENT' ), held AS ( SELECT b.trip_id AS id FROM core.settlement_trip_leg_balance AS b WHERE b.segment_no = 1 @@ -490,8 +491,8 @@ BEGIN END $fn$; COMMENT ON FUNCTION core.finance_trip_leg_facts() IS - 'Faits de l''invariant par jambe, par trip tenu (soldes, règlement ou encaissement prouvé) : Σ ' - 'capturé, Σ des encaissements portés ou prouvés et de leurs jambes, total payé de la version en ' + 'Faits de l''invariant par jambe, par trip tenu (soldes, règlement ou capture convertie prouvée) : ' + 'Σ capturé, Σ des encaissements portés ou convertis prouvés et de leurs jambes, total payé de la version en ' 'tête, jambe HOST attendue et jambe HOST du relevé. Travailleur reconciliation seulement ' '(EXECUTE app_worker). US-217 (217a, ADR-161), US-221 (221b, ADR-170).'; diff --git a/packages/db/test-migrations/9936_test_us221b_conversion_capture_fixtures.sql b/packages/db/test-migrations/9936_test_us221b_conversion_capture_fixtures.sql index 1e5511ca..861a028b 100644 --- a/packages/db/test-migrations/9936_test_us221b_conversion_capture_fixtures.sql +++ b/packages/db/test-migrations/9936_test_us221b_conversion_capture_fixtures.sql @@ -5,43 +5,29 @@ -- jetable principale `rueda_test_*`. -- -- Rôle (SECURITY DEFINER sous migrator, search_path figé ; aucun SQL dynamique) : --- 1. `us221b_proven_capture` : encaissement PROUVÉ (CAPTURE de loyer SUCCEEDED, preuve --- WEBHOOK_SIGNED, quatre jambes données par l'appelant, montant = Σ jambes) rattaché à un trip --- de fixture et JAMAIS porté sur les soldes : la forme qu'avait un trip réservé avant 0146 --- (défaut D2 de la passation US-221) ; appelée SEULEMENT dans une transaction annulée ; +-- 1. `us221b_legacy_conversion` : disposition CONVERSION d'une capture prouvée vers un trip de +-- fixture, SANS report sur les soldes : la forme qu'avait un trip réservé avant 0146 (défaut +-- D2 de la passation US-221) ; appelée SEULEMENT dans une transaction annulée (le contrôle +-- différé de la disposition n'est jamais atteint) ; -- 2. `us221b_capture_state` : rattachement et report d'une opération (trip de l'opération et de -- ses jambes, mouvements), lecture des preuves sous app_worker. -- AUCUNE fixture n'écrit un interrupteur de mise en service (17 §0.1). -- --- Retour arrière : DROP FUNCTION test_fixture.us221b_proven_capture(uuid, uuid, jsonb), +-- Retour arrière : DROP FUNCTION test_fixture.us221b_legacy_conversion(uuid, uuid), -- test_fixture.us221b_capture_state(uuid). -CREATE FUNCTION test_fixture.us221b_proven_capture(p_operation_id uuid, p_trip_id uuid, - p_legs jsonb) +CREATE FUNCTION test_fixture.us221b_legacy_conversion(p_operation_id uuid, p_trip_id uuid) RETURNS void - LANGUAGE plpgsql + LANGUAGE sql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $fn$ -DECLARE - t record; -BEGIN - SELECT x.org_id, x.country_code, x.currency INTO t FROM core.booking_trip AS x - WHERE x.id = p_trip_id; - INSERT INTO core.payment_payment_operation - (id, trip_id, psp_account_id, country_code, provider, kind, purpose, amount_minor, currency, - attempt_no, status, idem_plain, idem_sent, proof_type) - SELECT p_operation_id, p_trip_id, test_fixture.fixture_psp_account(t.country_code), - t.country_code, 'FAKE', 'CAPTURE', 'RENT', - (SELECT pg_catalog.sum((l.value #>> '{}')::bigint) - FROM pg_catalog.jsonb_each(p_legs) AS l), - t.currency, 1, 'SUCCEEDED', pg_catalog.format('us221b:%s', p_operation_id), - pg_catalog.format('us221b:%s', p_operation_id), 'WEBHOOK_SIGNED'; - INSERT INTO core.payment_payment_operation_leg - (operation_id, leg, org_id, trip_id, country_code, amount_minor) - SELECT p_operation_id, l.key, t.org_id, p_trip_id, t.country_code, (l.value #>> '{}')::bigint - FROM pg_catalog.jsonb_each(p_legs) AS l; -END + -- disposition CONVERSION posée SANS le report (forme d'avant 0146) ; le contrôle différé de la + -- disposition (hold CONVERTED) n'est jamais atteint : transaction annulée seulement + INSERT INTO core.booking_payment_disposition (operation_id, hold_id, disposition, trip_id) + SELECT o.id, o.hold_id, 'CONVERSION', p_trip_id + FROM core.payment_payment_operation AS o + WHERE o.id = p_operation_id $fn$; CREATE FUNCTION test_fixture.us221b_capture_state(p_operation_id uuid) @@ -62,7 +48,7 @@ AS $fn$ WHERE o.id = p_operation_id $fn$; -REVOKE ALL ON FUNCTION test_fixture.us221b_proven_capture(uuid, uuid, jsonb), +REVOKE ALL ON FUNCTION test_fixture.us221b_legacy_conversion(uuid, uuid), test_fixture.us221b_capture_state(uuid) FROM PUBLIC; -GRANT EXECUTE ON FUNCTION test_fixture.us221b_proven_capture(uuid, uuid, jsonb), +GRANT EXECUTE ON FUNCTION test_fixture.us221b_legacy_conversion(uuid, uuid), test_fixture.us221b_capture_state(uuid) TO app_worker; diff --git a/packages/db/test/l0/l0-us221b-conversion-capture.test.ts b/packages/db/test/l0/l0-us221b-conversion-capture.test.ts index dd90a374..fa5c937e 100644 --- a/packages/db/test/l0/l0-us221b-conversion-capture.test.ts +++ b/packages/db/test/l0/l0-us221b-conversion-capture.test.ts @@ -6,8 +6,8 @@ * D1 : à la conversion gardée, la CAPTURE prouvée est rattachée au trip né et reportée sur CHAQUE * jambe avec son montant explicite (jamais un prorata), dans la même transaction ; COLLECTION de la * jambe INSURER au registre de l'assureur ; rejeu sans double report. - * D2 : un trip qui a un encaissement prouvé jamais porté est vu par les faits de l'invariant par - * jambe du rapprochement (Σ capturé ≠ Σ encaissé). + * D2 : un trip dont la capture convertie et prouvée n'est pas portée est vu par les faits de + * l'invariant par jambe du rapprochement (Σ capturé ≠ Σ encaissé). * * Attendus : vecteurs TJ01 (USD) et TJ08a (PYG) de l'oracle Python (`docs/specs/tools/check_legs.py`, * `python -I -X utf8` : « TJ01 (USD) : 131,25 / 25,50 / 0,00 / 99,91 / 256,66 » et « TJ08a (PYG) : @@ -393,7 +393,7 @@ describe.each(COUNTRIES)( ); it( - 'garde : report refusé hors des travailleurs de conversion (42501) et pour une opération sans conversion (leg_movement_unsupported) ; app_api sans EXECUTE', + 'garde : report refusé hors des travailleurs de conversion (42501) et pour une opération sans conversion (leg_movement_unsupported) ; app_api sans EXECUTE ; D2 : capture convertie jamais portée vue en écart par le rapprochement', async () => { const T0 = era(idx + 2); const w = await world(c, T0); @@ -419,6 +419,24 @@ describe.each(COUNTRIES)( }); // rien n'a été porté ni rattaché expect(await captureState(op)).toMatchObject({ operation_trip_id: null, movements: 0 }); + // D2 (transaction ANNULÉE) : la même capture prouvée convertie SANS report (forme d'avant + // 0146 : disposition CONVERSION, aucun solde) est vue par les faits du rapprochement, en + // écart (Σ capturé 0 ≠ Σ encaissé ; aucune ligne de relevé) + await inTx(worker, {}, async (tx) => { + const trip = await insertTrip(tx, c, 9000 + idx); + await tx.query('SELECT test_fixture.us221b_legacy_conversion($1, $2)', [op, trip.id]); + await asReconciliation(tx); + const { rows } = await tx.query(FACTS_SQL, [trip.id]); + expect(rows).toEqual([ + { + captured: '0', + collected: o.total.toString(), + collected_legs: o.total.toString(), + expected_host: o.legs.HOST.toString(), + statement_host: null, + }, + ]); + }); // la vraie conversion porte ensuite la capture (aucune opération prouvée laissée sans // disposition dans la base partagée) const r = await convert(op, at(T0, 4)); @@ -430,28 +448,5 @@ describe.each(COUNTRIES)( }, LONG, ); - - it('D2 : un encaissement prouvé jamais porté (forme d’avant 0146) est vu par le rapprochement, en écart (Σ capturé 0 ≠ Σ encaissé)', async () => { - await inTx(worker, {}, async (tx) => { - const trip = await insertTrip(tx, c, 9000 + idx); - const op = uuid(); - await tx.query('SELECT test_fixture.us221b_proven_capture($1, $2, $3::jsonb)', [ - op, - trip.id, - legsJson(o.legs), - ]); - await asReconciliation(tx); - const { rows } = await tx.query(FACTS_SQL, [trip.id]); - expect(rows).toEqual([ - { - captured: '0', - collected: o.total.toString(), - collected_legs: o.total.toString(), - expected_host: o.legs.HOST.toString(), - statement_host: null, - }, - ]); - }); - }); }, ); From c4bb41e6760be38253d3dfb1e591aa6a9af36cd4 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 18:43:18 -0300 Subject: [PATCH 4/7] =?UTF-8?q?docs(US-221b):=20schema.md=20recopi=C3=A9?= =?UTF-8?q?=20de=20la=20sortie=20du=20job=20=C2=AB=20base=20de=20donn?= =?UTF-8?q?=C3=A9es=20=C2=BB=20(0147,=20apr=C3=A8s=20#242)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Agent-Role: argent Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- docs/architecture/schema.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/docs/architecture/schema.md b/docs/architecture/schema.md index fec6f73b..85ddf4d3 100644 --- a/docs/architecture/schema.md +++ b/docs/architecture/schema.md @@ -7,7 +7,7 @@ Lu dans le catalogue (`pg_catalog`) d'une base jetable du banc, après les seule ## Synthèse -- 147 migrations ; 129 tables ; 3 vues ; 728 politiques RLS ; 294 fonctions `SECURITY DEFINER` ; 253 autres fonctions. +- 148 migrations ; 129 tables ; 3 vues ; 734 politiques RLS ; 295 fonctions `SECURITY DEFINER` ; 255 autres fonctions. - Tables sans RLS `ENABLE` + `FORCE` : aucune. - Rôles applicatifs avec `SUPERUSER` ou `BYPASSRLS` : aucun. @@ -162,6 +162,7 @@ Lu dans le catalogue (`pg_catalog`) d'une base jetable du banc, après les seule | `0144_booking_meeting_place` | AVL / CAT : lieux de prise et de retour (US-514 ; 19 US-514 ; 16 BKG-016 ; 08 BR-BOOK-09 ; | | `0145_finance_receipt_alignment` | FIN : alignement des reçus et du relevé des gains sur les décisions écrites d'US-217 | | `0146_payment_deposit_hold` | PAY : caution de la plateforme figée au checkout (`deposit_hold`), vue du voyageur sans | +| `0147_settlement_conversion_capture_legs` | STL / AVL / FIN : la capture prouvée d'un hold converti est rattachée au trip né de la | ## Rôles @@ -1014,6 +1015,7 @@ Index : Politiques RLS : - `cmd_hold_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `true` +- `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `integrity_read` (SELECT, PERMISSIVE, integrity_owner) USING `true` - `migrator_all` (ALL, PERMISSIVE, migrator) USING `true` WITH CHECK `true` - `worker_insert_conversion` (INSERT, PERMISSIVE, app_worker) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])))` @@ -4415,6 +4417,7 @@ Politiques RLS : - `cmd_hold_request_auth_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'GUEST'::text) AND (purpose = 'RENT'::text) AND (kind = 'AUTH'::text) AND (status = 'PENDING'::text) AND (trip_id IS NULL) AND (psp_account_id IS NOT NULL) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.guest_user_id = app.actor_id()) AND (h.kind = 'REQUEST'::text) AND (h.status = 'PAYMENT_IN_FLIGHT'::text)))))` - `cmd_hold_request_pay_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((purpose = 'RENT'::text) AND (status = 'PENDING'::text) AND (trip_id IS NULL) AND (psp_account_id IS NOT NULL) AND (((kind = 'CAPTURE'::text) AND (app.actor_kind() = 'HOST'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id()) AND (h.status = 'PAYMENT_IN_FLIGHT'::text) AND (h.request_respond_by IS NOT NULL))))) OR ((kind = 'VOID'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (((app.actor_kind() = 'HOST'::text) AND (h.org_id = app.org_id())) OR ((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['hold_expiry'::text, 'booking_conversion'::text]))))))))))` - `cmd_hold_request_pay_upd` (UPDATE, PERMISSIVE, cmd_hold_owner) USING `((app.actor_kind() = 'HOST'::text) AND (purpose = 'RENT'::text) AND (kind = 'CAPTURE'::text) AND (status = 'PENDING'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id())))))` WITH CHECK `((app.actor_kind() = 'HOST'::text) AND (status = 'SUBMITTED'::text))` +- `cmd_money_conversion_attach` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (trip_id IS NULL) AND (hold_id IS NOT NULL) AND (kind = 'CAPTURE'::text) AND (purpose = 'RENT'::text) AND (status = 'SUCCEEDED'::text) AND (proof_type IS NOT NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (kind = 'CAPTURE'::text) AND (purpose = 'RENT'::text) AND (status = 'SUCCEEDED'::text) AND (proof_type IS NOT NULL) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.operation_id = payment_payment_operation.id) AND (d.hold_id = payment_payment_operation.hold_id) AND (d.disposition = 'CONVERSION'::text) AND (d.trip_id = payment_payment_operation.trip_id)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text) AND (status = 'PENDING'::text) AND (psp_account_id IS NOT NULL))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `cmd_money_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['payment_command'::text, 'webhook_ingest'::text])) AND (psp_account_id IS NOT NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (psp_account_id IS NOT NULL))` @@ -4429,6 +4432,7 @@ Politiques RLS : Déclencheurs : +- `operation_trip_attach_guard` : `CREATE TRIGGER operation_trip_attach_guard BEFORE UPDATE OF trip_id ON core.payment_payment_operation FOR EACH ROW WHEN (old.trip_id IS DISTINCT FROM new.trip_id) EXECUTE FUNCTION core.payment_guard_operation_trip_attach()` - `payment_operation_legs_check` : `CREATE CONSTRAINT TRIGGER payment_operation_legs_check AFTER INSERT ON core.payment_payment_operation DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION core.payment_assert_operation_legs()` - `refund_instance_gate` : `CREATE TRIGGER refund_instance_gate BEFORE UPDATE OF status ON core.payment_payment_operation FOR EACH ROW EXECUTE FUNCTION core.payment_refund_instance_gate()` - `refund_instance_sync` : `CREATE TRIGGER refund_instance_sync AFTER UPDATE OF status ON core.payment_payment_operation FOR EACH ROW WHEN (new.kind = 'REFUND'::text) EXECUTE FUNCTION core.payment_refund_instance_sync()` @@ -4501,6 +4505,7 @@ Politiques RLS : - `cmd_hold_leg_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'GUEST'::text) AND (trip_id IS NULL) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.status = 'PENDING'::text) AND (o.purpose = 'RENT'::text) AND (h.guest_user_id = app.actor_id())))))` - `cmd_hold_leg_sel` (SELECT, PERMISSIVE, cmd_hold_owner) USING `((app.actor_kind() = 'GUEST'::text) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (h.guest_user_id = app.actor_id())))))` - `cmd_hold_request_leg_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'HOST'::text) AND (trip_id IS NULL) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.kind = 'CAPTURE'::text) AND (o.status = 'PENDING'::text) AND (o.purpose = 'RENT'::text) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id())))))` +- `cmd_money_conversion_attach` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (trip_id IS NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_payment_disposition d ON (((d.operation_id = o.id) AND (d.disposition = 'CONVERSION'::text)))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.trip_id = payment_payment_operation_leg.trip_id) AND (d.trip_id = payment_payment_operation_leg.trip_id)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `host_view_read` (SELECT, PERMISSIVE, host_view_owner) USING `true` @@ -4513,6 +4518,7 @@ Politiques RLS : Déclencheurs : +- `operation_leg_trip_attach_guard` : `CREATE TRIGGER operation_leg_trip_attach_guard BEFORE UPDATE OF trip_id ON core.payment_payment_operation_leg FOR EACH ROW WHEN (old.trip_id IS DISTINCT FROM new.trip_id) EXECUTE FUNCTION core.payment_guard_leg_trip_attach()` - `payment_operation_leg_release_guard` : `CREATE TRIGGER payment_operation_leg_release_guard AFTER INSERT ON core.payment_payment_operation_leg REFERENCING NEW TABLE AS new_legs FOR EACH STATEMENT EXECUTE FUNCTION core.payment_operation_leg_release_guard()` - `payment_operation_legs_check` : `CREATE CONSTRAINT TRIGGER payment_operation_legs_check AFTER INSERT ON core.payment_payment_operation_leg DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION core.payment_assert_operation_legs()` @@ -5739,6 +5745,7 @@ Index : Politiques RLS : +- `cmd_money_conversion_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (kind = 'CAPTURE'::text) AND (segment_no = 1) AND (EXISTS ( SELECT 1 FROM (core.booking_payment_disposition d JOIN core.payment_payment_operation o ON ((o.id = d.operation_id))) WHERE ((d.operation_id = settlement_leg_movement.operation_id) AND (d.trip_id = settlement_leg_movement.trip_id) AND (d.disposition = 'CONVERSION'::text) AND (o.trip_id = settlement_leg_movement.trip_id) AND (o.kind = 'CAPTURE'::text) AND (o.status = 'SUCCEEDED'::text) AND (o.proof_type IS NOT NULL)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `migrator_all` (ALL, PERMISSIVE, migrator) USING `true` WITH CHECK `true` @@ -6082,6 +6089,8 @@ Index : Politiques RLS : +- `cmd_money_conversion_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text)))))` +- `cmd_money_conversion_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text)))))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (captured_minor = ( SELECT g.amount_minor FROM (core.booking_payment_disposition d JOIN core.payment_payment_operation_leg g ON ((g.operation_id = d.operation_id))) WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text) AND (g.leg = settlement_trip_leg_balance.leg)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `cmd_money_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` @@ -6744,6 +6753,7 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.settlement_assert_balanced()` | `trigger` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_money_owner: EXECUTE | | `core.settlement_assert_cancellation_refunded()` | `trigger` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_money_owner: EXECUTE | | `core.settlement_cancellation_of(p_settlement_id uuid)` | `TABLE(id uuid, trip_id uuid, segment_no integer, version integer, supersedes_id uuid, kind text, requested_reason text, reason text, origin text, target_state text, inputs jsonb, superseded boolean)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_hold_owner: EXECUTE ; cmd_money_owner: EXECUTE | +| `core.settlement_cmd_apply_conversion_capture(p_operation_id uuid)` | `text` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_apply_leg_movement(p_operation_id uuid)` | `text` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_approve_finance_action(p_token_hash bytea, p_approval_id uuid)` | `TABLE(outcome text, approval_id uuid)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_api: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_draft_insurer_bordereaux(p_month text)` | `TABLE(outcome text, country text, bordereau uuid, lines integer, total bigint)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | @@ -6967,6 +6977,8 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.payment_capability_value(p_provider text, p_country text, p_method text, p_capability text)` | `jsonb` | `migrator` | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE ; migrator: EXECUTE | | `core.payment_deposit_amount_param(p_key text, p_country text)` | `jsonb` | `cmd_hold_owner` | cmd_hold_owner: EXECUTE | | `core.payment_deposit_hold_guard()` | `trigger` | `migrator` | migrator: EXECUTE | +| `core.payment_guard_leg_trip_attach()` | `trigger` | `migrator` | migrator: EXECUTE | +| `core.payment_guard_operation_trip_attach()` | `trigger` | `migrator` | migrator: EXECUTE | | `core.payment_missing_blocking_capabilities(p_provider text, p_country text, p_mode text)` | `text[]` | `migrator` | app_api: EXECUTE ; app_worker: EXECUTE ; cmd_hold_owner: EXECUTE ; cmd_money_owner: EXECUTE ; kyc_cmd_owner: EXECUTE ; migrator: EXECUTE | | `core.payment_operation_leg_release_guard()` | `trigger` | `migrator` | migrator: EXECUTE | | `core.payment_psp_account_fake_guard()` | `trigger` | `migrator` | migrator: EXECUTE | From 328dc8d7a2ea55440b85332e91c5b5c5a274c060 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 19:16:46 -0300 Subject: [PATCH 5/7] =?UTF-8?q?docs(US-221b):=20revues=20ind=C3=A9pendante?= =?UTF-8?q?s=20de=20la=20PR=20246=20(architecture,=20argent,=20code,=20qa,?= =?UTF-8?q?=20securite)=20au=20SHA=20c4bb41e6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5.5 Agent-Role: revue-argent Agent-Model: claude-sonnet-5-5 --- .../reviews/US-221/architecture-2026-11-18r.md | 16 ++++++++++++++++ docs/team/reviews/US-221/argent-2026-11-18r.md | 18 ++++++++++++++++++ docs/team/reviews/US-221/code-2026-11-18r.md | 15 +++++++++++++++ docs/team/reviews/US-221/qa-2026-11-18r.md | 15 +++++++++++++++ .../reviews/US-221/securite-2026-11-18r.md | 17 +++++++++++++++++ 5 files changed, 81 insertions(+) create mode 100644 docs/team/reviews/US-221/architecture-2026-11-18r.md create mode 100644 docs/team/reviews/US-221/argent-2026-11-18r.md create mode 100644 docs/team/reviews/US-221/code-2026-11-18r.md create mode 100644 docs/team/reviews/US-221/qa-2026-11-18r.md create mode 100644 docs/team/reviews/US-221/securite-2026-11-18r.md diff --git a/docs/team/reviews/US-221/architecture-2026-11-18r.md b/docs/team/reviews/US-221/architecture-2026-11-18r.md new file mode 100644 index 00000000..d855f9e8 --- /dev/null +++ b/docs/team/reviews/US-221/architecture-2026-11-18r.md @@ -0,0 +1,16 @@ +# Revue architecture — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (r) + +Relecteur : revue-architecture / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : eb90f895..c4bb41e6 (SHA revu : c4bb41e6) + +Contexte : `git diff eb90f895...c4bb41e6` relu dans un worktree détaché (migration 0147, fixture 9936, ADR-170, passation US-221 partie 221b, CLAUDE.md, 08 E7 règles 1, 2 et 10, 17 v6 §2.3, §2.5, §2.9, définitions précédentes 0123, 0126, 0137, 0143) ; attendus recalculés avec `check_legs.py` ; aucune base ni Docker démarrés ici ; CI de la PR verte au SHA de tête. + +| # | Gravité | Constat | +| --- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| 1 | INFO | **Découpage** : la conversion (module booking, `booking_convert_payment`, recopie fidèle de 0126, seuls deux blocs US-221b ajoutés : vérifié par `diff` du corps) appelle la commande de règlement (module STL, famille `cmd_money`) dans la même transaction ; frontière respectée (passage par la fonction publique du schéma `core`, pas d’accès direct de booking aux tables de STL). Commande dédiée plutôt qu’élargissement de `settlement_cmd_apply_leg_movement` : périmètre fermé, justifié dans ADR-170. | +| 2 | INFO | **Conformité à 17 v6** : §2.5 étape 4 (conversion gardée, trip et soldes dans la même transaction) et §2.9 (soldes modifiés seulement par une commande `settlement_cmd_*` dans la transaction qui reçoit la preuve) ; report dans 17 annoncé comme demande de fusion de spécification (ADR-170 en tête). `CREATE OR REPLACE` à signature, propriétaire et droits identiques ; expand / contract respecté (rien n’est retiré, retour arrière écrit). | +| 3 | INFO | **D2** : `finance_trip_leg_facts` (corps de 0137, diff relu) étendu de façon étroite et tracée ; la suite (MIT, recouvrement, lot C) est inscrite dans ADR-170 « Limites ». | +| 4 | INFO | **Documentation** : ADR-170, passation US-221 (partie 221b), README `packages/db` et `fin`, `schema.md`, entrée `changelog.d` présents ; aucun texte visible (aucun catalogue es / en / fr / pt-BR à compléter). | +| 5 | MINEUR | **Réserve (non bloquante)** : phrase d’ADR-170 (« l’opération reste due et visible par le rapprochement (D2) ») inexacte quand la conversion entière est annulée (aucune disposition, donc hors des faits de D2) ; à corriger ou à rattacher à un détecteur du lot C. Numéro 0147 à renuméroter à la fusion (annoncé dans la passation). | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/argent-2026-11-18r.md b/docs/team/reviews/US-221/argent-2026-11-18r.md new file mode 100644 index 00000000..d5775a10 --- /dev/null +++ b/docs/team/reviews/US-221/argent-2026-11-18r.md @@ -0,0 +1,18 @@ +# Revue argent — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (r) + +Relecteur : revue-argent / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : eb90f895..c4bb41e6 (SHA revu : c4bb41e6) + +Contexte : `git diff eb90f895...c4bb41e6` relu dans un worktree détaché (migration 0147, fixture 9936, ADR-170, passation US-221 partie 221b, CLAUDE.md, 08 E7 règles 1, 2 et 10, 17 v6 §2.3, §2.5, §2.9, définitions précédentes 0123, 0126, 0137, 0143) ; attendus recalculés avec `check_legs.py` ; aucune base ni Docker démarrés ici ; CI de la PR verte au SHA de tête. + +| # | Gravité | Constat | +| --- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| 1 | INFO | **Montants et Σ jambes** : attendus recalculés avec `python -I -X utf8 docs/specs/tools/check_legs.py` (TJ01 USD 131,25 / 25,50 / 0,00 / 99,91 = 256,66 ; TJ08a PYG 787 500 / 105 000 / 0 / 545 550 = 1 438 050), égaux aux constantes du test ; la commande lit les jambes de l’opération (jamais un paramètre), exige 4 jambes ≥ 0 de somme = montant, et la conversion a déjà contrôlé chaque jambe contre le devis figé (étape 2). Chaque solde reçoit SA jambe (`captured = captured + leg`), contrôle final solde = jambe, sinon refus : aucun prorata. | +| 2 | INFO | **Idempotence et concurrence** : ordre de verrous inchangé et cohérent avec 0099 / 0124 (advisory voyageur, advisory véhicule, puis trip) ; la commande verrouille le trip puis rend `DUPLICATE` si un mouvement existe (unicité par opération) ; deux conversions simultanées sont sérialisées par les verrous consultatifs, le second passage prend la branche `REPLAY` ⇒ `DUPLICATE`. Webhook rejoué ⇒ `DUPLICATE` sans conversion. Un rejeu n’ajoute jamais de montant (la politique n’admet la mise à jour que sur un solde à zéro). | +| 3 | INFO | **Aucun chemin vers un autre trip** : politiques d’UPDATE de `trip_id` (opération et jambes) bornées aux trois travailleurs de conversion, CAPTURE de loyer SUCCEEDED prouvée sans trip, WITH CHECK = trip de SA disposition CONVERSION ; déclencheurs tous rôles (NULL vers ce trip, rien d’autre ne change). Une opération AUTH ne peut pas être rattachée (la politique exige `kind = CAPTURE`). | +| 4 | INFO | **Aucun fonds de tiers, aucun interrupteur** : garde `funds_holding_enabled` de 0123 reprise (lecture fail-closed par `core.config_go_live`), `collection_mode` PLATFORM_MOR toujours fermé par CHECK ; aucun interrupteur ni paramètre écrit ; aucune horloge SQL nouvelle (`platform.now()` conservé dans la conversion). | +| 5 | INFO | **D2** : l’UNION des encaissements portés et de la capture convertie prouvée dédoublonne par (trip, opération) : aucun double comptage d’une capture à la fois portée et convertie ; une capture convertie non portée ressort bien en `TRIP_CAPTURE_LEGS` (Σ capturé 0 ≠ Σ encaissé) et `STATEMENT_HOST_LEG`. Le rapprochement n’est pas rendu vert à tort ; l’exclusion MIT / recouvrement est inscrite dans ADR-170 (« Limites ») et dans le commentaire de la fonction. | +| 6 | MINEUR | **Réserve (non bloquante) : refus de report = conversion annulée, sans compensation** ; une CAPTURE prouvée dont le report serait refusé (cas non atteignable en bêta : mode PLATFORM_MOR fermé, jambes déjà contrôlées) laisserait un paiement encaissé sans trip ni disposition, que D2 ne voit pas (il ne tient que les captures ayant une disposition CONVERSION, annulée avec la conversion). ADR-170 écrit « visible par le rapprochement (D2) » : inexact pour ce cas précis ; la tâche réessaie et compte l’erreur. À rattacher au lot C (détecteur « SUCCEEDED prouvée sans disposition ») et à corriger dans la phrase de l’ADR. | +| 7 | MINEUR | **Réserve : rejeu d’une conversion antérieure à 0147** dont le trip porte déjà d’autres mouvements ou soldes non nuls lève un refus (fail-closed) au lieu de `REPLAY` ; sans effet en bêta (aucune donnée de production), noté dans ADR-170. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/code-2026-11-18r.md b/docs/team/reviews/US-221/code-2026-11-18r.md new file mode 100644 index 00000000..0516b263 --- /dev/null +++ b/docs/team/reviews/US-221/code-2026-11-18r.md @@ -0,0 +1,15 @@ +# Revue code — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (r) + +Relecteur : revue-code / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : eb90f895..c4bb41e6 (SHA revu : c4bb41e6) + +Contexte : `git diff eb90f895...c4bb41e6` relu dans un worktree détaché (migration 0147, fixture 9936, ADR-170, passation US-221 partie 221b, CLAUDE.md, 08 E7 règles 1, 2 et 10, 17 v6 §2.3, §2.5, §2.9, définitions précédentes 0123, 0126, 0137, 0143) ; attendus recalculés avec `check_legs.py` ; aucune base ni Docker démarrés ici ; CI de la PR verte au SHA de tête. + +| # | Gravité | Constat | +| --- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Fidélité de la recopie** : `diff` du corps de `booking_convert_payment` contre 0126 = deux blocs ajoutés (REPLAY et après la disposition CONVERSION) ; `finance_trip_leg_facts` contre 0137 = CTE `enc` ajoutée, `held` et `ops` réécrites sur `enc`, reste inchangé. Le report est dans le bloc BEGIN … EXCEPTION de la ré-acquisition : une erreur autre que `exclusion_violation` remonte et annule la conversion, comme annoncé. | +| 2 | INFO | **Commande** : verrous, ordre des gardes, `RETURN` `DUPLICATE` / `APPLIED`, contrôle final fail-closed des quatre soldes ; `ON CONFLICT DO NOTHING` sur les lignes de solde puis mise à jour filtrée par la politique : une ligne déjà portée n’est pas écrasée et fait échouer le contrôle. Variables et alias qualifiés, `search_path` figé, commentaires de fonction présents. | +| 3 | INFO | **Erreurs** : code `operation_trip_attach_invalid` ajouté à `CONSTRAINT_CODES` et à `errors.test.ts` ; refus du report sous les noms existants de 0123 (déjà traduits). Allowlist SECURITY DEFINER, README et changelog à jour ; CI verte au SHA de tête (18 contrôles, dont base de données L0 et revues). | +| 4 | MINEUR | **Lisibilité** : la liste des trois travailleurs est répétée dans huit endroits (quatre politiques, la commande, la conversion, la fixture) ; acceptable (miroir exact voulu) mais une fonction commune éviterait une dérive à la prochaine modification. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/qa-2026-11-18r.md b/docs/team/reviews/US-221/qa-2026-11-18r.md new file mode 100644 index 00000000..8e216294 --- /dev/null +++ b/docs/team/reviews/US-221/qa-2026-11-18r.md @@ -0,0 +1,15 @@ +# Revue qa — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (r) + +Relecteur : revue-qa / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : eb90f895..c4bb41e6 (SHA revu : c4bb41e6) + +Contexte : `git diff eb90f895...c4bb41e6` relu dans un worktree détaché (migration 0147, fixture 9936, ADR-170, passation US-221 partie 221b, CLAUDE.md, 08 E7 règles 1, 2 et 10, 17 v6 §2.3, §2.5, §2.9, définitions précédentes 0123, 0126, 0137, 0143) ; attendus recalculés avec `check_legs.py` ; aucune base ni Docker démarrés ici ; CI de la PR verte au SHA de tête. + +| # | Gravité | Constat | +| --- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Preuves L0 sous rôles de production** : `l0-us221b-conversion-capture.test.ts`, assertion L0-05 par `connectAs` (`app_api`, `app_worker`), jamais migrator ; PA / USD (TJ01) et PY / PYG (TJ08a), `describe.each(COUNTRIES)` ; vraies commandes de bout en bout (pose du hold, T1, T2, preuve, conversion) ; attendus tirés de l’oracle Python (recalculé ici : égal) et recoupés avec l’export `golden_vectors.json`, jamais du code testé. | +| 2 | INFO | **Couverture** : soldes = jambes (Σ = total), rattachement de l’opération et des jambes, mouvement CAPTURE, COLLECTION de l’assureur au bon montant, trois rejeux (conversion, webhook, `apply_leg_movement` ⇒ `DUPLICATE`, un seul mouvement, soldes inchangés), faits du rapprochement égaux, refus 42501 pour trois noms de travailleur et `app_api`, refus `leg_movement_unsupported`, D2 en transaction annulée (écart Σ capturé 0 ≠ Σ encaissé). Projet vitest isolé (données commitées, période d’horloge propre). CI verte au SHA de tête, base de données et L0 compris. | +| 3 | MINEUR | **Réserve (non bloquante)** : non couverts par un test, alors que l’ADR les affirme : (a) la conversion annulée par un refus du report (fail-closed), (b) les refus directs des déclencheurs et des politiques de rattachement (`operation_trip_attach_invalid`), (c) deux conversions réellement simultanées (la sérialisation repose sur les verrous consultatifs existants et sur le test de rejeu séquentiel). À ajouter en suite (la scène (a) demande une fixture de test qui force un refus, par exemple un compte hors SPLIT_AT_SOURCE avec `funds_holding_enabled` faux). | +| 4 | INFO | **Modification de `stl-schema.test.ts`** justifiée et non affaiblie (égalité exacte conservée, deux politiques attendues en plus) ; `errors.test.ts` complété ; aucune écriture d’interrupteur dans la fixture ni dans le test. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/securite-2026-11-18r.md b/docs/team/reviews/US-221/securite-2026-11-18r.md new file mode 100644 index 00000000..93dd1905 --- /dev/null +++ b/docs/team/reviews/US-221/securite-2026-11-18r.md @@ -0,0 +1,17 @@ +# Revue securite — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (r) + +Relecteur : revue-securite / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : eb90f895..c4bb41e6 (SHA revu : c4bb41e6) + +Contexte : `git diff eb90f895...c4bb41e6` relu dans un worktree détaché (migration 0147, fixture 9936, ADR-170, passation US-221 partie 221b, CLAUDE.md, 08 E7 règles 1, 2 et 10, 17 v6 §2.3, §2.5, §2.9, définitions précédentes 0123, 0126, 0137, 0143) ; attendus recalculés avec `check_legs.py` ; aucune base ni Docker démarrés ici ; CI de la PR verte au SHA de tête. + +| # | Gravité | Constat | +| --- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | +| 1 | INFO | **SECURITY DEFINER** : `core.settlement_cmd_apply_conversion_capture(uuid)` propriétaire `cmd_money_owner`, `SET search_path = pg_catalog, pg_temp`, noms qualifiés, aucun SQL dynamique, `REVOKE ALL … FROM PUBLIC`, `EXECUTE` `app_worker` seul, garde interne `actor_kind = WORKER` et nom dans les trois travailleurs de conversion (42501 sinon, vérifié par le test pour `payment_command`, `reconciliation`, `webhook_ingest` et `app_api`). Entrée dans `security-definer-allowlist.json` exacte (signature, famille `cmd_money`, propriétaire, execute, story). | +| 2 | INFO | **Droits minimaux** : `SELECT` de quatre colonnes de la disposition (pas de donnée personnelle) et `UPDATE (trip_id)` seulement ; politiques `cmd_money_conversion_*` limitées aux trois travailleurs, au miroir exact de la capture (mouvement CAPTURE de l’opération de la disposition, soldes créés à zéro puis `captured = jambe` de cette opération, tout autre cumul nul, non gelé). `FORCE` RLS inchangé, aucun `BYPASSRLS`. `CREATE` sur le schéma accordé puis retiré dans la migration, `RESET ROLE` fait. | +| 3 | INFO | **Déclencheurs** `operation_trip_attach_guard` et `operation_leg_trip_attach_guard` : `search_path` figé, tous rôles, `trip_id` ne passe que de NULL au trip de la disposition CONVERSION de l’opération et rien d’autre ne change ; le code `operation_trip_attach_invalid` est traduit en `INVARIANT_VIOLATION` (`errors.ts`, `errors.test.ts`). Pas d’élévation : une opération non convertie, une AUTH ou le trip d’un tiers ne se rattachent pas. | +| 4 | INFO | **Modification de `stl-schema.test.ts`** : l’inventaire reste une égalité exacte (`toEqual`) sur les écrivains de `trip_leg_balance`, il liste désormais quatre politiques au lieu de deux ; non affaibli (toute politique supplémentaire fait échouer le test), commentaire justifié par ADR-170. | +| 5 | INFO | **Secrets et interrupteurs** : aucun secret ; aucun interrupteur de mise en service lu autrement que par `core.config_go_live` (fail-closed), aucun écrit ; fixtures 9936 de test seulement (SECURITY DEFINER de test, `search_path` figé, base jetable). | +| 6 | MINEUR | **Réserve (non bloquante)** : les déclencheurs et les refus de politique (rattachement à un autre trip, travailleur hors liste appelant directement) ne sont couverts que par construction : aucun test ne tente le rattachement hors commande (les rôles applicatifs n’ont pas `UPDATE (trip_id)`). Un test d’intégration par fixture définer ou `SET LOCAL ROLE` dans une transaction annulée est recommandé en suite. | + +Verdict : APPROUVÉ From 2151c3f7f942af78ab6e6d23cb553f080108d2f2 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 20:34:05 -0300 Subject: [PATCH 6/7] =?UTF-8?q?docs(US-221b):=20schema.md=20recopi=C3=A9?= =?UTF-8?q?=20de=20la=20sortie=20du=20job=20=C2=AB=20base=20de=20donn?= =?UTF-8?q?=C3=A9es=20=C2=BB=20(0149,=20apr=C3=A8s=20#244=20et=20#247)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Agent-Role: argent Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- docs/architecture/schema.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/docs/architecture/schema.md b/docs/architecture/schema.md index 63d771c9..f37d6079 100644 --- a/docs/architecture/schema.md +++ b/docs/architecture/schema.md @@ -7,7 +7,7 @@ Lu dans le catalogue (`pg_catalog`) d'une base jetable du banc, après les seule ## Synthèse -- 149 migrations ; 129 tables ; 3 vues ; 728 politiques RLS ; 295 fonctions `SECURITY DEFINER` ; 253 autres fonctions. +- 150 migrations ; 129 tables ; 3 vues ; 734 politiques RLS ; 296 fonctions `SECURITY DEFINER` ; 255 autres fonctions. - Tables sans RLS `ENABLE` + `FORCE` : aucune. - Rôles applicatifs avec `SUPERUSER` ou `BYPASSRLS` : aucun. @@ -164,6 +164,7 @@ Lu dans le catalogue (`pg_catalog`) d'une base jetable du banc, après les seule | `0146_payment_deposit_hold` | PAY : caution de la plateforme figée au checkout (`deposit_hold`), vue du voyageur sans | | `0147_ctr_constancia_frozen_host_checkout_host` | CTR / AVL : hôte de la constancia lu du contrat FIGÉ ; hôte en prénom et initiale au | | `0148_hardening_country_open` | SUP / FIN / CAT : durcissement avant l'ouverture d'un pays (suites des revues : BOARD | +| `0149_settlement_conversion_capture_legs` | STL / AVL / FIN : la capture prouvée d'un hold converti est rattachée au trip né de la | ## Rôles @@ -1016,6 +1017,7 @@ Index : Politiques RLS : - `cmd_hold_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `true` +- `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `integrity_read` (SELECT, PERMISSIVE, integrity_owner) USING `true` - `migrator_all` (ALL, PERMISSIVE, migrator) USING `true` WITH CHECK `true` - `worker_insert_conversion` (INSERT, PERMISSIVE, app_worker) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])))` @@ -4417,6 +4419,7 @@ Politiques RLS : - `cmd_hold_request_auth_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'GUEST'::text) AND (purpose = 'RENT'::text) AND (kind = 'AUTH'::text) AND (status = 'PENDING'::text) AND (trip_id IS NULL) AND (psp_account_id IS NOT NULL) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.guest_user_id = app.actor_id()) AND (h.kind = 'REQUEST'::text) AND (h.status = 'PAYMENT_IN_FLIGHT'::text)))))` - `cmd_hold_request_pay_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((purpose = 'RENT'::text) AND (status = 'PENDING'::text) AND (trip_id IS NULL) AND (psp_account_id IS NOT NULL) AND (((kind = 'CAPTURE'::text) AND (app.actor_kind() = 'HOST'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id()) AND (h.status = 'PAYMENT_IN_FLIGHT'::text) AND (h.request_respond_by IS NOT NULL))))) OR ((kind = 'VOID'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (((app.actor_kind() = 'HOST'::text) AND (h.org_id = app.org_id())) OR ((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['hold_expiry'::text, 'booking_conversion'::text]))))))))))` - `cmd_hold_request_pay_upd` (UPDATE, PERMISSIVE, cmd_hold_owner) USING `((app.actor_kind() = 'HOST'::text) AND (purpose = 'RENT'::text) AND (kind = 'CAPTURE'::text) AND (status = 'PENDING'::text) AND (EXISTS ( SELECT 1 FROM core.booking_checkout_hold h WHERE ((h.id = payment_payment_operation.hold_id) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id())))))` WITH CHECK `((app.actor_kind() = 'HOST'::text) AND (status = 'SUBMITTED'::text))` +- `cmd_money_conversion_attach` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (trip_id IS NULL) AND (hold_id IS NOT NULL) AND (kind = 'CAPTURE'::text) AND (purpose = 'RENT'::text) AND (status = 'SUCCEEDED'::text) AND (proof_type IS NOT NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (kind = 'CAPTURE'::text) AND (purpose = 'RENT'::text) AND (status = 'SUCCEEDED'::text) AND (proof_type IS NOT NULL) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.operation_id = payment_payment_operation.id) AND (d.hold_id = payment_payment_operation.hold_id) AND (d.disposition = 'CONVERSION'::text) AND (d.trip_id = payment_payment_operation.trip_id)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text) AND (status = 'PENDING'::text) AND (psp_account_id IS NOT NULL))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `cmd_money_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['payment_command'::text, 'webhook_ingest'::text])) AND (psp_account_id IS NOT NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (psp_account_id IS NOT NULL))` @@ -4431,6 +4434,7 @@ Politiques RLS : Déclencheurs : +- `operation_trip_attach_guard` : `CREATE TRIGGER operation_trip_attach_guard BEFORE UPDATE OF trip_id ON core.payment_payment_operation FOR EACH ROW WHEN (old.trip_id IS DISTINCT FROM new.trip_id) EXECUTE FUNCTION core.payment_guard_operation_trip_attach()` - `payment_operation_legs_check` : `CREATE CONSTRAINT TRIGGER payment_operation_legs_check AFTER INSERT ON core.payment_payment_operation DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION core.payment_assert_operation_legs()` - `refund_instance_gate` : `CREATE TRIGGER refund_instance_gate BEFORE UPDATE OF status ON core.payment_payment_operation FOR EACH ROW EXECUTE FUNCTION core.payment_refund_instance_gate()` - `refund_instance_sync` : `CREATE TRIGGER refund_instance_sync AFTER UPDATE OF status ON core.payment_payment_operation FOR EACH ROW WHEN (new.kind = 'REFUND'::text) EXECUTE FUNCTION core.payment_refund_instance_sync()` @@ -4503,6 +4507,7 @@ Politiques RLS : - `cmd_hold_leg_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'GUEST'::text) AND (trip_id IS NULL) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.status = 'PENDING'::text) AND (o.purpose = 'RENT'::text) AND (h.guest_user_id = app.actor_id())))))` - `cmd_hold_leg_sel` (SELECT, PERMISSIVE, cmd_hold_owner) USING `((app.actor_kind() = 'GUEST'::text) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (h.guest_user_id = app.actor_id())))))` - `cmd_hold_request_leg_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((app.actor_kind() = 'HOST'::text) AND (trip_id IS NULL) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_checkout_hold h ON ((h.id = o.hold_id))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.kind = 'CAPTURE'::text) AND (o.status = 'PENDING'::text) AND (o.purpose = 'RENT'::text) AND (h.kind = 'REQUEST'::text) AND (h.org_id = app.org_id())))))` +- `cmd_money_conversion_attach` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (trip_id IS NULL))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (EXISTS ( SELECT 1 FROM (core.payment_payment_operation o JOIN core.booking_payment_disposition d ON (((d.operation_id = o.id) AND (d.disposition = 'CONVERSION'::text)))) WHERE ((o.id = payment_payment_operation_leg.operation_id) AND (o.trip_id = payment_payment_operation_leg.trip_id) AND (d.trip_id = payment_payment_operation_leg.trip_id)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `host_view_read` (SELECT, PERMISSIVE, host_view_owner) USING `true` @@ -4515,6 +4520,7 @@ Politiques RLS : Déclencheurs : +- `operation_leg_trip_attach_guard` : `CREATE TRIGGER operation_leg_trip_attach_guard BEFORE UPDATE OF trip_id ON core.payment_payment_operation_leg FOR EACH ROW WHEN (old.trip_id IS DISTINCT FROM new.trip_id) EXECUTE FUNCTION core.payment_guard_leg_trip_attach()` - `payment_operation_leg_release_guard` : `CREATE TRIGGER payment_operation_leg_release_guard AFTER INSERT ON core.payment_payment_operation_leg REFERENCING NEW TABLE AS new_legs FOR EACH STATEMENT EXECUTE FUNCTION core.payment_operation_leg_release_guard()` - `payment_operation_legs_check` : `CREATE CONSTRAINT TRIGGER payment_operation_legs_check AFTER INSERT ON core.payment_payment_operation_leg DEFERRABLE INITIALLY DEFERRED FOR EACH ROW EXECUTE FUNCTION core.payment_assert_operation_legs()` @@ -5741,6 +5747,7 @@ Index : Politiques RLS : +- `cmd_money_conversion_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (kind = 'CAPTURE'::text) AND (segment_no = 1) AND (EXISTS ( SELECT 1 FROM (core.booking_payment_disposition d JOIN core.payment_payment_operation o ON ((o.id = d.operation_id))) WHERE ((d.operation_id = settlement_leg_movement.operation_id) AND (d.trip_id = settlement_leg_movement.trip_id) AND (d.disposition = 'CONVERSION'::text) AND (o.trip_id = settlement_leg_movement.trip_id) AND (o.kind = 'CAPTURE'::text) AND (o.status = 'SUCCEEDED'::text) AND (o.proof_type IS NOT NULL)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `migrator_all` (ALL, PERMISSIVE, migrator) USING `true` WITH CHECK `true` @@ -6084,6 +6091,8 @@ Index : Politiques RLS : +- `cmd_money_conversion_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text)))))` +- `cmd_money_conversion_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (EXISTS ( SELECT 1 FROM core.booking_payment_disposition d WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text)))))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = ANY (ARRAY['booking_conversion'::text, 'disposition_sweeper'::text, 'payment_intent_sweeper'::text])) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen) AND (captured_minor = ( SELECT g.amount_minor FROM (core.booking_payment_disposition d JOIN core.payment_payment_operation_leg g ON ((g.operation_id = d.operation_id))) WHERE ((d.trip_id = settlement_trip_leg_balance.trip_id) AND (d.disposition = 'CONVERSION'::text) AND (g.leg = settlement_trip_leg_balance.leg)))))` - `cmd_money_ins` (INSERT, PERMISSIVE, cmd_money_owner) WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text) AND (captured_minor = 0) AND (refunded_minor = 0) AND (reallocated_in_minor = 0) AND (reallocated_out_minor = 0) AND (released_minor = 0) AND (NOT frozen))` - `cmd_money_sel` (SELECT, PERMISSIVE, cmd_money_owner) USING `true` - `cmd_money_upd` (UPDATE, PERMISSIVE, cmd_money_owner) USING `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` WITH CHECK `((app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` @@ -6747,6 +6756,7 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.settlement_assert_balanced()` | `trigger` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_money_owner: EXECUTE | | `core.settlement_assert_cancellation_refunded()` | `trigger` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_money_owner: EXECUTE | | `core.settlement_cancellation_of(p_settlement_id uuid)` | `TABLE(id uuid, trip_id uuid, segment_no integer, version integer, supersedes_id uuid, kind text, requested_reason text, reason text, origin text, target_state text, inputs jsonb, superseded boolean)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_hold_owner: EXECUTE ; cmd_money_owner: EXECUTE | +| `core.settlement_cmd_apply_conversion_capture(p_operation_id uuid)` | `text` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_apply_leg_movement(p_operation_id uuid)` | `text` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_approve_finance_action(p_token_hash bytea, p_approval_id uuid)` | `TABLE(outcome text, approval_id uuid)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_api: EXECUTE ; cmd_money_owner: EXECUTE | | `core.settlement_cmd_draft_insurer_bordereaux(p_month text)` | `TABLE(outcome text, country text, bordereau uuid, lines integer, total bigint)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | @@ -6970,6 +6980,8 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.payment_capability_value(p_provider text, p_country text, p_method text, p_capability text)` | `jsonb` | `migrator` | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE ; migrator: EXECUTE | | `core.payment_deposit_amount_param(p_key text, p_country text)` | `jsonb` | `cmd_hold_owner` | cmd_hold_owner: EXECUTE | | `core.payment_deposit_hold_guard()` | `trigger` | `migrator` | migrator: EXECUTE | +| `core.payment_guard_leg_trip_attach()` | `trigger` | `migrator` | migrator: EXECUTE | +| `core.payment_guard_operation_trip_attach()` | `trigger` | `migrator` | migrator: EXECUTE | | `core.payment_missing_blocking_capabilities(p_provider text, p_country text, p_mode text)` | `text[]` | `migrator` | app_api: EXECUTE ; app_worker: EXECUTE ; cmd_hold_owner: EXECUTE ; cmd_money_owner: EXECUTE ; kyc_cmd_owner: EXECUTE ; migrator: EXECUTE | | `core.payment_operation_leg_release_guard()` | `trigger` | `migrator` | migrator: EXECUTE | | `core.payment_psp_account_fake_guard()` | `trigger` | `migrator` | migrator: EXECUTE | From 1c377c8a8d8a19e18bb4301f2136ed9ce0a6148b Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 20:58:58 -0300 Subject: [PATCH 7/7] =?UTF-8?q?docs(US-221b):=20revues=20delta=20de=20la?= =?UTF-8?q?=20PR=20246=20au=20SHA=202151c3f7=20(renum=C3=A9rotation=200149?= =?UTF-8?q?)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5.5 Agent-Role: revue-argent Agent-Model: claude-sonnet-5-5 --- .../team/reviews/US-221/architecture-2026-11-18s.md | 13 +++++++++++++ docs/team/reviews/US-221/argent-2026-11-18s.md | 13 +++++++++++++ docs/team/reviews/US-221/code-2026-11-18s.md | 13 +++++++++++++ docs/team/reviews/US-221/qa-2026-11-18s.md | 13 +++++++++++++ docs/team/reviews/US-221/securite-2026-11-18s.md | 13 +++++++++++++ 5 files changed, 65 insertions(+) create mode 100644 docs/team/reviews/US-221/architecture-2026-11-18s.md create mode 100644 docs/team/reviews/US-221/argent-2026-11-18s.md create mode 100644 docs/team/reviews/US-221/code-2026-11-18s.md create mode 100644 docs/team/reviews/US-221/qa-2026-11-18s.md create mode 100644 docs/team/reviews/US-221/securite-2026-11-18s.md diff --git a/docs/team/reviews/US-221/architecture-2026-11-18s.md b/docs/team/reviews/US-221/architecture-2026-11-18s.md new file mode 100644 index 00000000..a45eb0a1 --- /dev/null +++ b/docs/team/reviews/US-221/architecture-2026-11-18s.md @@ -0,0 +1,13 @@ +# Revue architecture — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (s, delta) + +Relecteur : revue-architecture / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 278850cd..2151c3f7 (SHA revu : 2151c3f7) + +Contexte : delta `git diff 328dc8d7 2151c3f7` sur les fichiers de la PR (fusion de main avec #244 et #247, migration renumérotée 0147 → 0149) ; revues précédentes APPROUVÉ au SHA c4bb41e6 (`architecture-2026-11-18r.md`) reprises pour le reste ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Delta** : Renumérotation 0147 → 0149 après #244 (0147) et #247 (0148) ; ni 0147 ni 0148 ne redéfinissent `booking_convert_payment`, `finance_trip_leg_facts` ni `settlement_cmd_apply_leg_movement` (recherche par nom : aucune occurrence), donc aucune des deux recopies de corps n’est périmée. | +| 2 | INFO | **Fusion de main** : le fichier de migration est un renommage à deux lignes modifiées (numéro dans l'en-tête et le retour arrière) ; la fixture, le test L0, les tests et la documentation de la PR ne changent que par le numéro ; `schema.md` ne gagne que les lignes de 0149. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/argent-2026-11-18s.md b/docs/team/reviews/US-221/argent-2026-11-18s.md new file mode 100644 index 00000000..a3243040 --- /dev/null +++ b/docs/team/reviews/US-221/argent-2026-11-18s.md @@ -0,0 +1,13 @@ +# Revue argent — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (s, delta) + +Relecteur : revue-argent / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : 278850cd..2151c3f7 (SHA revu : 2151c3f7) + +Contexte : delta `git diff 328dc8d7 2151c3f7` sur les fichiers de la PR (fusion de main avec #244 et #247, migration renumérotée 0147 → 0149) ; revues précédentes APPROUVÉ au SHA c4bb41e6 (`argent-2026-11-18r.md`) reprises pour le reste ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Delta** : Aucun montant, jambe, verrou ni garde ne change : le corps SQL de la migration est identique à celui relu (r), hors deux lignes de commentaire portant le numéro. | +| 2 | INFO | **Fusion de main** : le fichier de migration est un renommage à deux lignes modifiées (numéro dans l'en-tête et le retour arrière) ; la fixture, le test L0, les tests et la documentation de la PR ne changent que par le numéro ; `schema.md` ne gagne que les lignes de 0149. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/code-2026-11-18s.md b/docs/team/reviews/US-221/code-2026-11-18s.md new file mode 100644 index 00000000..3fba6387 --- /dev/null +++ b/docs/team/reviews/US-221/code-2026-11-18s.md @@ -0,0 +1,13 @@ +# Revue code — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (s, delta) + +Relecteur : revue-code / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 278850cd..2151c3f7 (SHA revu : 2151c3f7) + +Contexte : delta `git diff 328dc8d7 2151c3f7` sur les fichiers de la PR (fusion de main avec #244 et #247, migration renumérotée 0147 → 0149) ; revues précédentes APPROUVÉ au SHA c4bb41e6 (`code-2026-11-18r.md`) reprises pour le reste ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Delta** : Fixture 9936, test L0, `stl-schema.test.ts`, `errors.ts` et `errors.test.ts`, ADR-170, README FIN et passation : seul le numéro de migration change (`git diff --word-diff`) ; README `packages/db` : section de #244 conservée, la nôtre ajoutée. | +| 2 | INFO | **Fusion de main** : le fichier de migration est un renommage à deux lignes modifiées (numéro dans l'en-tête et le retour arrière) ; la fixture, le test L0, les tests et la documentation de la PR ne changent que par le numéro ; `schema.md` ne gagne que les lignes de 0149. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/qa-2026-11-18s.md b/docs/team/reviews/US-221/qa-2026-11-18s.md new file mode 100644 index 00000000..7889bcb0 --- /dev/null +++ b/docs/team/reviews/US-221/qa-2026-11-18s.md @@ -0,0 +1,13 @@ +# Revue qa — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (s, delta) + +Relecteur : revue-qa / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5) +Entrées : 278850cd..2151c3f7 (SHA revu : 2151c3f7) + +Contexte : delta `git diff 328dc8d7 2151c3f7` sur les fichiers de la PR (fusion de main avec #244 et #247, migration renumérotée 0147 → 0149) ; revues précédentes APPROUVÉ au SHA c4bb41e6 (`qa-2026-11-18r.md`) reprises pour le reste ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Delta** : Tests : seul le numéro change (L0, `stl-schema.test.ts`, `errors.test.ts`) ; assertions et attendus de l’oracle inchangés. `schema.md` régénéré : uniquement les lignes 0149 (migration, politiques `cmd_money_*`, deux déclencheurs, commande, fonctions) et les compteurs. | +| 2 | INFO | **Fusion de main** : le fichier de migration est un renommage à deux lignes modifiées (numéro dans l'en-tête et le retour arrière) ; la fixture, le test L0, les tests et la documentation de la PR ne changent que par le numéro ; `schema.md` ne gagne que les lignes de 0149. | + +Verdict : APPROUVÉ diff --git a/docs/team/reviews/US-221/securite-2026-11-18s.md b/docs/team/reviews/US-221/securite-2026-11-18s.md new file mode 100644 index 00000000..c274cf84 --- /dev/null +++ b/docs/team/reviews/US-221/securite-2026-11-18s.md @@ -0,0 +1,13 @@ +# Revue securite — US-221 partie 221b « report de la capture convertie sur les soldes par jambe » (PR n° 246) — 2026-11-18 (s, delta) + +Relecteur : revue-securite / claude-sonnet-5-5 (famille A, modèle autre que l'auteur claude-opus-5-5; revue dégradée : famille B indisponible, TECH-007) +Entrées : 278850cd..2151c3f7 (SHA revu : 2151c3f7) + +Contexte : delta `git diff 328dc8d7 2151c3f7` sur les fichiers de la PR (fusion de main avec #244 et #247, migration renumérotée 0147 → 0149) ; revues précédentes APPROUVÉ au SHA c4bb41e6 (`securite-2026-11-18r.md`) reprises pour le reste ; aucune base ni Docker démarrés ici. + +| # | Gravité | Constat | +| --- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | INFO | **Delta** : Droits, politiques, déclencheurs, SECURITY DEFINER et entrée d’allowlist (`core.settlement_cmd_apply_conversion_capture(uuid)`, une seule occurrence) inchangés ; la seule autre entrée ajoutée à l’allowlist vient de main (#244, `booking_checkout_host_name`). | +| 2 | INFO | **Fusion de main** : le fichier de migration est un renommage à deux lignes modifiées (numéro dans l'en-tête et le retour arrière) ; la fixture, le test L0, les tests et la documentation de la PR ne changent que par le numéro ; `schema.md` ne gagne que les lignes de 0149. | + +Verdict : APPROUVÉ