From 1e91a15e6f7cb242d4ece41998a9125d5eaf4df8 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 19:26:17 -0300 Subject: [PATCH 1/5] =?UTF-8?q?feat(US-702):=20d=C3=A9cision=20de=20la=20c?= =?UTF-8?q?aution=20=C3=A0=20l'heure=20de=20d=C3=A9cision,=20transitions?= =?UTF-8?q?=20finales,=20=C3=A9ch=C3=A9ancier=20recalcul=C3=A9=20par=20la?= =?UTF-8?q?=20base?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - migration 0148 : file des décisions échues, transition finale gardée (Σ = montant, aucune capture après l'expiration, REFUNDED ⇔ rail b) et événement deposit.decision.executed ; fournisseur et échéancier de la décision recalculés par la base - DepositDecisionTimer dans la tâche deposit_timer : T57 (capture puis VOID), T58 (VOID puis MIT), expiration constatée sans appel, issue inconnue ⇒ même clé ; aucune source de frais annexes en production (caution libérée en entier) - avis au voyageur (NTF) en es, en, fr, pt-BR (catalogue v87) ; alertes DEPOSIT_DECISION_FAILED, DEPOSIT_FEES_UNCOLLECTED - suites d'US-701 : montants PYG de T73, test d'intégration des magasins de la minuterie, has_function_privilege ciblé app_anon, commentaire de période, sortie du refus vers /search - ADR-172, CHANGELOG, READMEs, COMME_TURO, GL-46, passation Agent-Role: argent Agent-Model: claude-opus-5-5 Co-Authored-By: Claude Opus 5.5 --- .../src/modules/bus/internal/alert-channel.ts | 4 + apps/api/src/modules/ntf/internal/catalog.ts | 56 +++ .../modules/ntf/internal/dispatcher.test.ts | 41 ++ apps/api/src/modules/pay/README.md | 50 +- apps/api/src/modules/pay/index.ts | 16 + .../pay/internal/deposit-checkout.test.ts | 22 +- .../modules/pay/internal/deposit-decision.ts | 324 +++++++++++++ .../src/modules/pay/internal/deposit-timer.ts | 39 +- .../pay/testing/deposit-decision.fake.test.ts | 330 +++++++++++++ .../testing/deposit-timer-store.int.test.ts | 189 ++++++++ .../pay/testing/deposit-timer.fake.test.ts | 31 +- apps/api/src/worker-tasks.ts | 2 +- .../app/(app)/checkout/hold/[holdId]/page.tsx | 4 +- apps/web/e2e/checkout-payment.spec.ts | 6 +- changelog.d/US-702-decision-caution.md | 9 + docs/adr/ADR-172-decision-de-la-caution.md | 29 ++ docs/ops/GO_LIVE_CHECKLIST.md | 2 +- docs/team/COMME_TURO.md | 1 + docs/team/handoffs/US-702.md | 40 ++ packages/db/README.md | 9 + .../0148_payment_deposit_decision.sql | 403 ++++++++++++++++ packages/db/personal-data-inventory.json | 5 +- packages/db/security-definer-allowlist.json | 14 + packages/db/src/errors.ts | 2 + ...4_test_us702_deposit_decision_fixtures.sql | 99 ++++ packages/db/test/int/outbox-schema.test.ts | 6 + .../db/test/l0/l0-us701-deposit-hold.test.ts | 8 +- .../test/l0/l0-us702-deposit-decision.test.ts | 441 ++++++++++++++++++ packages/i18n/src/catalogs/en.ts | 10 + packages/i18n/src/catalogs/es.ts | 10 + packages/i18n/src/catalogs/fr.ts | 10 + packages/i18n/src/catalogs/index.ts | 5 +- packages/i18n/src/catalogs/pt.ts | 10 + 33 files changed, 2184 insertions(+), 43 deletions(-) create mode 100644 apps/api/src/modules/pay/internal/deposit-decision.ts create mode 100644 apps/api/src/modules/pay/testing/deposit-decision.fake.test.ts create mode 100644 apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts create mode 100644 changelog.d/US-702-decision-caution.md create mode 100644 docs/adr/ADR-172-decision-de-la-caution.md create mode 100644 docs/team/handoffs/US-702.md create mode 100644 packages/db/migrations/0148_payment_deposit_decision.sql create mode 100644 packages/db/test-migrations/9934_test_us702_deposit_decision_fixtures.sql create mode 100644 packages/db/test/l0/l0-us702-deposit-decision.test.ts diff --git a/apps/api/src/modules/bus/internal/alert-channel.ts b/apps/api/src/modules/bus/internal/alert-channel.ts index a3c300ac..0210caaf 100644 --- a/apps/api/src/modules/bus/internal/alert-channel.ts +++ b/apps/api/src/modules/bus/internal/alert-channel.ts @@ -43,6 +43,10 @@ export const ALERT_CODES = [ // caution (US-701, ADR-169) : ré-autorisation refusée, trip signalé à l'ops, AUCUN débit // (19 US-225 critère 3) ; une fois par caution (la transition retire la minuterie) 'DEPOSIT_REAUTH_FAILED', + // décision de la caution (US-702, ADR-172) : annulation refusée (autorisation laissée expirer) ou + // autre échec de la décision (P1) ; frais annexes non recouvrés, caution libérée quand même (P2) + 'DEPOSIT_DECISION_FAILED', + 'DEPOSIT_FEES_UNCOLLECTED', // files de revue (US-106, ADR-106) : élément en retard (16 ADM-002, P2) ; dossier KYC en revue // qui ne peut pas être mis en file (P1 : personne ne le verrait) 'OPS_REVIEW_SLA_BREACH', diff --git a/apps/api/src/modules/ntf/internal/catalog.ts b/apps/api/src/modules/ntf/internal/catalog.ts index 66280c2d..e56c6ab7 100644 --- a/apps/api/src/modules/ntf/internal/catalog.ts +++ b/apps/api/src/modules/ntf/internal/catalog.ts @@ -138,6 +138,9 @@ export const TEMPLATE_KEYS = [ 'EVT_BOOKING_REQUEST_EXPIRED', 'EVT_BOOKING_REQUEST_FAILED', 'EVT_BOOKING_REQUEST_FAILED_HOST', + // décision de la caution (US-702, ADR-172) : libération entière, ou frais annoncés capturés + 'EVT_DEPOSIT_RELEASED', + 'EVT_DEPOSIT_PARTIALLY_CAPTURED', ] as const; export type TemplateKey = (typeof TEMPLATE_KEYS)[number]; @@ -148,6 +151,13 @@ const BOOKING_REF: VariableSource = { from: 'payload', type: 'ref', field: 'trip const REQUEST_REF: VariableSource = { from: 'payload', type: 'ref', field: 'hold_id' }; const START_AT: VariableSource = { from: 'payload', type: 'instant', field: 'scheduled_start' }; const END_AT: VariableSource = { from: 'payload', type: 'instant', field: 'scheduled_end' }; +/** Part de la caution libérée (VOID, expiration ou remboursement), US-702. */ +const RELEASED: VariableSource = { + from: 'payload', + type: 'money', + field: 'released_minor', + currencyField: 'currency', +}; /** Documents et confirmations : e-mail d'abord (preuve écrite), SMS en repli (16 A.8 « Notifications »). */ const EMAIL_THEN_SMS: readonly ChannelSpec[] = [{ channel: 'EMAIL', fallback: 'SMS' }]; @@ -308,6 +318,33 @@ export const TEMPLATES: Readonly> = { channels: EMAIL_THEN_SMS, critical: true, }, + // `deposit.decision.executed` (0148 : deposit_id, trip_id, status, captured_minor, + // released_minor, currency) ; 16 PAY-011 `EVT_DEPOSIT_RELEASED` (PROPOSÉ, ADR-172) + EVT_DEPOSIT_RELEASED: { + key: 'EVT_DEPOSIT_RELEASED', + slug: 'depositReleased', + variables: { first_name: FIRST_NAME, brand: BRAND, booking_ref: BOOKING_REF, amount: RELEASED }, + channels: EMAIL_THEN_SMS, + critical: false, + }, + EVT_DEPOSIT_PARTIALLY_CAPTURED: { + key: 'EVT_DEPOSIT_PARTIALLY_CAPTURED', + slug: 'depositPartiallyCaptured', + variables: { + first_name: FIRST_NAME, + brand: BRAND, + booking_ref: BOOKING_REF, + amount: RELEASED, + captured: { + from: 'payload', + type: 'money', + field: 'captured_minor', + currencyField: 'currency', + }, + }, + channels: EMAIL_THEN_SMS, + critical: false, + }, }; const GUEST: RecipientSpec = { role: 'GUEST', field: 'guest_user_id' }; @@ -457,6 +494,25 @@ export const RULES: readonly RuleSpec[] = [ recipients: [HOST], parties: CAPTURE_DECLINED_PARTIES, }, + // décision de la caution exécutée (0148, US-702, ADR-172 ; 16 PAY-011 « Notifications ») : + // voyageur du trip (parties lues en base) ; libération entière ou frais annoncés capturés + { + eventType: 'deposit.decision.executed', + template: 'EVT_DEPOSIT_RELEASED', + condition: { + field: 'status', + matches: (v) => v === 'VOIDED' || v === 'EXPIRED' || v === 'REFUNDED', + }, + recipients: [GUEST], + parties: TRIP_PARTIES, + }, + { + eventType: 'deposit.decision.executed', + template: 'EVT_DEPOSIT_PARTIALLY_CAPTURED', + condition: fieldIs('status', 'PARTIALLY_CAPTURED'), + recipients: [GUEST], + parties: TRIP_PARTIES, + }, ]; /** Types d'événements consommés par NTF (abonnement du travailleur `ntf_dispatcher`). */ diff --git a/apps/api/src/modules/ntf/internal/dispatcher.test.ts b/apps/api/src/modules/ntf/internal/dispatcher.test.ts index 4893276f..e87db35c 100644 --- a/apps/api/src/modules/ntf/internal/dispatcher.test.ts +++ b/apps/api/src/modules/ntf/internal/dispatcher.test.ts @@ -50,6 +50,7 @@ describe('abonnement', () => { 'booking.trip.host_restricted', 'booking.trip.host_restriction_lifted', 'catalog.addition_request.resolved', + 'deposit.decision.executed', 'kyc.verification.status_changed', 'payout.batch.status_changed', 'trip.overdue.detected', @@ -112,6 +113,46 @@ describe.each(COUNTRY_CASES)('planDispatches — $country ($currency)', (c) => { expect(() => planDispatches(real)).toThrow(NotificationContractError); }); + it('US-702 : décision de la caution exécutée ⇒ le voyageur du trip (base) ; libérée en entier ou frais annoncés capturés ; montants dans la devise du pays', () => { + // 0148 : deposit_id, trip_id, status, captured_minor, released_minor, currency, decided_at + const decided = (status: string, captured: string, released: string) => + event( + 'deposit.decision.executed', + { + deposit_id: randomUUID(), + trip_id: tripId, + status, + captured_minor: captured, + released_minor: released, + currency: c.currency, + decided_at: '2031-07-16T08:00:00+00:00', + }, + c.country, + ); + for (const status of ['VOIDED', 'EXPIRED', 'REFUNDED']) { + const plan = planDispatches(decided(status, '0', '1500000'), RULES, tripMap()); + expect(who(plan)).toEqual([['GUEST', guest, 'EMAIL', 'EVT_DEPOSIT_RELEASED']]); + expect(plan[0]?.variables).toEqual({ + booking_ref: '0190F5A2', + amount: { amount_minor: '1500000', currency: c.currency }, + }); + } + const partial = planDispatches( + decided('PARTIALLY_CAPTURED', '1200', '28800'), + RULES, + tripMap(), + ); + expect(who(partial)).toEqual([['GUEST', guest, 'EMAIL', 'EVT_DEPOSIT_PARTIALLY_CAPTURED']]); + expect(partial[0]?.variables).toEqual({ + booking_ref: '0190F5A2', + amount: { amount_minor: '28800', currency: c.currency }, + captured: { amount_minor: '1200', currency: c.currency }, + }); + // statut absent : erreur de contrat (jamais un avis deviné) + const bad = event('deposit.decision.executed', { trip_id: tripId }, c.country); + expect(() => planDispatches(bad, RULES, tripMap())).toThrow(NotificationContractError); + }); + it('US-213 : charge utile et base en désaccord sur une personne ⇒ erreur de contrat (jamais un mélange)', () => { const other = randomUUID(); expect(() => planDispatches(booked(), RULES, tripMap(tripFacts(other, host)))).toThrow( diff --git a/apps/api/src/modules/pay/README.md b/apps/api/src/modules/pay/README.md index f3c9eef6..8f4c3286 100644 --- a/apps/api/src/modules/pay/README.md +++ b/apps/api/src/modules/pay/README.md @@ -19,27 +19,27 @@ Détail fichier par fichier, FAKE et mode hostile : [`internal/README.md`](inter Entités de 17 §3.2.7 : -| Entité | État en base | -| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | -| `payment_operation` | table `core.payment_payment_operation` (migration 0005 ; `psp_account_id` 0028, `NOT NULL` 0038) | -| `webhook_inbox` | table `core.payment_webhook_inbox` (migration 0005 ; clé étrangère du compte 0038) | -| `psp_account` | table `core.payment_psp_account` (migration 0028) | -| `psp_capability` | table `core.payment_psp_capability` (migration 0028) | -| `payment_operation_leg` | table `core.payment_payment_operation_leg` (migration 0028) | -| `payment_operation_event` | table `core.payment_payment_operation_event` (migration 0028) | -| `psp_submerchant` | table `core.payment_psp_submerchant` (migration 0039) | -| `payment_command` | table `core.payment_payment_command` (migration 0040, réduite à `CANCEL_ORDER`) | -| `payment_operation_link` | cible 17, pas encore créée | -| `payment_instrument` | cible 17, pas encore créée | -| `mit_consent` | cible 17, pas encore créée | -| `tender` | cible 17, pas encore créée | -| `refund_instance` | cible 17, pas encore créée | -| `deposit_hold` | `core.payment_deposit_hold` (0146, US-701) : décision figée par hold avant le paiement, lue et écrite par les seules fonctions de cmd_hold_owner | -| `chargeback` | cible 17, pas encore créée | -| `debt_balance` | cible 17, pas encore créée | -| `payment_plan` | cible 17, pas encore créée | -| `payment_plan_installment` | cible 17, pas encore créée | -| `credit_lot` | cible 17, pas encore créée | +| Entité | État en base | +| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `payment_operation` | table `core.payment_payment_operation` (migration 0005 ; `psp_account_id` 0028, `NOT NULL` 0038) | +| `webhook_inbox` | table `core.payment_webhook_inbox` (migration 0005 ; clé étrangère du compte 0038) | +| `psp_account` | table `core.payment_psp_account` (migration 0028) | +| `psp_capability` | table `core.payment_psp_capability` (migration 0028) | +| `payment_operation_leg` | table `core.payment_payment_operation_leg` (migration 0028) | +| `payment_operation_event` | table `core.payment_payment_operation_event` (migration 0028) | +| `psp_submerchant` | table `core.payment_psp_submerchant` (migration 0039) | +| `payment_command` | table `core.payment_payment_command` (migration 0040, réduite à `CANCEL_ORDER`) | +| `payment_operation_link` | cible 17, pas encore créée | +| `payment_instrument` | cible 17, pas encore créée | +| `mit_consent` | cible 17, pas encore créée | +| `tender` | cible 17, pas encore créée | +| `refund_instance` | cible 17, pas encore créée | +| `deposit_hold` | `core.payment_deposit_hold` (0146, US-701 ; 0148, US-702) : décision figée par hold avant le paiement, décision exécutée (capturé, libéré), lue et écrite par les seules fonctions de cmd_hold_owner | +| `chargeback` | cible 17, pas encore créée | +| `debt_balance` | cible 17, pas encore créée | +| `payment_plan` | cible 17, pas encore créée | +| `payment_plan_installment` | cible 17, pas encore créée | +| `credit_lot` | cible 17, pas encore créée | Hors entités de 17 : `core.payment_psp_capability_catalog` (catalogue des capacités, migration 0039 ; `SUPPORTS_PAYOUT_WITHOUT_HOST_TAX_ID` ajoutée par 0087, non bloquante, lue par le KYC de l'hôte : inconnue ⇒ numéro fiscal exigé avant l'activation, ADR-115). Commandes `SECURITY DEFINER` (famille `cmd_money`) : `core.payment_cmd_record_operation`, `payment_cmd_apply_operation_status`, `payment_cmd_receive_webhook` (0028), `payment_cmd_register_submerchant`, `payment_cmd_record_submerchant_status` (0039). Détail : `packages/db/README.md`, sections « Port PaymentProvider » et « Port de place de marché ». @@ -55,9 +55,15 @@ Hors entités de 17 : `core.payment_psp_capability_catalog` (catalogue des capac - `DepositRailExecutor.reauthorize` : `SUCCEEDED` seul ⇒ `REAUTHORIZED` ; `PENDING` / `SUBMITTED` / `UNKNOWN` / `UNKNOWN_OUTCOME` ⇒ `REAUTH_PENDING` (`needsLookup`). - Clés d'idempotence (S-6, 08 E4) : `{trip}:{segment}:v0-DEPOSIT-{caution}:{opération}:{moyen}:i{n}:a{m}` (`depositOperationKey`) ; remboursement du rail (b) = `offSettlementRefundKey` d'origine `DEPOSIT`. +### Décision de la caution à l'heure de décision (US-702 ; ADR-172) + +- **Échéancier recalculé par la base** : `core.payment_cmd_record_deposit_decision` (0148) ignore `provider`, `authAt`, `releaseAt`, `decisionAt`, `reauthDueAt` de la décision envoyée et les recalcule (compte marchand du pays, durées `auth_lead_h`, `release_delay_h`, `deposit_safety_h`, `deposit_reauth_lead_h` lues en base) ; `V` reste l'instantané, borné. Le site lit toujours la libération figée en base. +- `DepositDecisionTimer` / `PgDepositDecisionStore` (`internal/deposit-decision.ts`), dans la tâche `deposit_timer` après les ré-autorisations : file `core.payment_deposit_decision_due` (décision échue ou autorisation expirée ; rien ne la suspend), plan `planDepositDecision`, exécution `DepositRailExecutor.execute` hors transaction, transition finale `core.payment_cmd_deposit_decide` (rang attendu, Σ capturé + libéré = montant) qui écrit `deposit.decision.executed`. Autorisation expirée ⇒ `EXPIRED` sans appel ; issue inconnue ⇒ même clé au passage suivant ; VOID refusé ⇒ laissée expirer, `DEPOSIT_DECISION_FAILED` ; MIT impossible ⇒ libérée quand même, `DEPOSIT_FEES_UNCOLLECTED`. +- `DepositFeeSource` : frais annexes et carte du consentement MIT ; en production `NO_DEPOSIT_FEES` (aucun registre des frais annexes encore : caution libérée en entier, frais ensuite par MIT, PROPOSÉ). + ## Événements -Aucun événement de domaine n'est émis ni consommé par le code de PAY aujourd'hui. Chaque statut reçu est écrit dans `core.payment_payment_operation_event` (pas un événement d'outbox). La commande `CANCEL_ORDER` est écrite dans `core.payment_payment_command` par les commandes du hold (AVL, migration 0040), pas par un événement. +Émis par une fonction de la base appelée par PAY : `deposit.decision.executed` (0148, US-702 ; `deposit_id`, `trip_id`, `status`, `captured_minor`, `released_minor`, `currency`, `decided_at`), consommé par NTF (avis au voyageur). Aucun autre événement de domaine n'est émis ni consommé par le code de PAY aujourd'hui. Chaque statut reçu est écrit dans `core.payment_payment_operation_event` (pas un événement d'outbox). La commande `CANCEL_ORDER` est écrite dans `core.payment_payment_command` par les commandes du hold (AVL, migration 0040), pas par un événement. Cible (17 §2.2, §4.5) : diff --git a/apps/api/src/modules/pay/index.ts b/apps/api/src/modules/pay/index.ts index a3c00b3b..cf76e609 100644 --- a/apps/api/src/modules/pay/index.ts +++ b/apps/api/src/modules/pay/index.ts @@ -207,6 +207,22 @@ export type { DepositTimerStep, DueDepositReauth, } from './internal/deposit-timer.js'; +// décision de la caution à l'heure de décision (US-702, ADR-172) +export { + DEPOSIT_DECISION_BATCH, + DepositDecisionTimer, + NO_DEPOSIT_FEES, + PgDepositDecisionStore, + postgresDepositDecisionDeps, + withoutMit, +} from './internal/deposit-decision.js'; +export type { + DepositDecisionDeps, + DepositDecisionStep, + DepositFeeSource, + DepositOutcome, + DueDepositDecision, +} from './internal/deposit-decision.js'; // Webhooks (17 §4.4) export { diff --git a/apps/api/src/modules/pay/internal/deposit-checkout.test.ts b/apps/api/src/modules/pay/internal/deposit-checkout.test.ts index efc78bbd..681911bc 100644 --- a/apps/api/src/modules/pay/internal/deposit-checkout.test.ts +++ b/apps/api/src/modules/pay/internal/deposit-checkout.test.ts @@ -54,11 +54,23 @@ const H = 3_600_000; const T = Date.parse('2031-07-10T10:00:00.000Z'); const at = (hours: number, minutes = 0): Date => new Date(T + hours * H + minutes * 60_000); -/** 300,00 de T57 (valeur de test du mécanisme) à l'exposant de la devise du pays. */ -const CASES = countryCases().map((c) => ({ - ...c, - deposit: 300n * 10n ** BigInt(CURRENCIES.get(c.currency).exponent), -})); +/** + * Montant de test de `deposit_amount[pays][LUXE]` selon l'exposant de la devise du pays (US-702, + * revues argent et qa d'US-701) : les oracles expriment T57 en centimes (exposant 2 : 300,00 = + * capture + VOID de T57, 30 000) et T73 a sans décimale (exposant 0 : 1 500 000, `AMT_PY`) ; jamais + * 300 mis à l'échelle. Aucun code de pays ni de devise écrit ici. + */ +const T57 = check('T57', /^T57$/) as Record; +const T73 = check('T73', /^T73 a\/b$/) as unknown[]; +const DEPOSIT_BY_EXPONENT = new Map([ + [2, (T57['capture'] ?? 0n) + (T57['void'] ?? 0n)], + [0, T73[1] as bigint], +]); +const CASES = countryCases().map((c) => { + const deposit = DEPOSIT_BY_EXPONENT.get(CURRENCIES.get(c.currency).exponent); + if (deposit === undefined) throw new Error(`devise sans vecteur de caution : ${c.currency}`); + return { ...c, deposit }; +}); const rec = (capability: string, value: unknown): CapabilityRecord => ({ capability, diff --git a/apps/api/src/modules/pay/internal/deposit-decision.ts b/apps/api/src/modules/pay/internal/deposit-decision.ts new file mode 100644 index 00000000..8357b8e1 --- /dev/null +++ b/apps/api/src/modules/pay/internal/deposit-decision.ts @@ -0,0 +1,324 @@ +/** + * Décision de la caution à l'heure de décision (US-702, ADR-172 ; 08 BR-PAY-06 « Libération à + * heure fixe, jamais suspendue », T57, T58 ; 16 PAY-011 / PAY-012 ; 19 US-702). + * + * Exécutée par la tâche périodique `deposit_timer` (après les ré-autorisations), sous le nom de + * travailleur `payment_command` exigé par la base. La file `core.payment_deposit_decision_due` rend + * les cautions AUTORISÉES dont la décision est échue (`decision_at ≤ platform.now()`) ou dont + * l'autorisation a expiré ; rien d'autre n'y entre : une réclamation de dommage, une facture ou des + * frais d'assistance ne suspendent jamais la libération. Pour chacune : + * 1. autorisation déjà expirée ⇒ `EXPIRED` sans appel au PSP (jamais de capture après + * `auth_expiry`) ; + * 2. sinon : configuration relue (capacités, `deposit_fee_notice_h`), frais annexes de la source + * (`DepositFeeSource` ; en production AUCUNE source n'existe encore : aucun frais ⇒ la caution + * est libérée en entier, les frais éventuels passent ensuite par MIT `DELAYED_CHARGES`, comme + * chez Turo), plan pur `planDepositDecision` (T57 : capture puis VOID ; T58 : VOID puis MIT), + * exécution par le port HORS transaction, clés de 08 E4 (même clé au rejeu) ; + * 3. issue reportée par `core.payment_cmd_deposit_decide` (transition finale gardée et événement + * `deposit.decision.executed` dans la même transaction : journal et avis au voyageur). + * Issue inconnue ou en cours ⇒ rien n'est écrit, la MÊME clé est rejouée au passage suivant + * (17 §4.3). VOID refusé définitivement ⇒ l'autorisation est laissée expirer (08 E3 repli 4), + * alerte ops `DEPOSIT_DECISION_FAILED`. Débit MIT refusé ou impossible ⇒ la caution reste libérée, + * alerte `DEPOSIT_FEES_UNCOLLECTED` (frais à recouvrer, BR-PAY-10). Autre échec ⇒ alerte, rien + * d'écrit, nouvel essai au passage suivant. + * Aucun connecteur pour le fournisseur (production jusqu'au lot C) ⇒ rien n'est envoyé. + * Journal : comptes et codes seulement, jamais un identifiant (17 §6.3). + */ +import type { AlertChannel, WorkerTransactions } from '../../bus/index.js'; +import { createCurrencyRegistry, money } from '@rueda/money'; +import { planDepositDecision } from './deposit-rails.js'; +import type { + DepositDecisionPlan, + DepositHoldStatus, + DepositIncidentalFee, + DepositRail, + DepositStep, +} from './deposit-rails.js'; +import { DepositRailExecutor } from './deposit-executor.js'; +import type { DepositExecution, DepositReference } from './deposit-executor.js'; +import { PgDepositRailConfigReader } from './pg-deposit-config.js'; +import type { DepositRailConfig } from './pg-deposit-config.js'; +import type { PaymentConnectorRegistry } from './production.js'; +import type { SqlExecutor } from './pg-stores.js'; + +/** Nom de travailleur exigé par la base pour la file et la transition. */ +const PAYMENT_COMMAND_WORKER = 'payment_command'; +export const DEPOSIT_DECISION_BATCH = 50; + +const RAILS: readonly DepositRail[] = ['PREAUTH_SINGLE', 'REAUTH', 'CHARGE_THEN_REFUND']; + +/** Caution dont la décision est échue (aucune donnée [C2]). */ +export interface DueDepositDecision { + readonly depositId: string; + readonly tripId: string; + readonly segmentId: string; + readonly tenderId: string; + readonly country: string; + readonly currency: string; + readonly currencyExponent: number; + readonly provider: string; + readonly providerReference: string; + readonly mechanism: DepositRail; + readonly amountMinor: bigint; + readonly decisionAt: Date; + /** `null` : rail « débit puis remboursement » (aucune autorisation à expirer). */ + readonly authExpiryAt: Date | null; + readonly reauthSeq: number; + /** `platform.now()` à la lecture de la file. */ + readonly now: Date; +} + +/** Issue finale reportée à la base (Σ capturé + libéré = montant de la caution). */ +export interface DepositOutcome { + readonly status: Exclude; + readonly capturedMinor: bigint; + readonly releasedMinor: bigint; +} + +/** + * Frais annexes à décider sur la caution et carte du consentement MIT. Source de production : + * `NO_DEPOSIT_FEES` (aucun registre des frais annexes ni carte enregistrée avant les stories qui les + * livrent : rien n'est capturé sur la caution, PROPOSÉ, fail-closed). + */ +export type DepositFeeSource = (due: DueDepositDecision) => Promise<{ + readonly fees: readonly DepositIncidentalFee[]; + /** Jeton de la carte enregistrée (consentement MIT) ; `null` : aucun débit MIT possible. */ + readonly instrumentToken: string | null; +}>; + +export const NO_DEPOSIT_FEES: DepositFeeSource = () => + Promise.resolve({ fees: [], instrumentToken: null }); + +export type DepositDecisionStep = + | 'NO_CONNECTOR' + | 'PARTIALLY_CAPTURED' + | 'VOIDED' + | 'REFUNDED' + | 'EXPIRED' + | 'PENDING' + | 'FAILED' + | 'STALE' + | 'ERROR'; + +const instant = (v: unknown): Date => { + const d = v instanceof Date ? v : new Date(String(v)); + if (Number.isNaN(d.getTime())) throw new TypeError('instant illisible'); + return d; +}; +const str = (v: unknown): string => { + if (typeof v !== 'string' || v === '') throw new TypeError('colonne inattendue'); + return v; +}; +const minor = (v: unknown): bigint => { + const s = typeof v === 'bigint' ? v.toString() : String(v); + if (!/^(0|[1-9][0-9]{0,18})$/.test(s)) throw new TypeError('montant illisible'); + return BigInt(s); +}; +const rail = (v: unknown): DepositRail => { + if (!(RAILS as readonly unknown[]).includes(v)) throw new TypeError('mécanisme inattendu'); + return v as DepositRail; +}; + +/** File et transition finale de la base (fonctions SECURITY DEFINER, `payment_command`). */ +export class PgDepositDecisionStore { + constructor(private readonly db: SqlExecutor) {} + + async due(limit: number): Promise { + const { rows } = await this.db.query( + `SELECT d.*, c.exponent AS currency_exponent + FROM core.payment_deposit_decision_due($1::integer) AS d + JOIN core.config_currency AS c ON c.code = d.currency`, + [limit], + ); + return rows.map((r) => ({ + depositId: str(r['deposit_id']), + tripId: str(r['trip_id']), + segmentId: str(r['segment_id']), + tenderId: str(r['tender_id']), + country: str(r['country_code']), + currency: str(r['currency']), + currencyExponent: Number(r['currency_exponent']), + provider: str(r['provider']), + providerReference: str(r['provider_reference']), + mechanism: rail(r['mechanism']), + amountMinor: minor(r['amount_minor']), + decisionAt: instant(r['decision_at']), + authExpiryAt: r['auth_expiry_at'] === null ? null : instant(r['auth_expiry_at']), + reauthSeq: Number(r['reauth_seq']), + now: instant(r['now']), + })); + } + + /** `APPLIED` ; `STALE` : la caution a changé entre-temps (rang ou état), rien n'est écrit. */ + async decide( + depositId: string, + expectedSeq: number, + outcome: DepositOutcome, + ): Promise<'APPLIED' | 'STALE'> { + const { rows } = await this.db.query<{ r: unknown }>( + `SELECT core.payment_cmd_deposit_decide($1::uuid, $2::integer, $3, $4::bigint, $5::bigint) + AS r`, + [ + depositId, + expectedSeq, + outcome.status, + outcome.capturedMinor.toString(), + outcome.releasedMinor.toString(), + ], + ); + const r = String(rows[0]?.r ?? ''); + if (r !== 'APPLIED' && r !== 'STALE') throw new TypeError('issue inattendue de la décision'); + return r; + } +} + +export interface DepositDecisionDeps { + /** Configuration du pays et du fournisseur (`PgDepositRailConfigReader`, transaction propre). */ + readonly config: (country: string, provider: string) => Promise; + /** Transition finale (`PgDepositDecisionStore.decide`, transaction propre). */ + readonly decide: PgDepositDecisionStore['decide']; + readonly fees: DepositFeeSource; + readonly alerts: Pick; + readonly connectors: PaymentConnectorRegistry; +} + +/** Dépendances de production : chaque lecture et chaque écriture dans sa transaction. */ +export function postgresDepositDecisionDeps( + transactions: WorkerTransactions, + alerts: Pick, + connectors: PaymentConnectorRegistry, + fees: DepositFeeSource = NO_DEPOSIT_FEES, +): DepositDecisionDeps { + return { + config: (country, provider) => + transactions.run(PAYMENT_COMMAND_WORKER, (db) => + new PgDepositRailConfigReader(db).read(country, provider), + ), + decide: (depositId, expectedSeq, outcome) => + transactions.run(PAYMENT_COMMAND_WORKER, (db) => + new PgDepositDecisionStore(db).decide(depositId, expectedSeq, outcome), + ), + fees, + alerts, + connectors, + }; +} + +/** Sans carte enregistrée, un débit MIT est impossible : les frais deviennent une dette (BR-PAY-10). */ +export function withoutMit(plan: DepositDecisionPlan): DepositDecisionPlan { + return { + ...plan, + steps: plan.steps.map((s): DepositStep => + s.op === 'MIT_CHARGE' ? { op: 'DEBT', amountMinor: s.amountMinor, parts: s.parts } : s, + ), + }; +} + +const capturedOf = (exec: DepositExecution): bigint => + exec.completed.reduce((sum, r) => (r.step.op === 'CAPTURE' ? sum + r.step.amountMinor : sum), 0n); + +export class DepositDecisionTimer { + constructor(private readonly deps: DepositDecisionDeps) {} + + /** Une caution ; ne lève jamais (une caution ne bloque pas les suivantes). */ + async process(due: DueDepositDecision): Promise { + try { + if (due.authExpiryAt !== null && due.authExpiryAt.getTime() <= due.now.getTime()) { + // l'autorisation est tombée seule : jamais de capture après `auth_expiry` (08 BR-PAY-06) + return await this.#report(due, { + status: 'EXPIRED', + capturedMinor: 0n, + releasedMinor: due.amountMinor, + }); + } + const provider = this.deps.connectors.get(due.provider); + if (provider === undefined) return 'NO_CONNECTOR'; + const config = await this.deps.config(due.country, due.provider); + const { fees, instrumentToken } = await this.deps.fees(due); + const currency = createCurrencyRegistry([ + { code: due.currency, exponent: due.currencyExponent }, + ]).get(due.currency); + // délai de notification absent : aucun frais n'est capturable sur la caution (fail-closed) + const noticeH = config.feeNoticeH; + const planned = planDepositDecision({ + mechanism: due.mechanism, + amount: money(due.amountMinor, currency), + decisionAt: due.decisionAt, + feeNoticeH: noticeH ?? 0, + fees: noticeH === null ? fees.map((f) => ({ ...f, proven: false })) : fees, + caps: { capabilities: config.capabilities }, + }); + const plan = instrumentToken === null ? withoutMit(planned) : planned; + const ref: DepositReference = { + depositId: due.depositId, + tripReference: due.tripId, + tripId: due.tripId, + segmentId: due.segmentId, + tenderId: due.tenderId, + currency, + }; + const exec = await new DepositRailExecutor(provider).execute(ref, plan, { + providerReference: due.providerReference, + instrumentToken: instrumentToken ?? '', + attemptNo: 1, + }); + const final = exec.fallback ?? plan; + if (exec.failed === null) { + const step = await this.#report(due, { + status: final.finalStatus as DepositOutcome['status'], + capturedMinor: final.capturedMinor, + releasedMinor: final.releasedMinor, + }); + if (step !== 'STALE' && final.steps.some((s) => s.op === 'DEBT')) { + await this.#alert('DEPOSIT_FEES_UNCOLLECTED', 'P2', due); + } + return step; + } + if (exec.failed.needsLookup) return 'PENDING'; + const failedOp = exec.failed.step.op; + if (failedOp === 'MIT_CHARGE') { + // la caution est déjà libérée (VOID ou capture faits) : seuls les frais restent dus + const step = await this.#report(due, { + status: final.finalStatus as DepositOutcome['status'], + capturedMinor: final.capturedMinor, + releasedMinor: final.releasedMinor, + }); + if (step !== 'STALE') await this.#alert('DEPOSIT_FEES_UNCOLLECTED', 'P2', due); + return step; + } + if (failedOp === 'VOID') { + // 08 E3 repli 4 : annulation refusée ⇒ l'autorisation est laissée expirer + const captured = capturedOf(exec); + const step = await this.#report(due, { + status: captured > 0n ? 'PARTIALLY_CAPTURED' : 'EXPIRED', + capturedMinor: captured, + releasedMinor: due.amountMinor - captured, + }); + if (step !== 'STALE') await this.#alert('DEPOSIT_DECISION_FAILED', 'P1', due); + return step; + } + await this.#alert('DEPOSIT_DECISION_FAILED', 'P1', due); + return 'FAILED'; + } catch { + return 'ERROR'; + } + } + + async #report(due: DueDepositDecision, outcome: DepositOutcome): Promise { + const applied = await this.deps.decide(due.depositId, due.reauthSeq, outcome); + return applied === 'STALE' ? 'STALE' : outcome.status; + } + + async #alert( + code: 'DEPOSIT_DECISION_FAILED' | 'DEPOSIT_FEES_UNCOLLECTED', + severity: 'P1' | 'P2', + due: DueDepositDecision, + ): Promise { + await this.deps.alerts.send({ + code, + severity, + counts: { deposits: 1 }, + labels: { country: due.country, provider: due.provider }, + }); + } +} diff --git a/apps/api/src/modules/pay/internal/deposit-timer.ts b/apps/api/src/modules/pay/internal/deposit-timer.ts index 14bd6fc8..70a8a87b 100644 --- a/apps/api/src/modules/pay/internal/deposit-timer.ts +++ b/apps/api/src/modules/pay/internal/deposit-timer.ts @@ -17,6 +17,7 @@ * aucun changement, la MÊME clé est rejouée au passage suivant (lecture de l'état d'abord, 17 * §4.3). * Aucun connecteur pour le fournisseur (production jusqu'au lot C) ⇒ rien n'est envoyé. + * La même tâche exécute ensuite les décisions échues (`DepositDecisionTimer`, US-702, ADR-172). * Journal : comptes et codes seulement, jamais un identifiant (17 §6.3). */ import type { AlertChannel, BusRegistry, SqlClient, WorkerTransactions } from '../../bus/index.js'; @@ -27,6 +28,13 @@ import { depositScheduleAfterReauth, } from './deposit-rails.js'; import { DepositRailExecutor } from './deposit-executor.js'; +import { + DEPOSIT_DECISION_BATCH, + DepositDecisionTimer, + PgDepositDecisionStore, + postgresDepositDecisionDeps, +} from './deposit-decision.js'; +import type { DepositFeeSource } from './deposit-decision.js'; import { PgDepositRailConfigReader } from './pg-deposit-config.js'; import type { DepositRailConfig } from './pg-deposit-config.js'; import type { PaymentConnectorRegistry } from './production.js'; @@ -35,7 +43,11 @@ import type { SqlExecutor } from './pg-stores.js'; export const DEPOSIT_TIMER_WORKER = 'deposit_timer'; /** Nom de travailleur exigé par la base pour la file et la transition. */ const PAYMENT_COMMAND_WORKER = 'payment_command'; -/** Période (PROPOSÉ) : la ré-autorisation est planifiée 24 h avant l'expiration. */ +/** + * Période de la tâche (PROPOSÉ, 60 s) : l'échéance la plus serrée est la marge `deposit_safety_h` + * (2 h) entre la décision et l'expiration ; l'avance de la ré-autorisation est un paramètre à part + * (`deposit_reauth_lead_h`, 24 h), lu en base. + */ export const DEPOSIT_TIMER_PERIOD_SECONDS = 60; export const DEPOSIT_TIMER_BATCH = 50; @@ -209,15 +221,23 @@ export class DepositReauthTimer { } } -/** Tâche périodique `deposit_timer` (comptes seulement dans le journal). */ +/** + * Tâche périodique `deposit_timer` (comptes seulement dans le journal) : ré-autorisations échues, + * puis décisions échues (US-702). `fees` : source des frais annexes ; en production aucune n'existe + * encore (`NO_DEPOSIT_FEES` : la caution est libérée en entier, PROPOSÉ, ADR-172). + */ export function registerDepositTimers( registry: BusRegistry, transactions: WorkerTransactions, alerts: AlertChannel, log: (line: string) => void, connectors: PaymentConnectorRegistry, + fees?: DepositFeeSource, ): void { const timer = new DepositReauthTimer(postgresDepositTimerDeps(transactions, alerts, connectors)); + const decisions = new DepositDecisionTimer( + postgresDepositDecisionDeps(transactions, alerts, connectors, fees), + ); registry.registerPeriodic( DEPOSIT_TIMER_WORKER, DEPOSIT_TIMER_PERIOD_SECONDS, @@ -231,8 +251,21 @@ export function registerDepositTimers( const step = (await timer.process(d)).toLowerCase(); counts[step] = (counts[step] ?? 0) + 1; } + const decide = await new PgDepositDecisionStore(tx).due(DEPOSIT_DECISION_BATCH); + const decided: Record = {}; + for (const d of decide) { + const step = (await decisions.process(d)).toLowerCase(); + decided[`decision_${step}`] = (decided[`decision_${step}`] ?? 0) + 1; + } log( - JSON.stringify({ level: 'info', worker: DEPOSIT_TIMER_WORKER, due: due.length, ...counts }), + JSON.stringify({ + level: 'info', + worker: DEPOSIT_TIMER_WORKER, + due: due.length, + ...counts, + decisions_due: decide.length, + ...decided, + }), ); }, ); diff --git a/apps/api/src/modules/pay/testing/deposit-decision.fake.test.ts b/apps/api/src/modules/pay/testing/deposit-decision.fake.test.ts new file mode 100644 index 00000000..d3089b0d --- /dev/null +++ b/apps/api/src/modules/pay/testing/deposit-decision.fake.test.ts @@ -0,0 +1,330 @@ +/** + * US-702 (ADR-172) — décision de la caution à l'heure de décision sur le PSP simulé (FAKE seulement, + * C19), en USD (PA) et en PYG sans décimale (PY). Attendus : 19 US-702 (critère 1 : T58 « VOID + * 300,00 puis MIT 12,00 » ; critère 2 : sans frais annexes, VOID automatique de la caution entière, + * journalisé et notifié, jamais suspendu par une réclamation), oracle `check_t49plus.py` (T57, T58 ; + * `@rueda/money/golden-vectors`) et T73 (montant de test PYG `deposit_amount[PY][LUXE]` 1 500 000), + * 08 BR-PAY-06 (jamais de capture après l'expiration), 08 E3 repli 4, 08 E4 (clés), 17 §4.3 (issue + * inconnue ⇒ même clé). Heures refaites à la main ; jamais le code testé. + */ +import { readFileSync } from 'node:fs'; +import { createCurrencyRegistry, money, ratio } from '@rueda/money'; +import { checksFor, loadGoldenVectors } from '@rueda/money/golden-vectors'; +import type { GoldenValue } from '@rueda/money/golden-vectors'; +import { describe, expect, it } from 'vitest'; +import type { OpsAlert } from '../../bus/index.js'; +import { CapabilitySet } from '../internal/capabilities.js'; +import { DepositDecisionTimer, NO_DEPOSIT_FEES } from '../internal/deposit-decision.js'; +import type { + DepositFeeSource, + DepositOutcome, + DueDepositDecision, +} from '../internal/deposit-decision.js'; +import { DepositRailExecutor } from '../internal/deposit-executor.js'; +import { depositOperationKey } from '../internal/idempotency.js'; +import type { DepositRailConfig } from '../internal/pg-deposit-config.js'; +import { countryCases } from '../../../../test/support/countries.js'; +import { fakeStack } from './fake-stack.js'; +import type { FakeStackOptions } from './fake-stack.js'; + +const set = loadGoldenVectors(); +const check = (vectorId: string, label: RegExp): GoldenValue => { + const found = checksFor(set, vectorId).find((c) => label.test(c.label)); + if (found === undefined) throw new Error(`contrôle ${vectorId} ${label} absent`); + return found.expected; +}; +const T57 = check('T57', /^T57$/) as Record; +const T58 = check('T58', /^T58$/) as Record; +/** T73 a/b : (déclencheurs a, montant a = LUXE, déclencheurs b, montant b = STANDARD). */ +const T73 = check('T73', /^T73 a\/b$/) as unknown[]; + +const CURRENCIES = createCurrencyRegistry( + ( + JSON.parse( + readFileSync(new URL('../../cfg/data/currencies.json', import.meta.url), 'utf8'), + ) as { currencies: { code: string; exponent: number }[] } + ).currencies, +); +const PARAMS = ( + JSON.parse(readFileSync(new URL('../../cfg/data/params.json', import.meta.url), 'utf8')) as { + params: { key: string; values: Record }[]; + } +).params; +const p = (key: string, country: string): unknown => + PARAMS.find((x) => x.key === key)?.values[country]; + +/** + * Montant de test de la caution selon l'exposant de la devise du pays : les oracles expriment T57 / + * T58 en centimes (exposant 2 : 300,00 = 30 000, carburant 12,00 = 1 200) et T73 a sans décimale + * (exposant 0 : `deposit_amount[PY][LUXE]` = 1 500 000). Les frais de T57 / T58 n'existent qu'en + * centimes : les cas de frais tournent sur les pays dont la devise a l'exposant du vecteur. Aucun + * code de pays ni de devise écrit ici. + */ +const DEPOSIT_BY_EXPONENT = new Map([ + [2, (T57['capture'] ?? 0n) + (T57['void'] ?? 0n)], + [0, T73[1] as bigint], +]); +const CASES = countryCases().map((c) => { + const cur = CURRENCIES.get(c.currency); + const deposit = DEPOSIT_BY_EXPONENT.get(cur.exponent); + if (deposit === undefined) throw new Error(`devise sans vecteur de caution : ${c.currency}`); + return { ...c, cur, deposit }; +}); +const T58_CASES = CASES.filter((c) => c.cur.exponent === 2); + +const H = 3_600_000; +/** T57 : fin du trip ; décision à fin + 70 h, expiration renvoyée à fin + 72 h (V = 168 h). */ +const END = Date.parse('2031-07-13T10:00:00.000Z'); +const at = (hours: number): Date => new Date(END + hours * H); + +const IDS = { + deposit: '0191d1a0-0000-7000-8000-000000000702', + trip: '0191d1a0-0000-7000-8000-0000000007a2', + segment: '0191d1a0-0000-7000-8000-0000000007b2', + tender: '0191d1a0-0000-7000-8000-0000000007c2', +}; + +function configOf( + c: (typeof CASES)[number], + caps: readonly { capability: string; method: string; value: unknown; status: string }[], +): DepositRailConfig { + return { + triggerParams: {}, + amounts: undefined, + railParams: { + authLeadH: p('auth_lead_h', c.country) as number, + releaseDelayH: p('release_delay_h', c.country) as number, + marginH: p('marge_h', c.country) as number, + safetyH: p('deposit_safety_h', c.country) as number, + reauthLeadH: p('deposit_reauth_lead_h', c.country) as number, + providerMaxHoldH: 168, + chargeCapMinor: 0n, + fundsHoldingEnabled: false, + }, + feeNoticeH: p('deposit_fee_notice_h', c.country) as number, + capabilities: new CapabilitySet( + caps.map((x) => ({ ...x, status: x.status as 'VALIDATED_SANDBOX' })), + ), + }; +} + +/** Carburant de T57 / T58 : 12,00 à 100 % pour l'hôte, prouvé, notifié à fin + 1 h, non contesté. */ +const fuelSource = + (c: (typeof CASES)[number], token: string | null): DepositFeeSource => + () => + Promise.resolve({ + fees: [ + { + id: 'fuel', + amount: money(T58['mit'] ?? 0n, c.cur), + hostShare: ratio(1n, 1n), + proven: true, + notifiedAt: at(1), + disputed: false, + }, + ], + instrumentToken: token, + }); + +/** Sans capture partielle pour la carte (moyen de la caution) : le cas de T58. */ +const NO_PARTIAL_CAPTURE = [ + { capability: 'SUPPORTS_PARTIAL_CAPTURE', method: '*', value: true, status: 'VALIDATED_SANDBOX' }, + { + capability: 'SUPPORTS_PARTIAL_CAPTURE', + method: 'CARD', + value: false, + status: 'VALIDATED_SANDBOX', + }, +] as const; + +async function setup( + c: (typeof CASES)[number], + options: FakeStackOptions & { + fees?: DepositFeeSource; + applied?: 'APPLIED' | 'STALE'; + noConnector?: boolean; + } = {}, +) { + const stack = fakeStack(options); + // pose de la caution (lot C : à `auth_at`) : pré-autorisation MANUAL acceptée par le voyageur + const order = await new DepositRailExecutor(stack.provider).place( + { + depositId: IDS.deposit, + tripReference: IDS.trip, + tripId: IDS.trip, + segmentId: IDS.segment, + tenderId: IDS.tender, + currency: c.cur, + }, + { + mechanism: 'PREAUTH_SINGLE', + amountMinor: c.deposit, + fundsHoldingEnabled: false, + attemptNo: 1, + }, + ); + stack.psp.customerPays(order.providerReference); + const decided: [string, number, DepositOutcome][] = []; + const alerts: OpsAlert[] = []; + const timer = new DepositDecisionTimer({ + config: () => Promise.resolve(configOf(c, stack.capabilities)), + decide: (id, seq, outcome) => { + decided.push([id, seq, outcome]); + return Promise.resolve(options.applied ?? 'APPLIED'); + }, + fees: options.fees ?? NO_DEPOSIT_FEES, + alerts: { + send: (a) => { + alerts.push(a); + return Promise.resolve(); + }, + }, + connectors: { + get: (name) => (options.noConnector || name !== 'FAKE' ? undefined : stack.provider), + }, + }); + const due = (over: Partial = {}): DueDepositDecision => ({ + depositId: IDS.deposit, + tripId: IDS.trip, + segmentId: IDS.segment, + tenderId: IDS.tender, + country: c.country, + currency: c.currency, + currencyExponent: c.cur.exponent, + provider: 'FAKE', + providerReference: order.providerReference, + mechanism: 'PREAUTH_SINGLE', + amountMinor: c.deposit, + decisionAt: at(70), + authExpiryAt: at(72), + reauthSeq: 0, + now: at(70), + ...over, + }); + return { stack, timer, decided, alerts, due }; +} + +const voidKey = (n: number) => + depositOperationKey({ + tripId: IDS.trip, + segmentId: IDS.segment, + depositId: IDS.deposit, + operationType: 'DEPOSIT_VOID', + tenderId: IDS.tender, + instanceSeq: n, + attemptNo: 1, + }); + +describe.each(T58_CASES)('US-702 — T57 / T58 à fin + 70 h ($country, $currency)', (c) => { + it('critère 1 (T58) : PSP sans capture partielle ⇒ VOID de la caution entière PUIS débit MIT du carburant (jambe HOST), VOIDED reporté', async () => { + const s = await setup(c, { + override: [...NO_PARTIAL_CAPTURE], + fees: fuelSource(c, 'tok_card'), + }); + expect(await s.timer.process(s.due())).toBe('VOIDED'); + expect(s.stack.psp.calls('VOID')).toBe(1); + expect(s.stack.psp.calls('CAPTURE')).toBe(0); + expect(s.stack.psp.movements().map((m) => [m.operation, m.amountMinor, m.legs?.HOST])).toEqual([ + ['MIT_CHARGE', T58['mit'], T58['mit']], + ]); + expect(s.decided).toEqual([ + [ + IDS.deposit, + 0, + { status: 'VOIDED', capturedMinor: T58['capture'], releasedMinor: T58['void'] }, + ], + ]); + expect(s.alerts).toEqual([]); + }); + + it('T57 : capture partielle validée ⇒ capture 12,00 (jambe HOST) puis VOID 288,00, PARTIALLY_CAPTURED reporté', async () => { + const s = await setup(c, { fees: fuelSource(c, 'tok_card') }); + expect(await s.timer.process(s.due())).toBe('PARTIALLY_CAPTURED'); + expect(s.stack.psp.movements().map((m) => [m.operation, m.amountMinor, m.legs?.HOST])).toEqual([ + ['CAPTURE', T57['capture'], T57['capture']], + ]); + expect(s.stack.psp.calls('VOID')).toBe(1); + expect(s.decided[0]?.[2]).toEqual({ + status: 'PARTIALLY_CAPTURED', + capturedMinor: T57['capture'], + releasedMinor: T57['void'], + }); + }); + + it('sans carte enregistrée (aucun consentement MIT) : la caution est libérée quand même, frais en dette, alerte DEPOSIT_FEES_UNCOLLECTED', async () => { + const s = await setup(c, { override: [...NO_PARTIAL_CAPTURE], fees: fuelSource(c, null) }); + expect(await s.timer.process(s.due())).toBe('VOIDED'); + expect(s.stack.psp.calls('MIT_CHARGE')).toBe(0); + expect(s.decided[0]?.[2]).toEqual({ + status: 'VOIDED', + capturedMinor: 0n, + releasedMinor: c.deposit, + }); + expect(s.alerts.map((a) => [a.code, a.severity])).toEqual([['DEPOSIT_FEES_UNCOLLECTED', 'P2']]); + }); +}); + +describe.each(CASES)('US-702 — libération automatique ($country, $currency)', (c) => { + it('critère 2 : aucun frais annexe (source de production) ⇒ VOID automatique de la caution entière, clé 08 E4, aucune capture ni MIT, VOIDED reporté', async () => { + const s = await setup(c); + expect(await s.timer.process(s.due())).toBe('VOIDED'); + expect(s.stack.psp.calls('VOID')).toBe(1); + expect(s.stack.psp.calls('CAPTURE')).toBe(0); + expect(s.stack.psp.calls('MIT_CHARGE')).toBe(0); + expect(s.stack.psp.movements()).toEqual([]); + expect(s.decided).toEqual([ + [IDS.deposit, 0, { status: 'VOIDED', capturedMinor: 0n, releasedMinor: c.deposit }], + ]); + expect(voidKey(1)).toBe( + `${IDS.trip}:${IDS.segment}:v0-DEPOSIT-${IDS.deposit}:DEPOSIT_VOID:${IDS.tender}:i1:a1`, + ); + }); + + it('autorisation expirée à la lecture ⇒ EXPIRED sans aucun appel au PSP (jamais de capture après auth_expiry)', async () => { + const s = await setup(c); + expect(await s.timer.process(s.due({ now: at(72) }))).toBe('EXPIRED'); + expect(s.stack.psp.calls('VOID')).toBe(0); + expect(s.stack.psp.calls('CAPTURE')).toBe(0); + expect(s.decided[0]?.[2]).toEqual({ + status: 'EXPIRED', + capturedMinor: 0n, + releasedMinor: c.deposit, + }); + }); + + it('17 §4.3 : VOID d’issue inconnue ⇒ rien n’est écrit ; au passage suivant la MÊME clé aboutit sans second appel effectif', async () => { + const s = await setup(c, { + scenario: { responses: { VOID: [{ kind: 'TIMEOUT_AFTER_SUCCESS' }] } }, + }); + expect(await s.timer.process(s.due())).toBe('PENDING'); + expect(s.decided).toEqual([]); + expect(await s.timer.process(s.due())).toBe('VOIDED'); + expect(s.decided).toHaveLength(1); + expect(s.stack.psp.movements()).toEqual([]); + }); + + it('08 E3 repli 4 : VOID refusé ⇒ autorisation laissée expirer (EXPIRED reporté), alerte DEPOSIT_DECISION_FAILED (P1)', async () => { + const s = await setup(c, { + scenario: { responses: { VOID: [{ kind: 'DECLINE', code: 'void_refused' }] } }, + }); + expect(await s.timer.process(s.due())).toBe('EXPIRED'); + expect(s.decided[0]?.[2]).toEqual({ + status: 'EXPIRED', + capturedMinor: 0n, + releasedMinor: c.deposit, + }); + expect(s.alerts.map((a) => [a.code, a.severity, a.labels])).toEqual([ + ['DEPOSIT_DECISION_FAILED', 'P1', { country: c.country, provider: 'FAKE' }], + ]); + }); + + it('aucun connecteur (production avant le lot C) ⇒ rien n’est envoyé ni écrit ; décision concurrente ⇒ STALE sans alerte', async () => { + const none = await setup(c, { noConnector: true }); + expect(await none.timer.process(none.due())).toBe('NO_CONNECTOR'); + expect(none.stack.psp.calls('VOID')).toBe(0); + expect(none.decided).toEqual([]); + const stale = await setup(c, { applied: 'STALE' }); + expect(await stale.timer.process(stale.due())).toBe('STALE'); + expect(stale.alerts).toEqual([]); + }); +}); diff --git a/apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts b/apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts new file mode 100644 index 00000000..a6364b83 --- /dev/null +++ b/apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts @@ -0,0 +1,189 @@ +/** + * US-702 (suite des revues code et qa d'US-701) — magasins de la minuterie de la caution exécutés + * sur PostgreSQL réel avec leurs fonctions SQL (paire TS / SQL ensemble), sous le rôle de production + * `app_worker` (`withRole` : assertion L0-05 en tête), nom de travailleur `payment_command`, dans + * chaque pays configuré (USD, PYG sans décimale), transactions ANNULÉES : + * - `PgDepositTimerStore` (0146) : jointure `config_currency` (exposant de la devise), paramètres + * `::timestamptz`, file des ré-autorisations échues et transition `REAUTHORIZED` (rang attendu) ; + * - `PgDepositDecisionStore` (0148) : file des décisions échues (montant en `bigint`, rail, + * expiration) et transition finale ; `DepositDecisionTimer` de bout en bout avec la configuration + * lue en base (capacités du FAKE inconnues en base ⇒ aucune annulation possible : l'autorisation + * est laissée expirer, aucun appel au PSP, 08 E3 repli 4). + * Attendus : 08 BR-PAY-06 (T57 : décision à fin + 70 h ; T59 en rail a), T73 (1 500 000 PYG), + * `currencies.json` (lu comme donnée) — jamais le code testé. + */ +import { readFileSync } from 'node:fs'; +import { randomUUID } from 'node:crypto'; +import { withRole, withTestTransaction } from '@rueda/db/testing'; +import type {} from '@rueda/db/testing/global-setup'; +import type pg from 'pg'; +import { describe, expect, it } from 'vitest'; +import { + DepositDecisionTimer, + NO_DEPOSIT_FEES, + PgDepositDecisionStore, +} from '../internal/deposit-decision.js'; +import { PgDepositTimerStore } from '../internal/deposit-timer.js'; +import { PgDepositRailConfigReader } from '../internal/pg-deposit-config.js'; +import { countryCases } from '../../../../test/support/countries.js'; +import { fakeStack } from './fake-stack.js'; + +const H = 3_600_000; +const read = (file: string): unknown => + JSON.parse(readFileSync(new URL(`../../cfg/data/${file}`, import.meta.url), 'utf8')); +const EXPONENTS = new Map( + (read('currencies.json') as { currencies: { code: string; exponent: number }[] }).currencies.map( + (c) => [c.code, c.exponent], + ), +); +const TIME_ZONES = new Map( + (read('countries.json') as { countries: { code: string; timeZone: string }[] }).countries.map( + (c) => [c.code, c.timeZone], + ), +); +/** 300,00 de T57 en centimes (exposant 2 : 30 000) ; 1 500 000 de T73 a sans décimale (exposant 0). */ +const DEPOSIT_BY_EXPONENT = new Map([ + [2, 30_000n], + [0, 1_500_000n], +]); + +const at = (iso: string, hours: number, minutes = 0): string => + new Date(Date.parse(iso) + hours * H + minutes * 60_000).toISOString(); + +async function workerTx(virtualNow: string, fn: (tx: pg.ClientBase) => Promise): Promise { + return withRole('app_worker', (client) => + withTestTransaction(client, { virtualNow }, async (tx) => { + await tx.query( + `SELECT pg_catalog.set_config('app.actor_kind', 'WORKER', true), + pg_catalog.set_config('app.worker_name', 'payment_command', true)`, + ); + return fn(tx); + }), + ); +} +const setClock = (tx: pg.ClientBase, iso: string) => + tx.query(`SELECT pg_catalog.set_config('app.virtual_now', $1, true)`, [iso]); + +describe.each(countryCases())( + '$country ($currency) — magasins de la minuterie sur base réelle', + (c) => { + const exponent = EXPONENTS.get(c.currency); + const amount = exponent === undefined ? undefined : DEPOSIT_BY_EXPONENT.get(exponent); + if (amount === undefined) throw new Error(`devise sans vecteur : ${c.currency}`); + const timezone = TIME_ZONES.get(c.country); + + it('PgDepositTimerStore : ré-autorisation échue lue (exposant de config_currency, instants), transition REAUTHORIZED appliquée puis STALE', async () => { + // T59 en rail (a) : autorisée à début − 24 h (expiration début + 144 h), ré-autorisation à + 120 h + const start = '2031-08-01T10:00:00.000Z'; + const release = at(start, 144, 25); + await workerTx(at(start, 119), async (tx) => { + const seeded = await tx.query<{ deposit_id: string; trip_id: string }>( + `SELECT * FROM test_fixture.us701_converted_deposit($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, + [ + c.country, + c.currency, + timezone, + start, + at(start, 72), + amount.toString(), + at(start, 144), + release, + release, + at(start, 120), + `fake-${randomUUID()}`, + ], + ); + const id = seeded.rows[0]!.deposit_id; + const store = new PgDepositTimerStore(tx); + const mine = async () => (await store.due(500)).filter((d) => d.depositId === id); + expect(await mine()).toEqual([]); + await setClock(tx, at(start, 120)); + const [due] = await mine(); + expect(due).toMatchObject({ + tripId: seeded.rows[0]!.trip_id, + country: c.country, + currency: c.currency, + currencyExponent: exponent, + provider: 'FAKE', + reauthSeq: 0, + }); + expect(due?.authExpiryAt.toISOString()).toBe(at(start, 144)); + expect(due?.releaseAt.toISOString()).toBe(release); + expect(due?.now.toISOString()).toBe(at(start, 120)); + const schedule = { + authExpiryAt: new Date(at(start, 288)), + decisionAt: new Date(release), + reauthDueAt: null, + }; + expect(await store.transition(id, 'REAUTHORIZED', 0, schedule)).toBe('APPLIED'); + expect(await mine()).toEqual([]); + expect(await store.transition(id, 'REAUTHORIZED', 0, schedule)).toBe('STALE'); + }); + }); + + it('PgDepositDecisionStore et DepositDecisionTimer : décision échue à fin + 70 h lue (montant bigint, rail, expiration), configuration relue en base, autorisation laissée expirer sans appel au PSP, puis STALE', async () => { + // T57 : trip de 72 h, expiration fin + 72 h, décision fin + 70 h + const start = '2031-09-01T10:00:00.000Z'; + const end = at(start, 72); + await workerTx(at(end, 69), async (tx) => { + const seeded = await tx.query<{ deposit_id: string; trip_id: string }>( + `SELECT * FROM test_fixture.us702_converted_deposit($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, + [ + c.country, + c.currency, + timezone, + start, + end, + amount.toString(), + 'PREAUTH_SINGLE', + at(end, 72), + at(end, 72), + at(end, 70), + `fake-${randomUUID()}`, + ], + ); + const id = seeded.rows[0]!.deposit_id; + const store = new PgDepositDecisionStore(tx); + const mine = async () => (await store.due(500)).filter((d) => d.depositId === id); + expect(await mine()).toEqual([]); + await setClock(tx, at(end, 70)); + const [due] = await mine(); + expect(due).toMatchObject({ + tripId: seeded.rows[0]!.trip_id, + country: c.country, + currency: c.currency, + currencyExponent: exponent, + provider: 'FAKE', + mechanism: 'PREAUTH_SINGLE', + amountMinor: amount, + reauthSeq: 0, + }); + expect(due?.decisionAt.toISOString()).toBe(at(end, 70)); + expect(due?.authExpiryAt?.toISOString()).toBe(at(end, 72)); + const stack = fakeStack(); + const decided: string[] = []; + const timer = new DepositDecisionTimer({ + config: (country, provider) => new PgDepositRailConfigReader(tx).read(country, provider), + decide: async (depositId, seq, outcome) => { + const r = await store.decide(depositId, seq, outcome); + decided.push( + `${outcome.status}:${outcome.capturedMinor}:${outcome.releasedMinor}:${r}`, + ); + return r; + }, + fees: NO_DEPOSIT_FEES, + alerts: { send: () => Promise.resolve() }, + connectors: { get: (name) => (name === 'FAKE' ? stack.provider : undefined) }, + }); + expect(await timer.process(due!)).toBe('EXPIRED'); + expect(decided).toEqual([`EXPIRED:0:${amount}:APPLIED`]); + expect(stack.psp.calls('VOID')).toBe(0); + expect(stack.psp.calls('CAPTURE')).toBe(0); + expect(await mine()).toEqual([]); + expect( + await store.decide(id, 0, { status: 'VOIDED', capturedMinor: 0n, releasedMinor: amount }), + ).toBe('STALE'); + }); + }); + }, +); diff --git a/apps/api/src/modules/pay/testing/deposit-timer.fake.test.ts b/apps/api/src/modules/pay/testing/deposit-timer.fake.test.ts index 3d613ab2..4c30e0e3 100644 --- a/apps/api/src/modules/pay/testing/deposit-timer.fake.test.ts +++ b/apps/api/src/modules/pay/testing/deposit-timer.fake.test.ts @@ -10,6 +10,8 @@ import { createHash } from 'node:crypto'; import { readFileSync } from 'node:fs'; import { createCurrencyRegistry } from '@rueda/money'; +import { checksFor, loadGoldenVectors } from '@rueda/money/golden-vectors'; +import type { GoldenValue } from '@rueda/money/golden-vectors'; import { describe, expect, it } from 'vitest'; import type { OpsAlert } from '../../bus/index.js'; import { CapabilitySet } from '../internal/capabilities.js'; @@ -26,6 +28,13 @@ import { countryCases } from '../../../../test/support/countries.js'; import { fakeStack } from './fake-stack.js'; import type { FakeStackOptions } from './fake-stack.js'; +const set = loadGoldenVectors(); +const check = (vectorId: string, label: RegExp): GoldenValue => { + const found = checksFor(set, vectorId).find((c) => label.test(c.label)); + if (found === undefined) throw new Error(`contrôle ${vectorId} ${label} absent`); + return found.expected; +}; + const CURRENCIES = createCurrencyRegistry( ( JSON.parse( @@ -41,11 +50,23 @@ const PARAMS = ( const p = (key: string, country: string): unknown => PARAMS.find((x) => x.key === key)?.values[country]; -const CASES = countryCases().map((c) => ({ - ...c, - exponent: CURRENCIES.get(c.currency).exponent, - deposit: 300n * 10n ** BigInt(CURRENCIES.get(c.currency).exponent), -})); +/** + * Montant de test de la caution selon l'exposant de la devise du pays (US-702, revues argent et qa + * d'US-701) : T57 en centimes (exposant 2 : 300,00 = 30 000) ; T73 a sans décimale (exposant 0 : + * `deposit_amount[PY][LUXE]` = 1 500 000). Aucun code de pays ni de devise écrit ici. + */ +const T57 = check('T57', /^T57$/) as Record; +const T73 = check('T73', /^T73 a\/b$/) as unknown[]; +const DEPOSIT_BY_EXPONENT = new Map([ + [2, (T57['capture'] ?? 0n) + (T57['void'] ?? 0n)], + [0, T73[1] as bigint], +]); +const CASES = countryCases().map((c) => { + const exponent = CURRENCIES.get(c.currency).exponent; + const deposit = DEPOSIT_BY_EXPONENT.get(exponent); + if (deposit === undefined) throw new Error(`devise sans vecteur de caution : ${c.currency}`); + return { ...c, exponent, deposit }; +}); const H = 3_600_000; const T = Date.parse('2031-07-10T10:00:00.000Z'); diff --git a/apps/api/src/worker-tasks.ts b/apps/api/src/worker-tasks.ts index e00e0654..1eee64a8 100644 --- a/apps/api/src/worker-tasks.ts +++ b/apps/api/src/worker-tasks.ts @@ -25,7 +25,7 @@ * | `trip_lifecycle` | 10 s (US-215, ADR-148) | `TripCancellationProcessor` de STL : chaque demande d'annulation de l'ops (`core.booking_trip_cancellations_pending`) réglée dans sa propre transaction (`core.booking_trip_cancellation_begin`, moteur unique, `core.settlement_cmd_record`, `core.booking_cmd_trip_settle_cancellation`, ordres REFUND bornés de 0121) ; refus garés par `core.booking_cmd_trip_park_cancellation`, alertes `FIN_SETTLEMENT_REVIEW` ou `TRIP_CANCELLATION_FAILED` (P1) | * | `refund_scheduler` | 10 s (US-224c, ADR-150) | `RefundScheduler` de STL sous le nom `payment_command` : file `core.payment_refunds_due` (0127), une instance par transaction ; `core.payment_cmd_submit_refund`, puis l'ordre stocké relu sous les verrous du trip et de l'ordre (`core.payment_cmd_refund_order_for_send`) et envoyé par `MoneyCommandSender` au connecteur du fournisseur ; report `core.settlement_cmd_apply_leg_movement` d'un remboursement prouvé ; alertes `FIN_REFUND_BLOCKED`, `FIN_REFUND_FAILED` (P1, une fois par état). Aucun connecteur en production avant le lot C : rien n'est autorisé ni envoyé | * - * | `deposit_timer` | 60 s (US-701, ADR-169) | `DepositReauthTimer` de PAY sous le nom `payment_command` : file `core.payment_deposit_reauth_due` (0146), ré-autorisation de la caution (rail a) par le connecteur du fournisseur, report `core.payment_cmd_deposit_transition` ; refusée ⇒ décision avancée avant l'expiration, alerte `DEPOSIT_REAUTH_FAILED` (P1), aucun débit. Aucun connecteur en production avant le lot C : rien n'est envoyé | + * | `deposit_timer` | 60 s (US-701, ADR-169) | `DepositReauthTimer` de PAY sous le nom `payment_command` : file `core.payment_deposit_reauth_due` (0146), ré-autorisation de la caution (rail a) par le connecteur du fournisseur, report `core.payment_cmd_deposit_transition` ; refusée ⇒ décision avancée avant l'expiration, alerte `DEPOSIT_REAUTH_FAILED` (P1), aucun débit. Puis décisions échues (US-702, ADR-172) : `DepositDecisionTimer`, file `core.payment_deposit_decision_due` (0148), VOID / capture des frais / MIT par le connecteur, transition finale `core.payment_cmd_deposit_decide` et événement `deposit.decision.executed` (avis au voyageur) ; aucune source de frais annexes en production (`NO_DEPOSIT_FEES` : caution libérée en entier). Aucun connecteur en production avant le lot C : rien n'est envoyé | * * Non déclarés ici, faute de port réel (tracé dans docs/team/handoffs/US-003.md) : * `payment_intent_sweeper` et `payment_command` (lisent ou appellent le PSP : adaptateurs du lot C, diff --git a/apps/web/app/(app)/checkout/hold/[holdId]/page.tsx b/apps/web/app/(app)/checkout/hold/[holdId]/page.tsx index 04ed77af..6b512153 100644 --- a/apps/web/app/(app)/checkout/hold/[holdId]/page.tsx +++ b/apps/web/app/(app)/checkout/hold/[holdId]/page.tsx @@ -279,7 +279,9 @@ export default async function HoldPage({ ? t(depositRefusal.key, { count: depositRefusal.count }) : t(depositRefusal.key)} - + {/* US-702 (revue ux d'US-701) : sortie vers la recherche elle-même, autres dates ou + autre voiture */} + {t('web.listing.search')} diff --git a/apps/web/e2e/checkout-payment.spec.ts b/apps/web/e2e/checkout-payment.spec.ts index 3b2236ac..fdf0992b 100644 --- a/apps/web/e2e/checkout-payment.spec.ts +++ b/apps/web/e2e/checkout-payment.spec.ts @@ -344,7 +344,11 @@ for (const language of LANGUAGES) { await expect(section.locator('[role="alert"]')).toHaveText( t.t('web.deposit.unavailable', { count: 3 }), ); - await expect(section.getByRole('link', { name: t.t('web.listing.search') })).toBeVisible(); + // US-702 (revue ux d'US-701) : la sortie mène à la recherche elle-même + await expect(section.getByRole('link', { name: t.t('web.listing.search') })).toHaveAttribute( + 'href', + '/search', + ); await expect(page.locator('[data-testid="s05-pay-submit"]')).toHaveCount(0); await expectAccessible(page); await expectMobileFriendly(page); diff --git a/changelog.d/US-702-decision-caution.md b/changelog.d/US-702-decision-caution.md new file mode 100644 index 00000000..366e7450 --- /dev/null +++ b/changelog.d/US-702-decision-caution.md @@ -0,0 +1,9 @@ +lot: L2 +module: Paiements + +- Ajouté : décision automatique de la caution à l'heure de décision (fin + 72 h, 70 h dans le cas T57), par la tâche de la caution du travailleur : annulation de l'autorisation, capture des seuls frais annexes annoncés si le PSP le permet, débit séparé sinon ; jamais suspendue par une réclamation (migration 0148, US-702, ADR-172) +- Ajouté : état final de la caution enregistré une fois (capturé, libéré, heure) et événement `deposit.decision.executed` ; une autorisation expirée n'est jamais capturée (US-702) +- Ajouté : avis au voyageur « caution libérée » ou « frais capturés, reste libéré » par e-mail puis SMS, en espagnol, anglais, français et portugais du Brésil (catalogue v87, US-702) +- Ajouté : alertes ops `DEPOSIT_DECISION_FAILED` et `DEPOSIT_FEES_UNCOLLECTED` (US-702) +- Modifié : le fournisseur et l'échéancier de la caution sont recalculés par la base à l'écriture de la décision, au lieu d'être repris de l'API (US-702, suite des revues d'US-701) +- Modifié : la sortie de la page de paiement quand la caution est impossible mène à la recherche (US-702) diff --git a/docs/adr/ADR-172-decision-de-la-caution.md b/docs/adr/ADR-172-decision-de-la-caution.md new file mode 100644 index 00000000..b0402092 --- /dev/null +++ b/docs/adr/ADR-172-decision-de-la-caution.md @@ -0,0 +1,29 @@ +# ADR-172 — Décision de la caution à l'heure de décision : libération automatique, transitions finales, échéancier recalculé par la base + +- **Statut** : PROPOSÉ (US-702, agent de story argent, claude-opus-5-5, 2026-11-18). Revues exigées : celles de `node scripts/ci/check-story-reviews.mjs` ; argent, RLS / rôles, `SECURITY DEFINER` et concurrence sur un autre modèle que l'auteur. À reporter par une PR revue de `docs/specs/` : 17 §3.2.7 (`captured_minor`, `released_minor`, `decision_executed_at` de `deposit_hold`), §4.5 (charge utile de `deposit.decision.executed`), 16 PAY-011 (« Notifications » : `EVT_DEPOSIT_RELEASED` et avis de capture partielle). +- **Complète** : ADR-169 (caution figée au checkout, minuterie de ré-autorisation, US-701), ADR-164 (rails, US-225), ADR-108 (caution « comme Turo »). +- **Sources** : 19 US-702 (critères 1 et 2), suites d'US-701 (passation, revues argent n° 6 et 7, sécurité n° 9 et 11, code n° 6 et 7, qa n° 6 et 7, ux n° 5) ; 08 BR-PAY-06 (« Libération à heure fixe, jamais suspendue »), E3 (replis 1, 2 et 4), E4 ; vecteurs T57, T58, T73 (oracle `docs/specs/tools/check_t49plus.py`) ; 16 PAY-011 / PAY-012 ; 17 §0.1, §3.2.7, §4.3, §4.5. + +## Contexte + +US-701 a figé la décision de la caution au checkout (`deposit_hold`) et branché la ré-autorisation ; l'exécution à l'heure de décision (T57 : fin + 70 h), les transitions finales et l'avis au voyageur restaient à faire. Les revues d'US-701 ont aussi relevé que `provider`, `auth_at`, `release_at`, `decision_at` et `reauth_due_at` étaient écrits tels que reçus de l'API : une API compromise pouvait raccourcir la libération. + +## Décision + +1. **Échéancier recalculé par la base** (migration 0148, `payment_cmd_record_deposit_decision` remplacée à signature identique) : fournisseur = compte marchand du pays (même choix que `payment_deposit_checkout` et T1) ; `auth_at = max(platform.now(), début − auth_lead_h)` ; `release_at = fin du devis engagé + release_delay_h` ; `decision_at` et `reauth_due_at` selon ADR-169 point 5 ; durées lues en base (politique `cmd_hold_deposit_read` élargie à `auth_lead_h`, `release_delay_h`, `deposit_safety_h`, `deposit_reauth_lead_h`). Les champs correspondants de l'API sont ignorés. `V` (validité du PSP) reste l'instantané de la décision, borné et entier : il ne peut qu'avancer la décision (minimum avec la libération), jamais la retarder. Valeur absente ou illisible ⇒ refus (`deposit_decision_mismatch`). +2. **File et transition finale** (cmd_hold_owner, travailleur `payment_command`) : `payment_deposit_decision_due(lot)` rend les cautions AUTORISÉES dont la décision est échue (`decision_at ≤ platform.now()`) ou l'autorisation expirée ; elle ne lit ni réclamation, ni facture, ni frais d'assistance (la libération n'est jamais suspendue). `payment_cmd_deposit_decide(…)` : rang attendu (`STALE` sinon) ; jamais avant `decision_at` sauf `EXPIRED` d'une autorisation expirée ; aucune capture après `auth_expiry_at` ; `REFUNDED` ⇔ rail « débit puis remboursement » ; colonnes ajoutées `captured_minor`, `released_minor`, `decision_executed_at` posées une fois, Σ = montant, capture > 0 ⇔ `PARTIALLY_CAPTURED` (`deposit_hold_final_shape`) ; événement `deposit.decision.executed` (acteur SYSTEM, identifiants, état et montants, aucune donnée [C2]) dans la même transaction (politique `cmd_hold_deposit_event_ins`). +3. **Exécution** (`DepositDecisionTimer`, dans la tâche `deposit_timer` après les ré-autorisations) : autorisation expirée ⇒ `EXPIRED` sans appel ; sinon plan pur `planDepositDecision` (T57 : capture des frais puis VOID ; T58 : VOID puis MIT) exécuté par le port hors transaction, clés de 08 E4 ; issue inconnue ⇒ rien d'écrit, même clé au passage suivant ; VOID refusé ⇒ autorisation laissée expirer (08 E3 repli 4), alerte `DEPOSIT_DECISION_FAILED` (P1) ; MIT refusé, sans carte enregistrée ou sans capacité ⇒ caution libérée quand même, frais en dette, alerte `DEPOSIT_FEES_UNCOLLECTED` (P2) ; autre échec ⇒ alerte, nouvel essai. Aucun connecteur en production avant le lot C : rien n'est envoyé. +4. **Frais annexes : aucune source en production** (`NO_DEPOSIT_FEES`, PROPOSÉ, fail-closed) : le registre des frais annexes prouvés et notifiés (et la décision de l'ops sur preuves, 16 PAY-012 bêta) n'existe pas encore ; rien n'est donc jamais capturé sur la caution, elle est libérée en entier et les frais éventuels passent ensuite par MIT `DELAYED_CHARGES`, comme chez Turo (jamais plus lourd). Le port `DepositFeeSource` accueillera la source réelle. `deposit_fee_notice_h` absent ⇒ aucun frais capturable sur la caution. +5. **Avis au voyageur** (NTF) : `deposit.decision.executed` ⇒ `EVT_DEPOSIT_RELEASED` (`VOIDED`, `EXPIRED`, `REFUNDED` : montant libéré) ou `EVT_DEPOSIT_PARTIALLY_CAPTURED` (frais annoncés capturés et reste libéré), voyageur du trip lu en base, e-mail puis SMS ; textes `ntf.depositReleased.*`, `ntf.depositPartiallyCaptured.*` en es, en, fr, pt-BR (catalogue v87). Aucun texte n'affirme que Kmino ou l'hôte « garde » la caution (10b UX-25). + +## Options écartées + +- Recalculer aussi `V` et `H_requise` en SQL : il faudrait recopier la lecture des capacités par réseau (`CapabilitySet`) ; `V` ne peut qu'avancer la décision, le risque relevé (raccourcir la libération) est fermé par `release_at`. +- Une tâche périodique distincte pour la décision : même nom de travailleur, même file de transactions ; une seule tâche évite une course entre ré-autorisation et décision sur la même caution. +- Suspendre la décision tant qu'une ré-autorisation est en cours : contraire à « jamais suspendue » ; une autorisation expirée entre-temps est simplement constatée (`EXPIRED`). + +## Conséquences + +- Au PA et au PY aujourd'hui : aucune caution n'est posée (pose à `auth_at` : S-1, lot C ; LUXE À DÉCIDER) ; la file reste vide et rien n'est envoyé. Aucun interrupteur touché, aucun fonds de tiers détenu. +- Non livré (suites) : registre des frais annexes et décision de l'ops sur preuves, enregistrement des opérations `DEPOSIT_*` dans `payment_operation` avec le vrai connecteur (lot C), écran de suivi S09 « Tu depósito » (UX-25, L3). +- Preuves : `apps/api/src/modules/pay/testing/deposit-decision.fake.test.ts`, `pay/testing/deposit-timer-store.int.test.ts`, `ntf/internal/dispatcher.test.ts`, `packages/db/test/l0/l0-us702-deposit-decision.test.ts`. diff --git a/docs/ops/GO_LIVE_CHECKLIST.md b/docs/ops/GO_LIVE_CHECKLIST.md index 7d7f3a8f..45c4c026 100644 --- a/docs/ops/GO_LIVE_CHECKLIST.md +++ b/docs/ops/GO_LIVE_CHECKLIST.md @@ -72,7 +72,7 @@ | GL-41 | **Caution « comme Turo » prête avant l'ouverture d'un pays** (US-225, ADR-108, ADR-164 ; 08 BR-PAY-06). **Existe** (bêta, fonctions pures et FAKE) : aucune caution par défaut (graine 0142 : `deposit_always_required` faux, `deposit_trigger_classes` = {LUXE}, aucune classe pour l'âge, `risk_control_deployed` faux) ; décision du checkout avant le paiement (`PARAM_MISSING`, `DEPOSIT_RAIL_UNAVAILABLE` avec les jours possibles) ; rail choisi par configuration ; « débit puis remboursement » fermé par `funds_holding_enabled`. **À faire** : (1) `deposit_amount[pays][LUXE]` fixé et `deposit_trigger_classes` confirmé par le fondateur (sinon tout trip LUXE est refusé avant le paiement) ; (2) `provider_max_hold_h`, `MAX_HOLD_HOURS`, `SUPPORTS_PREAUTH`, `SUPPORTS_VOID`, `SUPPORTS_PARTIAL_CAPTURE`, `deposit_safety_h` validés en bac à sable (OQ-PAY-02 ; `SUPPORTS_REAUTH` OQ-PAY-17) ; (3) `deposit_hold`, écriture au checkout, minuteries de ré-autorisation et de décision, écran S05 (US-701, US-702) ; (4) pose à `auth_at` sans le voyageur validée avec le PSP | `l0-us225-deposit-rails.test.ts` et `deposit-rail-config.int.test.ts` verts au SHA déployé ; valeurs relues dans `core.config_param_value` et `core.payment_psp_capability` | fondateur (montants), US-701, US-702, lot C (PSP) | | | GL-45 | **Lieux de prise et de retour complets avant l'ouverture d'un pays** (US-514, ADR-168 ; 16 BKG-016). **Existe** (bêta) : un lieu par véhicule, zone seule avant la réservation, adresse exacte au seul voyageur d'un trip à venir ou en cours jusqu'à la fin prévue + `review_window_days`, retour différent refusé (`ONE_WAY_NOT_ALLOWED`), lieu non modifiable une fois créé. **Manque avant l'ouverture d'un pays** : choix du point par le voyageur parmi plusieurs points de l'hôte ; consignes de rendez-vous saisies par l'hôte ; `review_window_days` du pays confirmé (J-ADM-031) ; durée de conservation du contrat de location qui porte l'adresse | trip réservé en préproduction : adresse visible au voyageur seulement, retirée après la fenêtre ; retour ailleurs refusé ; preuves `l0-us514-meeting-place`, `checkout.contract.test.ts` | US-514 (suite), lot 3 (messages), fondateur (`review_window_days`) | | GL-44 | **Versements visibles sur A08 avant d'ouvrir `payouts_enabled[pays]`** (US-217 partie 217b, ADR-167). **Existe** (bêta) : écran des gains de l'hôte (A08 : acquis et à régler par mois, part, commission de Kmino et pénalité en ligne séparée par trip) et reçu du voyageur (S09 · reçu : total payé, trip fee et sa taxe tant que rien n'en est remboursé, remboursement dû, mention d'intermédiaire, reçu sans valeur fiscale) ; A08 dit toujours que les versements ne sont pas ouverts (`web.a08.payoutsOff`). **Manque avant d'ouvrir `payouts_enabled` dans un pays** : date de versement (`web.a08.payoutOn`, BR-PAYOUT-02) et statuts du lot de versement (`web.a08.status.*` : programmé, envoyé, retenu avec la raison) lus de l'API ; mentions du reçu validées par le comptable (GL-38). | -| GL-46 | **Caution figée au checkout et ré-autorisation branchées** (US-701, ADR-169 ; 08 BR-PAY-06). **Existe** (bêta, sur `FAKE`) : décision de la caution figée une fois par réservation avant le paiement (`deposit_hold`, migration 0146), revérifiée par la base (montant du pays et de la classe, aucune « sans caution » sur une classe déclencheur, « débit puis remboursement » fermé par `funds_holding_enabled`) ; S05 affiche la caution ou le refus avant tout paiement ; minuterie `deposit_timer` (ré-autorisation, refus signalé à l'ops sans débit). **À faire** : (1) pose à `auth_at` par le connecteur réel (S-1, lot C) et décision de libération (US-702) ; (2) âge des conducteurs et signal de risque lus au checkout (S-10) ; (3) fiche et cartes de recherche sur `deposit_amount` (T70 c, N-89) ; (4) console ops des déclencheurs ; (5) GL-41 levé (montant LUXE, capacités du PSP) | `l0-us701-deposit-hold.test.ts`, `deposit-checkout.test.ts`, `deposit-timer.fake.test.ts`, `checkout-deposit.contract.test.ts` et l'e2e S05 (US-701) verts au SHA fusionné | US-702, lot C (PSP), fondateur (montants) | | +| GL-46 | **Caution figée au checkout et ré-autorisation branchées** (US-701, ADR-169 ; 08 BR-PAY-06). **Existe** (bêta, sur `FAKE`) : décision de la caution figée une fois par réservation avant le paiement (`deposit_hold`, migration 0146), revérifiée par la base (montant du pays et de la classe, aucune « sans caution » sur une classe déclencheur, « débit puis remboursement » fermé par `funds_holding_enabled`) ; S05 affiche la caution ou le refus avant tout paiement ; minuterie `deposit_timer` (ré-autorisation, refus signalé à l'ops sans débit ; puis décision à l'heure de décision, US-702, ADR-172 : VOID / capture des frais / MIT, transition finale, avis au voyageur, échéancier recalculé par la base, migration 0148). **À faire** : (1) pose à `auth_at` par le connecteur réel (S-1, lot C), registre des frais annexes et décision de l'ops sur preuves (aujourd'hui aucun frais n'est pris sur la caution), opérations `DEPOSIT_*` dans `payment_operation` avec le vrai connecteur ; (2) âge des conducteurs et signal de risque lus au checkout (S-10) ; (3) fiche et cartes de recherche sur `deposit_amount` (T70 c, N-89) ; (4) console ops des déclencheurs ; (5) GL-41 levé (montant LUXE, capacités du PSP) | `l0-us701-deposit-hold.test.ts`, `l0-us702-deposit-decision.test.ts`, `deposit-checkout.test.ts`, `deposit-timer.fake.test.ts`, `deposit-decision.fake.test.ts`, `deposit-timer-store.int.test.ts`, `checkout-deposit.contract.test.ts` et l'e2e S05 (US-701, US-702) verts au SHA fusionné | lot C (PSP), fondateur (montants) | | | # | Condition | Preuve exigée | Porteur | Coché (date, preuve) | | ----- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | -------------------- | | GL-01 | **EXC-003 fermée** (F-RLS-03, au registre RT-RLS-03, `core.iam_cmd_open_session` ne laisse plus `app_api` choisir l'acteur) | PR fusionnée de la story **US-410** (BOARD, « Suites de la porte du lot 0 ») ; run CI vert sur `main` où **RT-RLS-18 est inversé** (`packages/db/test/l0/redteam-rls/rt-rls-actors.test.ts`, « RT-RLS-18 » exige le refus) ; EXC-003 passée à FERMÉE dans `docs/team/DECISIONS.md` §3 et RT-RLS-03 dans `docs/team/RISKS.md` | US-410 (lot 4, US-003) | | diff --git a/docs/team/COMME_TURO.md b/docs/team/COMME_TURO.md index 676dd7b4..fca1190f 100644 --- a/docs/team/COMME_TURO.md +++ b/docs/team/COMME_TURO.md @@ -222,3 +222,4 @@ Règles : | 2026-11-18 | US-227 | Comment la prime de l'assureur est-elle suivie et payée ? | l'assureur partenaire couvre chaque location ; sa part des frais de protection lui revient selon le contrat, réglée périodiquement par Turo | 08 E7 règles 6 et 7 ; pages publiques de Turo sur les plans de protection et l'assureur partenaire | prime due tenue trip par trip à partir de la part assureur enregistrée ; bordereau mensuel (défaut, contrat à signer) émis par deux personnes FINANCE ; une contestation de paiement gèle la ligne sans réduire la prime ; aucun paiement avant le lot C ; ADR-165 | PROPOSÉ | | 2026-11-18 | US-701 | Que voit le voyageur de la caution avant de payer, et que fait-on si elle est impossible pour ses dates ? | la caution est affichée au checkout avant la réservation (montant, rendue automatiquement après le trip) ; sinon aucune caution | 08 BR-PAY-06 (« Moment de l'évaluation », pages d'aide de Turo relues pour ADR-108) ; 10b UX-24 | la page de paiement dit « aucune caution », ou le montant, le blocage temporaire et la date de libération au plus tard ; caution impossible : message avec les jours possibles, aucun bouton « Payer », lien vers la recherche ; la décision est figée une fois par réservation, jamais les déclencheurs montrés (ADR-169) | PROPOSÉ | | 2026-11-18 | US-701 | Que fait-on si la ré-autorisation de la caution est refusée pendant le trip ? | (mécanisme non publié par Turo) la caution est rendue à heure fixe et les frais passent par la carte enregistrée | 08 BR-PAY-06 « Mécanisme » ; 19 US-225 critère 3 | aucun débit de remplacement : la décision de libération est avancée avant l'expiration de l'autorisation en cours (2 h de marge) et le trip est signalé à l'ops ; les frais constatés plus tard passent par la carte enregistrée (ADR-169) | PROPOSÉ | +| 2026-11-18 | US-702 | Quand la caution est-elle rendue, et que deviennent les frais constatés après le trip ? | la caution est rendue automatiquement quelques jours après la fin du trip (80 h chez Turo), sans attendre une réclamation de dommage ; les frais après le trip sont débités sur la carte enregistrée | 08 BR-PAY-06 « Libération à heure fixe, jamais suspendue », NOTIF-20 ; T57, T58 | décision automatique à fin + 72 h (70 h si l'autorisation expire avant), jamais suspendue par une réclamation ; tant qu'aucun registre des frais annexes n'existe, rien n'est pris sur la caution : elle est libérée en entier et les frais passent par la carte enregistrée ; le voyageur est prévenu (e-mail puis SMS) ; une autorisation expirée n'est jamais capturée (ADR-172) | PROPOSÉ | diff --git a/docs/team/handoffs/US-702.md b/docs/team/handoffs/US-702.md new file mode 100644 index 00000000..37e43177 --- /dev/null +++ b/docs/team/handoffs/US-702.md @@ -0,0 +1,40 @@ +# Passation US-702 — Décision de la caution à l'heure de décision (libération automatique) + +- **Branche** : `story/US-702-liberation-caution` ; agent de story argent, claude-opus-5-5 ; ADR-172 (PROPOSÉ). +- **Numéros pris** : migration `0148_payment_deposit_decision` (suivante de `main` au moment de pousser ; à renuméroter à chaque fusion de `main`), fixture `9934_test_us702_deposit_decision_fixtures.sql`, catalogue **v87**, ADR-172 ; GL-46 mis à jour (aucune nouvelle ligne). + +## Livré + +1. **Échéancier recalculé par la base** (0148, `payment_cmd_record_deposit_decision` remplacée, même signature) : `provider` (compte marchand du pays), `auth_at`, `release_at`, `decision_at`, `reauth_due_at` calculés en base depuis le devis engagé et les durées de 08 ; les champs de l'API sont ignorés (revues argent n° 7, sécurité n° 9, architecture n° 6 d'US-701). `V` reste l'instantané, entier et borné (il ne peut qu'avancer la décision). +2. **File et transition finale** : `payment_deposit_decision_due(lot)` (décision échue ou autorisation expirée ; aucune lecture de réclamation : rien ne suspend la libération) ; `payment_cmd_deposit_decide(…)` (rang attendu, jamais avant l'heure de décision sauf expiration, aucune capture après l'expiration, `REFUNDED` ⇔ rail b, Σ = montant par `deposit_hold_final_shape`) ; événement `deposit.decision.executed`. +3. **Exécution** (`DepositDecisionTimer`, `internal/deposit-decision.ts`) dans la tâche `deposit_timer` après les ré-autorisations : T57 (capture puis VOID), T58 (VOID puis MIT), expiration constatée sans appel, issue inconnue ⇒ même clé, VOID refusé ⇒ laissée expirer (`DEPOSIT_DECISION_FAILED`), MIT impossible ⇒ libérée quand même (`DEPOSIT_FEES_UNCOLLECTED`). Source des frais annexes en production : `NO_DEPOSIT_FEES` (PROPOSÉ, ADR-172 point 4). +4. **Avis au voyageur** : règles NTF sur `deposit.decision.executed` ⇒ `EVT_DEPOSIT_RELEASED` / `EVT_DEPOSIT_PARTIALLY_CAPTURED` (voyageur du trip lu en base) ; textes es, en, fr, pt-BR (catalogue v87). +5. **Petits détails d'US-701** : commentaire de période de `deposit_timer` corrigé (code n° 7) ; montants de test PYG alignés sur T73 (1 500 000) dans `deposit-checkout.test.ts`, `deposit-timer.fake.test.ts` et le L0 d'US-701 (argent n° 6, qa n° 6) ; test d'intégration sur base réelle de `PgDepositTimerStore` et `PgDepositDecisionStore` (code n° 6, qa n° 7) ; preuve `has_function_privilege` ciblée `app_anon` (sécurité n° 11) ; sortie du refus de caution vers `/search` (ux n° 5). + +## Critères de 19 (US-702) + +| Critère | Preuve | +| --------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| T58 (PSP sans capture partielle) : décision ⇒ VOID 300,00 puis MIT 12,00 | `deposit-decision.fake.test.ts` (FAKE, valeurs de l'oracle T58, jambe HOST) ; T57 à côté | +| Sans frais annexes : à fin + 72 h, VOID automatique, journalisé, notifié ; une réclamation ne suspend pas | VOID automatique : `deposit-decision.fake.test.ts` (PA et PY) ; file à l'heure de la base, transition et événement : `l0-us702-deposit-decision.test.ts` ; avis : `dispatcher.test.ts`, `templates.test.ts` ; réclamation : la file ne lit aucune réclamation (par construction, ADR-172) | + +Non couvert ici : pose réelle à `auth_at` (S-1, lot C) — en production aucune caution n'est encore autorisée, la file reste vide ; registre des frais annexes et décision de l'ops sur preuves ; opérations `DEPOSIT_*` dans `payment_operation` avec le vrai connecteur. + +## Tests existants modifiés (justification) + +- `pay/internal/deposit-checkout.test.ts`, `pay/testing/deposit-timer.fake.test.ts` : montant de test lu par exposant (T57 en centimes, T73 a sans décimale) au lieu de 300 mis à l'échelle ; aucun attendu de règle changé (échéancier indépendant du montant). +- `packages/db/test/l0/l0-us701-deposit-hold.test.ts` : PYG 300 ⇒ 1 500 000 (T73) ; aucune assertion retirée ni relâchée. +- `packages/db/test/int/outbox-schema.test.ts` (sécurité) : une entrée ajoutée à la liste exhaustive des politiques, `cmd_hold_deposit_event_ins` (cmd_hold_owner, INSERT) ; toute autre politique reste refusée. +- `ntf/internal/dispatcher.test.ts` : `deposit.decision.executed` ajouté à la liste exacte des abonnements ; nouveau cas. +- `apps/web/e2e/checkout-payment.spec.ts` : la sortie du refus vérifie maintenant `href="/search"`. + +## Décisions PROPOSÉ + +COMME_TURO (ligne US-702) ; ADR-172 : échéancier recalculé par la base, aucune source de frais annexes en production (caution libérée en entier), VOID refusé ⇒ laissée expirer, une seule tâche pour ré-autorisation et décision, avis au voyageur. Aucun montant nouveau (LUXE toujours À DÉCIDER), aucun interrupteur touché. + +## Suites (pour l'orchestrateur) + +- Registre des frais annexes prouvés et notifiés, décision de l'ops sur preuves (16 PAY-012 bêta), branché sur `DepositFeeSource`. +- Lot C : pose à `auth_at` (S-1), opérations `DEPOSIT_*` journalisées dans `payment_operation`, lecture d'état avant rejeu. +- Report dans `docs/specs/` (PR revue) : 17 §3.2.7 (trois colonnes), §4.5 (charge utile), 16 PAY-011 (notifications). +- Hors périmètre, inchangé : S-9, S-10, S-11, S-12, S-1. diff --git a/packages/db/README.md b/packages/db/README.md index c83be70e..ca170c7a 100644 --- a/packages/db/README.md +++ b/packages/db/README.md @@ -1071,3 +1071,12 @@ Migration `0146_payment_deposit_hold`, fixture `9945_test_us701_deposit_hold_fix - **Fonctions** (cmd_hold_owner, RLS-15) : `payment_deposit_checkout(jeton, hold)` et `payment_cmd_record_deposit_decision(jeton, hold, décision)` (EXECUTE `app_api`, voyageur de la session, hold d'un autre ⇒ `HOLD_NOT_FOUND`) ; `payment_deposit_reauth_due(lot)` et `payment_cmd_deposit_transition(…)` (EXECUTE `app_worker`, nom `payment_command`). Revérifications de l'écriture : `deposit_decision_mismatch` (montant ≠ `deposit_amount[pays][classe]`, `NOT_REQUIRED` sur un pays ou une classe déclencheurs, classe inconnue), `deposit_rail_closed` (`CHARGE_THEN_REFUND` tant que `funds_holding_enabled` = faux). - **Droits ajoutés** à cmd_hold_owner : politiques de lecture `cmd_hold_deposit_read` de `config_param_value` (`deposit_always_required`, `deposit_trigger_classes`, `deposit_amount`, `funds_holding_enabled`) et de `config_param_definition` (`funds_holding_enabled`) ; `SELECT (conversion_operation_id)` de `booking_checkout_hold`. - **Preuves** : `test/l0/l0-us701-deposit-hold.test.ts` (PA USD, PY PYG ; `app_api`, `app_worker`). + +## Décision de la caution (US-702 ; 08 BR-PAY-06 ; ADR-172) + +Migration `0148_payment_deposit_decision`, fixture `9934_test_us702_deposit_decision_fixtures.sql` (`test_fixture.us702_converted_deposit` : caution autorisée d'un hold converti, rail au choix, EXECUTE `app_worker` ; `test_fixture.us702_deposit_schedule` : lecture de l'échéancier écrit, EXECUTE `app_api`). + +- **Table** `core.payment_deposit_hold` : colonnes ajoutées `captured_minor`, `released_minor`, `decision_executed_at`, posées une fois par la transition finale (`deposit_hold_final_shape` : état final ⇔ décision exécutée, Σ = montant, capture > 0 ⇔ `PARTIALLY_CAPTURED`) ; index `deposit_hold_decision_due_idx`. +- **Fonctions** (cmd_hold_owner, RLS-15) : `payment_cmd_record_deposit_decision` remplacée (fournisseur et échéancier recalculés par la base) ; `payment_deposit_decision_due(lot)` et `payment_cmd_deposit_decide(…)` (EXECUTE `app_worker`, nom `payment_command`) : jamais avant l'heure de décision sauf expiration, aucune capture après l'expiration, `REFUNDED` ⇔ rail b, rang attendu (`STALE`), événement `deposit.decision.executed`. +- **Droits** : politique `cmd_hold_deposit_read` de `config_param_value` élargie (`auth_lead_h`, `release_delay_h`, `deposit_safety_h`, `deposit_reauth_lead_h`) ; politique ajoutée `cmd_hold_deposit_event_ins` sur `outbox_outbox_event` ; `UPDATE` des trois colonnes à cmd_hold_owner. +- **Preuves** : `test/l0/l0-us702-deposit-decision.test.ts` (PA USD, PY PYG ; `app_api`, `app_worker`, `app_anon` par `has_function_privilege`). diff --git a/packages/db/migrations/0148_payment_deposit_decision.sql b/packages/db/migrations/0148_payment_deposit_decision.sql new file mode 100644 index 00000000..e0332a7b --- /dev/null +++ b/packages/db/migrations/0148_payment_deposit_decision.sql @@ -0,0 +1,403 @@ +-- 0148 — PAY : décision de la caution à l'heure de décision (libération automatique, transitions +-- finales) et échéancier recalculé par la base. +-- US-702 ; 19 US-702 (critères 1 et 2 : T58 « VOID 300,00 puis MIT 12,00 » ; « fin + 72 h ⇒ VOID +-- automatique, journalisé, notifié au voyageur ; une réclamation de dommage ne la suspend jamais ») ; +-- 16 PAY-011 / PAY-012 (« États », « Notifications ») ; 08 BR-PAY-06 (« Libération à heure fixe, +-- jamais suspendue », T57, T58) ; 17 v6 §3.2.7 (`deposit_hold`), §4.5 (`deposit.decision.executed`), +-- §0.1 ; ADR-169 (0146), ADR-172 (cette migration). Appliquée sous `migrator`. +-- +-- Cette migration : +-- 1. `core.payment_deposit_hold` : colonnes AJOUTÉES `captured_minor`, `released_minor` +-- (unités mineures, Σ = montant de la caution) et `decision_executed_at` (heure de la base), +-- posées UNE fois par la transition finale ; un état final ⇔ ces trois colonnes ; aucune +-- capture dans `VOIDED`, `EXPIRED`, `REFUNDED` ; une capture > 0 dans `PARTIALLY_CAPTURED`. +-- La garde de 0146 (état final figé, décision et identité figées) est inchangée ; +-- 2. `core.payment_cmd_record_deposit_decision` (CREATE OR REPLACE depuis 0146) : `provider`, +-- `auth_at`, `release_at`, `decision_at` et `reauth_due_at` RECALCULÉS par la base au lieu d'être +-- écrits tels que reçus de l'API (revues argent et sécurité d'US-701) : compte marchand du pays +-- (même choix que `payment_deposit_checkout` et T1), `auth_at = max(platform.now(), début − +-- auth_lead_h)`, `release_at = fin du devis engagé + release_delay_h`, `decision_at` et +-- `reauth_due_at` selon 08 BR-PAY-06 (ADR-169 point 5) ; paramètre de durée absent ou illisible ⇒ +-- refus (fail-closed). Le reste de la commande est recopié de 0146 sans changement ; +-- 3. `core.payment_deposit_decision_due(lot)` (app_worker, `payment_command`) : cautions AUTORISÉES +-- dont la décision est échue (`decision_at ≤ platform.now()`) ou dont l'autorisation a expiré, +-- hold converti en trip ; aucune lecture d'une réclamation, d'une facture ni d'un frais +-- d'assistance : rien ne suspend la libération (08 BR-PAY-06) ; +-- 4. `core.payment_cmd_deposit_decide(…)` (app_worker, `payment_command`) : transition FINALE gardée +-- (rang attendu ; jamais avant `decision_at` sauf expiration ; jamais de capture après +-- `auth_expiry_at` ; `REFUNDED` ⇔ rail « débit puis remboursement ») et événement +-- `deposit.decision.executed` (17 §4.5) dans la même transaction (journal et avis au voyageur, +-- NTF), sans aucune donnée [C2]. +-- +-- Erreurs (SQLSTATE, contrainte) traduites par packages/db/src/errors.ts, sans DETAIL : +-- deposit_decision_mismatch (23514) → INVARIANT_VIOLATION ; deposit_hold_guarded (55000) → +-- INVARIANT_VIOLATION ; deposit_hold_command_forbidden (42501) → FORBIDDEN ; +-- deposit_hold_final_shape (23514) → INVARIANT_VIOLATION (contrainte de table). +-- Issues rendues (texte) : APPLIED, STALE (et celles de 0146 pour l'écriture de la décision). +-- +-- Expand / contract : trois colonnes NULL, une contrainte, un index, deux fonctions, une politique +-- AJOUTÉS ; une fonction REMPLACÉE (même signature, mêmes droits) ; la politique de lecture de la +-- configuration de cmd_hold_owner ÉLARGIE à quatre durées de 08 BR-PAY-06. Rien de retiré. +-- +-- Retour arrière : +-- DROP FUNCTION core.payment_deposit_decision_due(integer), +-- core.payment_cmd_deposit_decide(uuid, integer, text, bigint, bigint); +-- DROP POLICY cmd_hold_deposit_event_ins ON core.outbox_outbox_event; +-- ALTER POLICY cmd_hold_deposit_read ON core.config_param_value USING (key IN +-- ('deposit_always_required', 'deposit_trigger_classes', 'deposit_amount', 'funds_holding_enabled')); +-- ALTER TABLE core.payment_deposit_hold DROP CONSTRAINT deposit_hold_final_shape, +-- DROP COLUMN captured_minor, DROP COLUMN released_minor, DROP COLUMN decision_executed_at; +-- DROP INDEX core.deposit_hold_decision_due_idx; +-- puis recréer core.payment_cmd_record_deposit_decision depuis 0146. + +-- 1. Colonnes de la décision exécutée -------------------------------------------------------------- +ALTER TABLE core.payment_deposit_hold + ADD COLUMN captured_minor bigint, + ADD COLUMN released_minor bigint, + ADD COLUMN decision_executed_at timestamptz, + -- 16 PAY-011 « États » : un état final porte la décision exécutée, et seulement lui ; Σ = montant + ADD CONSTRAINT deposit_hold_final_shape CHECK ( + COALESCE(status IN ('PARTIALLY_CAPTURED', 'VOIDED', 'REFUNDED', 'EXPIRED'), false) + = (decision_executed_at IS NOT NULL) + AND (decision_executed_at IS NULL) = (captured_minor IS NULL) + AND (decision_executed_at IS NULL) = (released_minor IS NULL) + AND (decision_executed_at IS NULL + OR (captured_minor >= 0 AND released_minor >= 0 + AND captured_minor + released_minor = amount_minor + AND (status = 'PARTIALLY_CAPTURED') = (captured_minor > 0)))); +CREATE INDEX deposit_hold_decision_due_idx ON core.payment_deposit_hold (decision_at) + WHERE status = 'AUTHORIZED'; +COMMENT ON COLUMN core.payment_deposit_hold.captured_minor IS + 'Frais annexes capturés sur la caution à la décision (unités mineures) ; NULL avant. US-702.'; +COMMENT ON COLUMN core.payment_deposit_hold.released_minor IS + 'Part libérée (VOID, expiration) ou remboursée (rail b) à la décision ; NULL avant. US-702.'; + +-- transition finale (travailleur payment_command, politique cmd_hold_upd de 0146) +GRANT UPDATE (captured_minor, released_minor, decision_executed_at) + ON core.payment_deposit_hold TO cmd_hold_owner; + +-- 2. Droits complémentaires de cmd_hold_owner ------------------------------------------------------ +-- durées de 08 BR-PAY-06 relues par l'écriture de la décision (échéancier recalculé en base) +ALTER POLICY cmd_hold_deposit_read ON core.config_param_value + USING (key IN ('deposit_always_required', 'deposit_trigger_classes', 'deposit_amount', + 'funds_holding_enabled', 'auth_lead_h', 'release_delay_h', 'deposit_safety_h', + 'deposit_reauth_lead_h')); +-- événement de la décision exécutée (17 §4.5), acteur SYSTEM, travailleur payment_command +CREATE POLICY cmd_hold_deposit_event_ins ON core.outbox_outbox_event FOR INSERT TO cmd_hold_owner + WITH CHECK (aggregate_type = 'deposit_hold' AND type = 'deposit.decision.executed' + AND actor_role = 'SYSTEM' AND actor_user_id IS NULL + AND app.actor_kind() = 'WORKER' AND app.worker_name() = 'payment_command'); + +-- 3. Fonctions (cmd_hold_owner, liste blanche RLS-15) ------------------------------------------- +GRANT CREATE ON SCHEMA core TO cmd_hold_owner; +SET LOCAL ROLE cmd_hold_owner; + +-- Écriture unique de la décision (avant T1), recopiée de 0146 ; seul l'échéancier change : il est +-- RECALCULÉ ici (les champs `provider`, `authAt`, `releaseAt`, `decisionAt`, `reauthDueAt` de l'API +-- sont ignorés : une API compromise ne peut ni choisir le connecteur ni raccourcir la libération). +CREATE OR REPLACE FUNCTION core.payment_cmd_record_deposit_decision(p_token_hash bytea, + p_hold_id uuid, + p_decision jsonb) + RETURNS text + LANGUAGE plpgsql + VOLATILE + SECURITY DEFINER + SET search_path = pg_catalog, pg_temp +AS $fn$ +DECLARE + v_user uuid; + v_hold record; + v_t record; + v_class text; + v_mech text := p_decision ->> 'mechanism'; + v_triggers text[]; + v_amount bigint; + v_always jsonb; + v_classes jsonb; + v_amounts jsonb; + v_prev_kind text; + v_prev_actor text; + v_locked boolean; + v_now timestamptz := platform.now(); + v_hours jsonb; + v_lead_h integer; + v_delay_h integer; + v_safety_h integer; + v_rlead_h integer; + v_v_h integer; + v_provider text; + v_auth_at timestamptz; + v_release_at timestamptz; + v_decision timestamptz; + v_reauth_due timestamptz; + v_expiry timestamptz; +BEGIN + SELECT s.user_id INTO v_user FROM core.iam_session_resolve(p_token_hash) AS s; + IF v_user IS NULL THEN + RETURN 'AUTH_REQUIRED'; + END IF; + SELECT h.id, h.country_code, h.vehicle_id, h.status INTO v_hold + FROM core.booking_checkout_hold AS h + JOIN core.booking_checkout_acceptance AS a ON a.hold_id = h.id + WHERE h.id = p_hold_id AND h.guest_user_id = v_user AND a.guest_user_id = v_user; + IF v_hold.id IS NULL THEN + RETURN 'HOLD_NOT_FOUND'; + END IF; + IF EXISTS (SELECT 1 FROM core.payment_deposit_hold AS d WHERE d.hold_id = v_hold.id) THEN + RETURN 'EXISTING'; + END IF; + IF v_hold.status NOT IN ('ACTIVE', 'PAYMENT_IN_FLIGHT') THEN + RETURN 'HOLD_NOT_PAYABLE'; + END IF; + SELECT * INTO v_t FROM core.booking_checkout_capture_terms(v_hold.id); + IF v_t.currency IS NULL THEN + RETURN 'QUOTE_UNAVAILABLE'; + END IF; + SELECT v.value_class INTO v_class FROM core.catalog_vehicle AS v WHERE v.id = v_hold.vehicle_id; + IF pg_catalog.jsonb_typeof(p_decision -> 'triggers') IS DISTINCT FROM 'array' + OR (p_decision ->> 'amountMinor') !~ '^(0|[1-9][0-9]{0,17})$' THEN + RAISE EXCEPTION 'caution : décision illisible' + USING ERRCODE = 'check_violation', CONSTRAINT = 'deposit_decision_mismatch'; + END IF; + v_triggers := ARRAY(SELECT pg_catalog.jsonb_array_elements_text(p_decision -> 'triggers')); + v_amount := (p_decision ->> 'amountMinor')::bigint; + v_always := core.payment_deposit_amount_param('deposit_always_required', v_hold.country_code); + v_classes := core.payment_deposit_amount_param('deposit_trigger_classes', v_hold.country_code); + v_amounts := core.payment_deposit_amount_param('deposit_amount', v_hold.country_code); + IF v_mech = 'NOT_REQUIRED' THEN + -- fail-closed (08 BR-PAY-06) : paramètre absent ou illisible, classe inconnue ⇒ déclencheur vrai + IF v_always IS DISTINCT FROM 'false'::jsonb + OR pg_catalog.jsonb_typeof(v_classes) IS DISTINCT FROM 'array' + OR v_class IS NULL + OR v_classes ? v_class THEN + RAISE EXCEPTION 'caution : aucune caution refusée pour ce pays ou cette classe' + USING ERRCODE = 'check_violation', CONSTRAINT = 'deposit_decision_mismatch'; + END IF; + ELSE + -- montant unique (08 « Montant unique ») : deposit_amount[pays][classe], jamais inventé + IF v_class IS NULL OR pg_catalog.jsonb_typeof(v_amounts) IS DISTINCT FROM 'object' + OR (v_amounts ->> v_class) IS NULL + OR (v_amounts ->> v_class) !~ '^[1-9][0-9]{0,17}$' + OR (v_amounts ->> v_class)::bigint <> v_amount THEN + RAISE EXCEPTION 'caution : montant différent de deposit_amount' + USING ERRCODE = 'check_violation', CONSTRAINT = 'deposit_decision_mismatch'; + END IF; + -- aucun fonds de tiers détenu (17 §0.1) : rail (b) fermé tant que l'interrupteur est faux + IF v_mech = 'CHARGE_THEN_REFUND' + AND NOT core.config_go_live('funds_holding_enabled', v_hold.country_code) THEN + RAISE EXCEPTION 'caution : débit puis remboursement fermé (funds_holding_enabled)' + USING ERRCODE = 'object_not_in_prerequisite_state', CONSTRAINT = 'deposit_rail_closed'; + END IF; + IF v_mech NOT IN ('PREAUTH_SINGLE', 'REAUTH', 'CHARGE_THEN_REFUND') THEN + RAISE EXCEPTION 'caution : mécanisme inconnu' + USING ERRCODE = 'check_violation', CONSTRAINT = 'deposit_decision_mismatch'; + END IF; + -- US-702 : échéancier RECALCULÉ (08 BR-PAY-06 « Libération à heure fixe », « Mécanisme » ; + -- ADR-169 point 5) ; une durée absente ou illisible ⇒ refus (failMode BLOCK de 0009 / 0142) + FOREACH v_hours IN ARRAY ARRAY[ + core.payment_deposit_amount_param('auth_lead_h', v_hold.country_code), + core.payment_deposit_amount_param('release_delay_h', v_hold.country_code), + core.payment_deposit_amount_param('deposit_safety_h', v_hold.country_code), + core.payment_deposit_amount_param('deposit_reauth_lead_h', v_hold.country_code), + p_decision -> 'vHours'] LOOP + IF pg_catalog.jsonb_typeof(v_hours) IS DISTINCT FROM 'number' + OR (v_hours #>> '{}') !~ '^(0|[1-9][0-9]{0,5})$' THEN + RAISE EXCEPTION 'caution : durée de l''échéancier absente ou illisible' + USING ERRCODE = 'check_violation', CONSTRAINT = 'deposit_decision_mismatch'; + END IF; + END LOOP; + v_lead_h := (core.payment_deposit_amount_param('auth_lead_h', v_hold.country_code) + #>> '{}')::integer; + v_delay_h := (core.payment_deposit_amount_param('release_delay_h', v_hold.country_code) + #>> '{}')::integer; + v_safety_h := (core.payment_deposit_amount_param('deposit_safety_h', v_hold.country_code) + #>> '{}')::integer; + v_rlead_h := (core.payment_deposit_amount_param('deposit_reauth_lead_h', v_hold.country_code) + #>> '{}')::integer; + -- V (validité du PSP, US-225) : instantané de la décision, borné ; il ne fait qu'AVANCER la + -- décision (min), jamais la retarder au-delà de la libération + v_v_h := (p_decision #>> '{vHours}')::integer; + v_auth_at := GREATEST(v_now, v_t.scheduled_start - pg_catalog.make_interval(hours => v_lead_h)); + v_release_at := v_t.scheduled_end + pg_catalog.make_interval(hours => v_delay_h); + v_expiry := v_auth_at + pg_catalog.make_interval(hours => v_v_h); + IF v_mech = 'PREAUTH_SINGLE' THEN + v_decision := LEAST(v_release_at, v_expiry - pg_catalog.make_interval(hours => v_safety_h)); + v_reauth_due := NULL; + ELSIF v_mech = 'REAUTH' THEN + v_decision := v_release_at; + v_reauth_due := CASE + WHEN v_release_at <= v_expiry - pg_catalog.make_interval(hours => v_safety_h) THEN NULL + ELSE v_expiry - pg_catalog.make_interval(hours => v_rlead_h) END; + ELSE + v_decision := v_release_at; + v_reauth_due := NULL; + END IF; + END IF; + -- compte marchand de Kmino du pays : même choix que payment_deposit_checkout et T1 (0116) + SELECT a.provider INTO v_provider + FROM core.payment_psp_account AS a + WHERE a.country_code = v_hold.country_code AND a.status = 'ACTIVE' + AND (a.environment = 'LIVE' + OR COALESCE(platform.deployment_env(), 'production') IN ('test', 'development', 'staging')) + ORDER BY (a.environment = 'LIVE') DESC, a.provider, a.id + LIMIT 1; + -- contexte du voyageur (comme T1, 0116) le temps du verrou et de l'écriture, puis remis ; une + -- erreur annule l'instruction (et le contexte avec elle) + v_prev_kind := pg_catalog.current_setting('app.actor_kind', true); + v_prev_actor := pg_catalog.current_setting('app.actor_id', true); + PERFORM pg_catalog.set_config('app.actor_kind', 'GUEST', true); + PERFORM pg_catalog.set_config('app.actor_id', v_user::text, true); + -- verrou du hold (politique cmd_hold_upd : hold vivant du voyageur) : deux onglets ne figent + -- jamais deux décisions ; la décision est relue sous le verrou + PERFORM 1 FROM core.booking_checkout_hold AS h WHERE h.id = v_hold.id FOR UPDATE; + v_locked := FOUND; + IF NOT v_locked OR EXISTS (SELECT 1 FROM core.payment_deposit_hold AS d + WHERE d.hold_id = v_hold.id) THEN + PERFORM pg_catalog.set_config('app.actor_kind', COALESCE(v_prev_kind, ''), true); + PERFORM pg_catalog.set_config('app.actor_id', COALESCE(v_prev_actor, ''), true); + RETURN CASE WHEN v_locked THEN 'EXISTING' ELSE 'HOLD_NOT_PAYABLE' END; + END IF; + INSERT INTO core.payment_deposit_hold (hold_id, country_code, currency, provider, mechanism, + triggers, params_snapshot, amount_minor, + h_required_hours, v_hours_snapshot, auth_at, release_at, + decision_at, reauth_due_at, status) + VALUES (v_hold.id, v_hold.country_code, v_t.currency, + v_provider, + v_mech, v_triggers, p_decision -> 'paramsSnapshot', v_amount, + (p_decision ->> 'hRequiredHours')::integer, + CASE WHEN v_mech = 'NOT_REQUIRED' THEN (p_decision ->> 'vHours')::integer ELSE v_v_h END, + v_auth_at, v_release_at, v_decision, v_reauth_due, + CASE WHEN v_mech = 'NOT_REQUIRED' THEN NULL ELSE 'PLANNED' END); + PERFORM pg_catalog.set_config('app.actor_kind', COALESCE(v_prev_kind, ''), true); + PERFORM pg_catalog.set_config('app.actor_id', COALESCE(v_prev_actor, ''), true); + RETURN 'RECORDED'; +END +$fn$; +COMMENT ON FUNCTION core.payment_cmd_record_deposit_decision(bytea, uuid, jsonb) IS + 'Décision de la caution du hold du checkout du voyageur de la session, figée une fois avant le ' + 'paiement ; montant, pays, classe et rail (b) revérifiés ; fournisseur et échéancier recalculés ' + 'par la base (US-702). SECURITY DEFINER, EXECUTE app_api. US-701, US-702 (ADR-169, ADR-172).'; + +-- File des décisions échues (travailleur payment_command) : caution AUTORISÉE, hold converti en +-- trip ; décision échue à l'heure de la base, ou autorisation expirée (jamais de capture ensuite). +-- Rien d'autre n'est lu : une réclamation, une facture ou des frais d'assistance ne suspendent +-- jamais la libération (08 BR-PAY-06). Clé 08 E4 : trip, segment n° 1, opération de loyer. +CREATE FUNCTION core.payment_deposit_decision_due(p_limit integer) + RETURNS TABLE (deposit_id uuid, + trip_id uuid, + segment_id uuid, + tender_id uuid, + country_code text, + currency text, + provider text, + provider_reference text, + mechanism text, + amount_minor bigint, + decision_at timestamptz, + auth_expiry_at timestamptz, + reauth_seq integer, + now timestamptz) + LANGUAGE sql + STABLE + SECURITY DEFINER + SET search_path = pg_catalog, pg_temp +AS $fn$ + WITH t AS (SELECT platform.now() AS ts) + SELECT d.id, h.converted_trip_id, s.id, h.conversion_operation_id, d.country_code, d.currency, + d.provider, d.auth_provider_reference, d.mechanism, d.amount_minor, d.decision_at, + d.auth_expiry_at, d.reauth_seq, t.ts + FROM core.payment_deposit_hold AS d + CROSS JOIN t + JOIN core.booking_checkout_hold AS h ON h.id = d.hold_id AND h.status = 'CONVERTED' + JOIN core.booking_trip_segment AS s ON s.trip_id = h.converted_trip_id AND s.seq = 1 + WHERE app.actor_kind() = 'WORKER' AND app.worker_name() = 'payment_command' + AND d.status = 'AUTHORIZED' + AND (d.decision_at <= t.ts OR d.auth_expiry_at <= t.ts) + AND d.provider IS NOT NULL AND d.auth_provider_reference IS NOT NULL + ORDER BY d.decision_at, d.id + LIMIT GREATEST(LEAST(p_limit, 500), 0) +$fn$; +COMMENT ON FUNCTION core.payment_deposit_decision_due(integer) IS + 'Cautions autorisées dont la décision est échue ou l''autorisation expirée (platform.now()), sans ' + 'champ [C2]. SECURITY DEFINER, EXECUTE app_worker (payment_command). US-702 (ADR-172).'; + +-- Transition FINALE de la décision (16 PAY-011 « États ») et événement deposit.decision.executed +-- dans la même transaction ; rang attendu : un passage concurrent ou un rejeu tardif rend STALE +-- sans rien écrire. +CREATE FUNCTION core.payment_cmd_deposit_decide(p_deposit_id uuid, p_expected_seq integer, + p_status text, p_captured_minor bigint, + p_released_minor bigint) + RETURNS text + LANGUAGE plpgsql + VOLATILE + SECURITY DEFINER + SET search_path = pg_catalog, pg_temp +AS $fn$ +DECLARE + v_d record; + v_h record; + v_now timestamptz := platform.now(); + v_version integer; +BEGIN + IF app.actor_kind() IS DISTINCT FROM 'WORKER' + OR app.worker_name() IS DISTINCT FROM 'payment_command' THEN + RAISE EXCEPTION 'caution : décision réservée au travailleur payment_command' + USING ERRCODE = 'insufficient_privilege', CONSTRAINT = 'deposit_hold_command_forbidden'; + END IF; + SELECT d.id, d.hold_id, d.country_code, d.currency, d.mechanism, d.status, d.reauth_seq, + d.decision_at, d.auth_expiry_at + INTO v_d + FROM core.payment_deposit_hold AS d WHERE d.id = p_deposit_id FOR UPDATE; + IF v_d.id IS NULL OR v_d.reauth_seq IS DISTINCT FROM p_expected_seq + OR v_d.status IS DISTINCT FROM 'AUTHORIZED' THEN + RETURN 'STALE'; + END IF; + IF p_status IS NULL + OR p_status NOT IN ('PARTIALLY_CAPTURED', 'VOIDED', 'REFUNDED', 'EXPIRED') + -- 08 BR-PAY-06 : jamais avant l'heure de décision, sauf une autorisation déjà expirée + OR NOT (v_d.decision_at <= v_now + OR (p_status = 'EXPIRED' AND COALESCE(v_d.auth_expiry_at <= v_now, false))) + -- jamais de capture après l'expiration de l'autorisation + OR (p_status = 'PARTIALLY_CAPTURED' AND COALESCE(v_d.auth_expiry_at <= v_now, false)) + -- remboursement ⇔ rail « débit puis remboursement » (seul rail sans autorisation à annuler) + OR ((p_status = 'REFUNDED') <> (v_d.mechanism = 'CHARGE_THEN_REFUND')) THEN + RAISE EXCEPTION 'caution : décision finale refusée' + USING ERRCODE = 'object_not_in_prerequisite_state', CONSTRAINT = 'deposit_hold_guarded'; + END IF; + SELECT h.converted_trip_id INTO v_h FROM core.booking_checkout_hold AS h WHERE h.id = v_d.hold_id; + -- montants contrôlés par deposit_hold_final_shape (Σ = montant, capture seulement si partielle) + UPDATE core.payment_deposit_hold + SET status = p_status, captured_minor = p_captured_minor, released_minor = p_released_minor, + decision_executed_at = v_now, reauth_due_at = NULL + WHERE id = p_deposit_id + RETURNING row_version INTO v_version; + -- journal et avis au voyageur (NTF) : identifiants, état et montants seulement, jamais [C2] + INSERT INTO core.outbox_outbox_event + (type, schema_version, aggregate_type, aggregate_id, aggregate_version, country_code, + actor_user_id, actor_role, correlation_id, payload, partition_key) + VALUES ('deposit.decision.executed', 1, 'deposit_hold', p_deposit_id, v_version, + v_d.country_code, NULL, 'SYSTEM', pg_catalog.gen_random_uuid(), + pg_catalog.jsonb_build_object( + 'deposit_id', p_deposit_id, 'trip_id', v_h.converted_trip_id, 'status', p_status, + 'captured_minor', p_captured_minor::text, 'released_minor', p_released_minor::text, + 'currency', v_d.currency, 'decided_at', v_now), + COALESCE(v_h.converted_trip_id, p_deposit_id)::text); + RETURN 'APPLIED'; +END +$fn$; +COMMENT ON FUNCTION core.payment_cmd_deposit_decide(uuid, integer, text, bigint, bigint) IS + 'Transition finale de deposit_hold (PARTIALLY_CAPTURED, VOIDED, REFUNDED, EXPIRED) gardée par ' + 'le rang, l''heure de décision et l''expiration ; événement deposit.decision.executed. SECURITY ' + 'DEFINER, EXECUTE app_worker (payment_command). US-702 (ADR-172).'; + +-- droits posés par le propriétaire (un REVOKE de migrator, non propriétaire, serait sans effet) ; +-- la fonction remplacée garde ses droits de 0146 (EXECUTE app_api) +REVOKE ALL ON FUNCTION core.payment_deposit_decision_due(integer), + core.payment_cmd_deposit_decide(uuid, integer, text, bigint, bigint) + FROM PUBLIC; +GRANT EXECUTE ON FUNCTION core.payment_deposit_decision_due(integer), + core.payment_cmd_deposit_decide(uuid, integer, text, bigint, bigint) + TO app_worker; + +RESET ROLE; +REVOKE CREATE ON SCHEMA core FROM cmd_hold_owner; diff --git a/packages/db/personal-data-inventory.json b/packages/db/personal-data-inventory.json index c7686dfb..85cf9fc9 100644 --- a/packages/db/personal-data-inventory.json +++ b/packages/db/personal-data-inventory.json @@ -1640,7 +1640,10 @@ "decided_at": "C1", "created_at": "C1", "updated_at": "C1", - "row_version": "C1" + "row_version": "C1", + "captured_minor": "C1", + "released_minor": "C1", + "decision_executed_at": "C1" } }, "core.payment_payment_command": { diff --git a/packages/db/security-definer-allowlist.json b/packages/db/security-definer-allowlist.json index de6037db..5a38207d 100644 --- a/packages/db/security-definer-allowlist.json +++ b/packages/db/security-definer-allowlist.json @@ -2071,6 +2071,20 @@ "owner": "cmd_hold_owner", "execute": ["app_worker"], "story": "US-701" + }, + { + "signature": "core.payment_deposit_decision_due(integer)", + "family": "cmd_hold", + "owner": "cmd_hold_owner", + "execute": ["app_worker"], + "story": "US-702" + }, + { + "signature": "core.payment_cmd_deposit_decide(uuid,integer,text,bigint,bigint)", + "family": "cmd_hold", + "owner": "cmd_hold_owner", + "execute": ["app_worker"], + "story": "US-702" } ] } diff --git a/packages/db/src/errors.ts b/packages/db/src/errors.ts index 41f484de..3d46fc8b 100644 --- a/packages/db/src/errors.ts +++ b/packages/db/src/errors.ts @@ -398,6 +398,8 @@ export const CONSTRAINT_CODES: Readonly { expect(r).toMatchObject({ roles: 'cmd_hold_owner', cmd: 'a' }); continue; } + // décision de la caution (0148, US-702, ADR-172) : deposit.decision.executed seulement, + // acteur SYSTEM, travailleur payment_command + if (r.pol === 'outbox_outbox_event.cmd_hold_deposit_event_ins') { + expect(r).toMatchObject({ roles: 'cmd_hold_owner', cmd: 'a' }); + continue; + } // commandes de l'OTP (0066, US-104) : insertion de leurs seuls événements // iam.otp.requested et iam.phone.verified if (r.pol === 'outbox_outbox_event.iam_auth_otp_event_ins') { diff --git a/packages/db/test/l0/l0-us701-deposit-hold.test.ts b/packages/db/test/l0/l0-us701-deposit-hold.test.ts index d092ce5a..d2bd2583 100644 --- a/packages/db/test/l0/l0-us701-deposit-hold.test.ts +++ b/packages/db/test/l0/l0-us701-deposit-hold.test.ts @@ -72,8 +72,12 @@ const VECTORS: Readonly> = { }, }; -/** 300,00 de T57 (valeur de test du mécanisme) à l'exposant de la devise : USD 30 000, PYG 300. */ -const DEPOSIT: Readonly> = { USD: 30_000n, PYG: 300n }; +/** + * Montant de test de `deposit_amount[pays][LUXE]` (valeur de test du mécanisme, 08) : 300,00 de T57 + * en USD (30 000 centimes) ; 1 500 000 de T73 a en PYG (`AMT_PY` de l'oracle `check_t49plus.py`, + * US-702 : revues argent et qa d'US-701), jamais 300 mis à l'échelle. + */ +const DEPOSIT: Readonly> = { USD: 30_000n, PYG: 1_500_000n }; const depositOf = (cc: CountryCase): bigint => { const d = DEPOSIT[cc.currency]; if (d === undefined) throw new Error(`devise sans vecteur : ${cc.currency}`); diff --git a/packages/db/test/l0/l0-us702-deposit-decision.test.ts b/packages/db/test/l0/l0-us702-deposit-decision.test.ts new file mode 100644 index 00000000..5d7bed78 --- /dev/null +++ b/packages/db/test/l0/l0-us702-deposit-decision.test.ts @@ -0,0 +1,441 @@ +/** + * US-702 — décision de la caution (migration 0148, ADR-172) sous les rôles de PRODUCTION (assertion + * L0-05 en tête de chaque connexion : withRole), en USD (PA) et en PYG sans décimale (PY), + * transactions annulées : + * - `app_api` (voyageur de la session) : l'écriture de la décision RECALCULE le fournisseur et + * l'échéancier (revues argent et sécurité d'US-701) : une décision qui raccourcit la libération ou + * choisit un autre connecteur est écrite avec les valeurs de la base ; validité V absente ou + * illisible ⇒ refus (fail-closed) ; + * - `app_worker` (`payment_command`) : file des décisions échues à l'heure de la base, sans champ + * [C2] ; transition FINALE gardée (jamais avant l'heure de décision, jamais de capture après + * l'expiration, Σ capturé + libéré = montant, `REFUNDED` ⇔ rail b, rang attendu) et événement + * `deposit.decision.executed` dans la même transaction ; autre travailleur ⇒ rien lu, refus ; + * - `app_anon` : aucune des fonctions de la caution (0146, 0148) n'est exécutable. + * Attendus : 08 BR-PAY-06 (T57 : 300,00 de test, décision à fin + 70 h, libération fin + 72 h ; T73 : + * 1 500 000 PYG), 16 PAY-011 « États », 17 §3.2.7, la graine (durées 24 / 72 / 2 / 24 h de 0009 et + * 0142) — jamais le code testé. Personnes, devis et checkout par les VRAIES commandes (US-208, + * US-223) ; interrupteurs ouverts par la procédure à deux personnes dans la transaction annulée. + */ +import type pg from 'pg'; +import { describe, expect, it } from 'vitest'; +import { translateDbError } from '../../src/index.ts'; +import { withRole, withTestTransaction } from '../../src/testing/index.ts'; +import { COUNTRIES, uuid } from '../support/avl.ts'; +import type { CountryCase } from '../support/avl.ts'; +import { + approveDriver, + checkoutPerson, + checkoutQuote, + failure, + frozenQuote, + listedListing, + openSwitch, + protectionParams, + quoteDocs, + setClock, + taxGroups, +} from '../support/checkout.ts'; +import type { CheckoutVector, Person } from '../support/checkout.ts'; +import { payTx } from '../support/pay.ts'; + +type Tx = pg.ClientBase; +type Row = Record; + +const NOW = '2026-12-01T12:00:00.000Z'; +const START = '2026-12-10T15:00:00.000Z'; +const H = 3_600_000; + +/** Vecteurs du checkout d'US-223 (en-tête de l0-us223-checkout-payment) : devis de 3 jours. */ +const VECTORS: Readonly> = { + PA: { + daily: 4_000, + schedule: { tiers: [{ maxDays: null, rateBps: 0 }], minMinor: '0' }, + fee: 0, + taxes: { TRIP_PRICE: 840 }, + host: 9_000, + total: 15_840, + basicaPrice: '1/4', + protection: 3_000, + insurer: 2_100, + }, + PY: { + daily: 333_334, + schedule: null, + fee: 150_000, + taxes: { TRIP_PRICE: 100_000, TRIP_FEE: 15_000 }, + host: 750_001, + total: 1_415_002, + basicaPrice: '3/20', + protection: 150_000, + insurer: 105_000, + }, +}; + +/** 300,00 de T57 en USD (30 000 centimes) ; 1 500 000 de T73 a en PYG (`deposit_amount[PY][LUXE]`). */ +const DEPOSIT: Readonly> = { USD: 30_000n, PYG: 1_500_000n }; +const depositOf = (cc: CountryCase): bigint => { + const d = DEPOSIT[cc.currency]; + if (d === undefined) throw new Error(`devise sans vecteur : ${cc.currency}`); + return d; +}; + +const at = (iso: string, hours: number): string => + new Date(Date.parse(iso) + hours * H).toISOString(); +const iso = (v: unknown): string | null => (v === null ? null : (v as Date).toISOString()); + +function scenario(cc: CountryCase) { + return (fn: (tx: Tx, groups: Map) => Promise) => + withRole('app_api', (client) => + withTestTransaction(client, { virtualNow: NOW }, async (tx) => { + await openSwitch(tx, 'p2p_private_hosts_enabled', cc.country); + await openSwitch(tx, 'insurer_contract_active', cc.country); + const v = VECTORS[cc.country]!; + if (v.schedule !== null) { + await tx.query('SELECT test_fixture.us704_set_trip_fee_schedule($1, $2::jsonb)', [ + cc.country, + JSON.stringify(v.schedule), + ]); + } + await protectionParams(tx, cc.country, v); + await tx.query('SELECT test_fixture.us024_psp_account($1)', [cc.country]); + await tx.query("SELECT test_fixture.us225_param_version('deposit_amount', $1, $2::jsonb)", [ + cc.country, + JSON.stringify({ LUXE: depositOf(cc).toString() }), + ]); + await fn(tx, await taxGroups(tx, cc)); + }), + ); +} + +async function luxeHold( + tx: Tx, + cc: CountryCase, + groups: Map, +): Promise<{ + p: Person; + hold: string; +}> { + const p = await checkoutPerson(tx, cc.country); + await approveDriver(tx, p, cc.country, { birth: '1990-01-01', licenseExpiry: '2030-12-31' }); + const v = VECTORS[cc.country]!; + const l = await listedListing(tx, cc, v.daily); + await tx.query('SELECT test_fixture.us108_set_value_class($1, $2)', [l.vehicleId, 'LUXE']); + const d = quoteDocs(cc, v, groups, Date.parse(START), Date.parse(NOW)); + const quoteId = await frozenQuote(tx, p, l.listingId, d); + const r = await checkoutQuote(tx, p, quoteId); + expect(r.outcome).toBe('DONE'); + return { p, hold: r.hold_id! }; +} + +/** Décision HOSTILE : autre connecteur, libération et décision ramenées au début du trip. */ +const hostile = (amount: bigint, mechanism: string, vHours: number) => ({ + mechanism, + triggers: ['CLASS'], + paramsSnapshot: { version: 1, riskEvaluated: false, youngestDriverAge: null }, + amountMinor: amount.toString(), + provider: 'EVIL_PSP', + hRequiredHours: 168, + vHours, + authAt: at(START, -1), + releaseAt: at(START, 0), + decisionAt: at(START, 0), + reauthDueAt: null, +}); + +const schedule = async (tx: Tx, hold: string): Promise => + (await tx.query('SELECT * FROM test_fixture.us702_deposit_schedule($1)', [hold])).rows[0]!; + +describe.each(COUNTRIES)( + 'US-702 — échéancier recalculé par la base ($country, $currency)', + (cc) => { + const run = scenario(cc); + const record = 'SELECT core.payment_cmd_record_deposit_decision($1, $2, $3::jsonb) AS r'; + + it('T57 (pré-autorisation unique, V = 168 h) : fournisseur et échéancier de l’API ignorés ; auth = début − 24 h, libération = fin + 72 h, décision = fin + 70 h', async () => { + await run(async (tx, groups) => { + const { p, hold } = await luxeHold(tx, cc, groups); + const r = await tx.query<{ r: string }>(record, [ + p.hash, + hold, + JSON.stringify(hostile(depositOf(cc), 'PREAUTH_SINGLE', 168)), + ]); + expect(r.rows[0]!.r).toBe('RECORDED'); + const s = await schedule(tx, hold); + expect(s['provider']).toBe('FAKE'); + expect(s['v_hours_snapshot']).toBe(168); + // devis de 3 jours : fin = début + 72 h + expect(iso(s['auth_at'])).toBe(at(START, -24)); + expect(iso(s['release_at'])).toBe(at(START, 72 + 72)); + expect(iso(s['decision_at'])).toBe(at(START, 72 + 70)); + expect(s['reauth_due_at']).toBeNull(); + }); + }); + + it('rail (a) (V = 48 h) : ré-autorisation à expiration − 24 h, décision à la libération (08 BR-PAY-06 « Mécanisme »)', async () => { + await run(async (tx, groups) => { + const { p, hold } = await luxeHold(tx, cc, groups); + const r = await tx.query<{ r: string }>(record, [ + p.hash, + hold, + JSON.stringify(hostile(depositOf(cc), 'REAUTH', 48)), + ]); + expect(r.rows[0]!.r).toBe('RECORDED'); + const s = await schedule(tx, hold); + // expiration prévue = auth + 48 h = début + 24 h ; ré-autorisation 24 h avant + expect(iso(s['reauth_due_at'])).toBe(at(START, 0)); + expect(iso(s['decision_at'])).toBe(at(START, 144)); + expect(iso(s['release_at'])).toBe(at(START, 144)); + }); + }); + + it('fail-closed : V absent ou illisible ⇒ refus, rien n’est écrit (les durées de 08 sont typées par la garde de 0008)', async () => { + await run(async (tx, groups) => { + const { p, hold } = await luxeHold(tx, cc, groups); + for (const vHours of [null, '168', 1.5]) { + const bad = { ...hostile(depositOf(cc), 'PREAUTH_SINGLE', 168), vHours }; + const e = await failure(tx, record, [p.hash, hold, JSON.stringify(bad)]); + expect(e, String(vHours)).toMatchObject({ + code: '23514', + constraint: 'deposit_decision_mismatch', + }); + expect(translateDbError(e ?? {}).code).toBe('INVARIANT_VIOLATION'); + } + expect(await schedule(tx, hold)).toBeUndefined(); + }); + }); + }, +); + +describe.each(COUNTRIES)('US-702 — décision à l’heure de décision ($country, $currency)', (cc) => { + /** T57 : trip de 72 h, autorisé à début − 24 h (expiration fin + 72 h), décision fin + 70 h. */ + const start = '2031-08-01T10:00:00.000Z'; + const end = at(start, 72); + const expiry = at(end, 72); + const release = at(end, 72); + const decision = at(end, 70); + const seed = async (tx: Tx, mechanism = 'PREAUTH_SINGLE') => + ( + await tx.query( + `SELECT * FROM test_fixture.us702_converted_deposit($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, + [ + cc.country, + cc.currency, + cc.timezone, + start, + end, + depositOf(cc).toString(), + mechanism, + mechanism === 'CHARGE_THEN_REFUND' ? null : expiry, + release, + mechanism === 'CHARGE_THEN_REFUND' ? release : decision, + `fake-${uuid()}`, + ], + ) + ).rows[0]!; + const dueOf = async (tx: Tx, id: unknown) => + (await tx.query('SELECT * FROM core.payment_deposit_decision_due(500)')).rows.filter( + (r) => r['deposit_id'] === id, + ); + const decideSql = 'SELECT core.payment_cmd_deposit_decide($1, $2, $3, $4, $5) AS r'; + const decide = async ( + tx: Tx, + id: unknown, + status: string, + captured: bigint, + released: bigint, + seq = 0, + ) => + ( + await tx.query<{ r: string }>(decideSql, [ + id, + seq, + status, + captured.toString(), + released.toString(), + ]) + ).rows[0]!.r; + + it('critère 2 : échue seulement à fin + 70 h (heure de la base), sans champ [C2] ; VOID entier ⇒ VOIDED, événement deposit.decision.executed ; rejeu ⇒ STALE', async () => { + await withRole('app_worker', (client) => + payTx(client, { worker: 'payment_command', virtualNow: at(end, 69) }, async (tx) => { + const s = await seed(tx); + const amount = depositOf(cc); + expect(await dueOf(tx, s['deposit_id'])).toEqual([]); + // jamais avant l'heure de décision + expect( + await failure(tx, decideSql, [s['deposit_id'], 0, 'VOIDED', '0', amount.toString()]), + ).toMatchObject({ code: '55000', constraint: 'deposit_hold_guarded' }); + await setClock(tx, decision); + const due = await dueOf(tx, s['deposit_id']); + expect(due).toHaveLength(1); + expect(due[0]).toMatchObject({ + trip_id: s['trip_id'], + segment_id: s['segment_id'], + tender_id: s['tender_id'], + country_code: cc.country, + currency: cc.currency, + provider: 'FAKE', + mechanism: 'PREAUTH_SINGLE', + amount_minor: amount.toString(), + reauth_seq: 0, + }); + expect(iso(due[0]!['decision_at'])).toBe(decision); + expect(Object.keys(due[0]!)).not.toContain('triggers'); + expect(Object.keys(due[0]!)).not.toContain('params_snapshot'); + expect(await decide(tx, s['deposit_id'], 'VOIDED', 0n, amount)).toBe('APPLIED'); + expect(await dueOf(tx, s['deposit_id'])).toEqual([]); + expect(await decide(tx, s['deposit_id'], 'VOIDED', 0n, amount)).toBe('STALE'); + // journal : un événement, acteur SYSTEM, identifiants et montants seulement + await tx.query(`SELECT pg_catalog.set_config('app.worker_name', 'outbox_relay', true)`); + const ev = await tx.query( + `SELECT type, actor_role, actor_user_id, country_code, payload + FROM core.outbox_outbox_event WHERE aggregate_id = $1`, + [s['deposit_id']], + ); + expect(ev.rows).toHaveLength(1); + expect(ev.rows[0]).toMatchObject({ + type: 'deposit.decision.executed', + actor_role: 'SYSTEM', + actor_user_id: null, + country_code: cc.country, + }); + const payload = ev.rows[0]!['payload'] as Record; + expect(payload).toMatchObject({ + deposit_id: s['deposit_id'], + trip_id: s['trip_id'], + status: 'VOIDED', + captured_minor: '0', + released_minor: amount.toString(), + currency: cc.currency, + }); + expect(Object.keys(payload).sort()).toEqual([ + 'captured_minor', + 'currency', + 'decided_at', + 'deposit_id', + 'released_minor', + 'status', + 'trip_id', + ]); + }), + ); + }); + + it('forme finale : Σ ≠ montant, capture dans VOIDED, aucune capture dans PARTIALLY_CAPTURED ⇒ refus ; capture partielle valide ⇒ APPLIED', async () => { + await withRole('app_worker', (client) => + payTx(client, { worker: 'payment_command', virtualNow: decision }, async (tx) => { + const s = await seed(tx); + const amount = depositOf(cc); + const one = amount / 300n; // un « 1,00 » de la devise (300,00 ⇒ 1,00 ; 1 500 000 ⇒ 5 000) + for (const [status, captured, released] of [ + ['PARTIALLY_CAPTURED', one, amount], + ['VOIDED', one, amount - one], + ['PARTIALLY_CAPTURED', 0n, amount], + ] as const) { + expect( + await failure(tx, decideSql, [ + s['deposit_id'], + 0, + status, + captured.toString(), + released.toString(), + ]), + `${status} ${captured} ${released}`, + ).toMatchObject({ code: '23514', constraint: 'deposit_hold_final_shape' }); + } + // 16 PAY-011 : REFUNDED réservé au rail « débit puis remboursement » + expect( + await failure(tx, decideSql, [s['deposit_id'], 0, 'REFUNDED', '0', amount.toString()]), + ).toMatchObject({ code: '55000', constraint: 'deposit_hold_guarded' }); + expect(await decide(tx, s['deposit_id'], 'PARTIALLY_CAPTURED', one, amount - one)).toBe( + 'APPLIED', + ); + }), + ); + }); + + it('08 BR-PAY-06 : après l’expiration, aucune capture ; EXPIRED (libération entière) seulement', async () => { + await withRole('app_worker', (client) => + payTx(client, { worker: 'payment_command', virtualNow: expiry }, async (tx) => { + const s = await seed(tx); + const amount = depositOf(cc); + const one = amount / 300n; + expect(await dueOf(tx, s['deposit_id'])).toHaveLength(1); + expect( + await failure(tx, decideSql, [ + s['deposit_id'], + 0, + 'PARTIALLY_CAPTURED', + one.toString(), + (amount - one).toString(), + ]), + ).toMatchObject({ code: '55000', constraint: 'deposit_hold_guarded' }); + expect(await decide(tx, s['deposit_id'], 'EXPIRED', 0n, amount)).toBe('APPLIED'); + }), + ); + }); + + it('rail (b) : REFUNDED (remboursement entier) seulement ; rang périmé ⇒ STALE', async () => { + await withRole('app_worker', (client) => + payTx(client, { worker: 'payment_command', virtualNow: release }, async (tx) => { + const s = await seed(tx, 'CHARGE_THEN_REFUND'); + const amount = depositOf(cc); + expect( + await failure(tx, decideSql, [s['deposit_id'], 0, 'VOIDED', '0', amount.toString()]), + ).toMatchObject({ code: '55000', constraint: 'deposit_hold_guarded' }); + expect(await decide(tx, s['deposit_id'], 'REFUNDED', 0n, amount, 1)).toBe('STALE'); + expect(await decide(tx, s['deposit_id'], 'REFUNDED', 0n, amount)).toBe('APPLIED'); + }), + ); + }); + + it('autre travailleur : file vide, décision refusée (42501)', async () => { + await withRole('app_worker', (client) => + payTx(client, { worker: 'payment_command', virtualNow: decision }, async (tx) => { + const s = await seed(tx); + await tx.query(`SELECT pg_catalog.set_config('app.worker_name', 'settlement', true)`); + expect(await dueOf(tx, s['deposit_id'])).toEqual([]); + const e = await failure(tx, decideSql, [ + s['deposit_id'], + 0, + 'VOIDED', + '0', + depositOf(cc).toString(), + ]); + expect(e).toMatchObject({ code: '42501', constraint: 'deposit_hold_command_forbidden' }); + expect(translateDbError(e ?? {}).code).toBe('FORBIDDEN'); + }), + ); + }); +}); + +describe('US-701 / US-702 — droits ciblés des fonctions de la caution', () => { + const API = [ + 'core.payment_deposit_checkout(bytea, uuid)', + 'core.payment_cmd_record_deposit_decision(bytea, uuid, jsonb)', + ]; + const WORKER = [ + 'core.payment_deposit_reauth_due(integer)', + 'core.payment_cmd_deposit_transition(uuid, text, integer, timestamptz, timestamptz, timestamptz, text)', + 'core.payment_deposit_decision_due(integer)', + 'core.payment_cmd_deposit_decide(uuid, integer, text, bigint, bigint)', + ]; + + it('has_function_privilege : app_anon n’exécute aucune fonction de la caution ; app_api seulement celles du voyageur, app_worker seulement celles du travailleur', async () => { + await withRole('app_worker', async (client) => { + const { rows } = await client.query<{ fn: string; role: string; x: boolean }>( + `SELECT f AS fn, r AS role, pg_catalog.has_function_privilege(r, f, 'EXECUTE') AS x + FROM unnest($1::text[]) AS f, unnest(ARRAY['app_anon', 'app_api', 'app_worker']) AS r + ORDER BY 1, 2`, + [[...API, ...WORKER]], + ); + for (const r of rows) { + const expected = + (r.role === 'app_api' && API.includes(r.fn)) || + (r.role === 'app_worker' && WORKER.includes(r.fn)); + expect(r.x, `${r.role} ${r.fn}`).toBe(expected); + } + expect(rows).toHaveLength((API.length + WORKER.length) * 3); + }); + }); +}); diff --git a/packages/i18n/src/catalogs/en.ts b/packages/i18n/src/catalogs/en.ts index f73b6f24..2fbb369b 100644 --- a/packages/i18n/src/catalogs/en.ts +++ b/packages/i18n/src/catalogs/en.ts @@ -1321,6 +1321,16 @@ export const EN_MESSAGES = { "Hi {first_name}. You accepted the request {booking_ref}, but we could not confirm the guest's payment and the booking was not made. The dates are free again in your {brand} calendar. Do not hand over the car for this request.", 'ntf.bookingRequestFailedHost.sms.body': '{brand}: the request {booking_ref} you accepted was not confirmed. Dates released. Do not hand over the car.', + 'ntf.depositReleased.email.subject': 'We released your {amount} deposit', + 'ntf.depositReleased.email.body': + 'Hi {first_name}. We released your {amount} security deposit for trip {booking_ref}. Your bank may take a few days to show it.', + 'ntf.depositReleased.sms.body': + '{brand}: we released your {amount} deposit for trip {booking_ref}. Your bank may take a few days to show it.', + 'ntf.depositPartiallyCaptured.email.subject': 'Your deposit: {captured} charged, rest released', + 'ntf.depositPartiallyCaptured.email.body': + 'Hi {first_name}. From the security deposit for trip {booking_ref}, we charged {captured} for the extra fees we told you about and released {amount}. Your bank may take a few days to show it.', + 'ntf.depositPartiallyCaptured.sms.body': + '{brand}: from your deposit for trip {booking_ref}, we charged {captured} in fees already notified and released {amount}.', 'backoffice.catalog.open': 'Open the request', 'backoffice.catalog.heading': 'Catalog addition request', 'backoffice.catalog.requested': 'What the host entered', diff --git a/packages/i18n/src/catalogs/es.ts b/packages/i18n/src/catalogs/es.ts index 0d2d4cab..93739d98 100644 --- a/packages/i18n/src/catalogs/es.ts +++ b/packages/i18n/src/catalogs/es.ts @@ -1359,6 +1359,16 @@ export const ES_MESSAGES = { 'Hola, {first_name}. Aceptaste la solicitud {booking_ref}, pero no pudimos confirmar el cobro al viajero y la reserva no se hizo. Las fechas vuelven a estar libres en tu calendario de {brand}. No entregues el auto para esta solicitud.', 'ntf.bookingRequestFailedHost.sms.body': '{brand}: la solicitud {booking_ref} que aceptaste no se confirmó. Fechas liberadas. No entregues el auto.', + 'ntf.depositReleased.email.subject': 'Liberamos tu depósito de {amount}', + 'ntf.depositReleased.email.body': + 'Hola, {first_name}. Liberamos tu depósito de garantía de {amount} del viaje {booking_ref}. Tu banco puede tardar unos días en mostrarlo.', + 'ntf.depositReleased.sms.body': + '{brand}: liberamos tu depósito de {amount} del viaje {booking_ref}. Tu banco puede tardar unos días en mostrarlo.', + 'ntf.depositPartiallyCaptured.email.subject': 'Tu depósito: {captured} cobrado, resto liberado', + 'ntf.depositPartiallyCaptured.email.body': + 'Hola, {first_name}. Del depósito de garantía del viaje {booking_ref}, cobramos {captured} por los cargos adicionales que te avisamos y liberamos {amount}. Tu banco puede tardar unos días en mostrarlo.', + 'ntf.depositPartiallyCaptured.sms.body': + '{brand}: de tu depósito del viaje {booking_ref}, cobramos {captured} de cargos ya avisados y liberamos {amount}.', 'backoffice.catalog.open': 'Abrir la solicitud', 'backoffice.catalog.heading': 'Solicitud de alta al catálogo', 'backoffice.catalog.requested': 'Lo que escribió el anfitrión', diff --git a/packages/i18n/src/catalogs/fr.ts b/packages/i18n/src/catalogs/fr.ts index 56f90281..52d6482d 100644 --- a/packages/i18n/src/catalogs/fr.ts +++ b/packages/i18n/src/catalogs/fr.ts @@ -1391,6 +1391,16 @@ export const FR_MESSAGES = { 'Bonjour {first_name}. Tu as accepté la demande {booking_ref}, mais nous n’avons pas pu confirmer le paiement du voyageur et la réservation ne s’est pas faite. Les dates sont de nouveau libres dans ton calendrier {brand}. Ne remets pas la voiture pour cette demande.', 'ntf.bookingRequestFailedHost.sms.body': '{brand} : la demande {booking_ref} que tu as acceptée n’a pas été confirmée. Dates libérées. Ne remets pas la voiture.', + 'ntf.depositReleased.email.subject': 'Ton dépôt de {amount} est libéré', + 'ntf.depositReleased.email.body': + 'Bonjour {first_name}. Nous avons libéré ton dépôt de garantie de {amount} du voyage {booking_ref}. Ta banque peut mettre quelques jours à l’afficher.', + 'ntf.depositReleased.sms.body': + '{brand} : ton dépôt de {amount} du voyage {booking_ref} est libéré. Ta banque peut mettre quelques jours à l’afficher.', + 'ntf.depositPartiallyCaptured.email.subject': 'Ton dépôt : {captured} prélevé, le reste libéré', + 'ntf.depositPartiallyCaptured.email.body': + 'Bonjour {first_name}. Sur le dépôt de garantie du voyage {booking_ref}, nous avons prélevé {captured} pour les frais annexes qui t’ont été annoncés et libéré {amount}. Ta banque peut mettre quelques jours à l’afficher.', + 'ntf.depositPartiallyCaptured.sms.body': + '{brand} : sur ton dépôt du voyage {booking_ref}, {captured} de frais annoncés prélevés, {amount} libérés.', 'backoffice.catalog.open': 'Ouvrir la demande', 'backoffice.catalog.heading': 'Demande d’ajout au catalogue', 'backoffice.catalog.requested': 'Saisie de l’hôte', diff --git a/packages/i18n/src/catalogs/index.ts b/packages/i18n/src/catalogs/index.ts index ffcb5774..020747dd 100644 --- a/packages/i18n/src/catalogs/index.ts +++ b/packages/i18n/src/catalogs/index.ts @@ -270,8 +270,11 @@ export type { Catalog, Message, PluralCategory, PluralMessage, VersionedCatalog `common.payment.depositUnavailable` (réponse 409 `DEPOSIT_RAIL_UNAVAILABLE` / `DEPOSIT_PARAM_MISSING` de `POST /checkout/holds/{id}/payment`, avec une sortie : autres dates, autre voiture). + Version 87 (la 86 est celle d’US-212b) : décision de la caution (US-702, ADR-172) : avis au + voyageur `ntf.depositReleased.*` (caution libérée en entier) et `ntf.depositPartiallyCaptured.*` + (frais annexes annoncés capturés, reste libéré), sur `deposit.decision.executed`. */ -export const CATALOG_VERSION = 85; +export const CATALOG_VERSION = 87; /** Catalogues de base par langue ; la langue d'un profil de locale choisit le sien. */ export const CATALOGS: Readonly>> = { diff --git a/packages/i18n/src/catalogs/pt.ts b/packages/i18n/src/catalogs/pt.ts index 3dab5fda..32f9e019 100644 --- a/packages/i18n/src/catalogs/pt.ts +++ b/packages/i18n/src/catalogs/pt.ts @@ -1360,6 +1360,16 @@ export const PT_MESSAGES = { 'Olá, {first_name}. Você aceitou o pedido {booking_ref}, mas não conseguimos confirmar o pagamento do viajante e a reserva não foi feita. As datas estão livres de novo no seu calendário da {brand}. Não entregue o carro para este pedido.', 'ntf.bookingRequestFailedHost.sms.body': '{brand}: o pedido {booking_ref} que você aceitou não foi confirmado. Datas liberadas. Não entregue o carro.', + 'ntf.depositReleased.email.subject': 'Sua caução de {amount} foi liberada', + 'ntf.depositReleased.email.body': + 'Olá, {first_name}. Liberamos a sua caução de {amount} da viagem {booking_ref}. O banco pode levar alguns dias para mostrar.', + 'ntf.depositReleased.sms.body': + '{brand}: liberamos a sua caução de {amount} da viagem {booking_ref}. O banco pode levar alguns dias para mostrar.', + 'ntf.depositPartiallyCaptured.email.subject': 'Sua caução: {captured} cobrado, o resto liberado', + 'ntf.depositPartiallyCaptured.email.body': + 'Olá, {first_name}. Da caução da viagem {booking_ref}, cobramos {captured} pelas taxas extras já avisadas e liberamos {amount}. O banco pode levar alguns dias para mostrar.', + 'ntf.depositPartiallyCaptured.sms.body': + '{brand}: da sua caução da viagem {booking_ref}, cobramos {captured} de taxas já avisadas e liberamos {amount}.', 'backoffice.catalog.open': 'Abrir o pedido', 'backoffice.catalog.heading': 'Pedido de inclusão no catálogo', 'backoffice.catalog.requested': 'O que o anfitrião digitou', From 450db2f533f1313d45228e1d89f388af4521f3cf Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 19:29:34 -0300 Subject: [PATCH 2/5] =?UTF-8?q?test(US-702):=20d=C3=A9cision=20de=20bout?= =?UTF-8?q?=20en=20bout=20sur=20base=20r=C3=A9elle=20avec=20capacit=C3=A9s?= =?UTF-8?q?=20pos=C3=A9es=20et=20autorisation=20du=20FAKE=20(VOID=20entier?= =?UTF-8?q?)?= 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 --- .../testing/deposit-timer-store.int.test.ts | 52 ++++++++++++++++--- 1 file changed, 44 insertions(+), 8 deletions(-) diff --git a/apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts b/apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts index a6364b83..75e44d40 100644 --- a/apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts +++ b/apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts @@ -7,8 +7,8 @@ * `::timestamptz`, file des ré-autorisations échues et transition `REAUTHORIZED` (rang attendu) ; * - `PgDepositDecisionStore` (0148) : file des décisions échues (montant en `bigint`, rail, * expiration) et transition finale ; `DepositDecisionTimer` de bout en bout avec la configuration - * lue en base (capacités du FAKE inconnues en base ⇒ aucune annulation possible : l'autorisation - * est laissée expirer, aucun appel au PSP, 08 E3 repli 4). + * et les capacités lues en base (posées dans la transaction) et le PSP simulé : VOID de la caution + * entière à fin + 70 h, aucune capture (19 US-702 critère 2). * Attendus : 08 BR-PAY-06 (T57 : décision à fin + 70 h ; T59 en rail a), T73 (1 500 000 PYG), * `currencies.json` (lu comme donnée) — jamais le code testé. */ @@ -27,6 +27,8 @@ import { PgDepositTimerStore } from '../internal/deposit-timer.js'; import { PgDepositRailConfigReader } from '../internal/pg-deposit-config.js'; import { countryCases } from '../../../../test/support/countries.js'; import { fakeStack } from './fake-stack.js'; +import { DepositRailExecutor } from '../internal/deposit-executor.js'; +import { createCurrencyRegistry } from '@rueda/money'; const H = 3_600_000; const read = (file: string): unknown => @@ -121,11 +123,44 @@ describe.each(countryCases())( }); }); - it('PgDepositDecisionStore et DepositDecisionTimer : décision échue à fin + 70 h lue (montant bigint, rail, expiration), configuration relue en base, autorisation laissée expirer sans appel au PSP, puis STALE', async () => { + it('PgDepositDecisionStore et DepositDecisionTimer : décision échue à fin + 70 h lue (montant bigint, rail, expiration), configuration relue en base, VOID de la caution entière, puis STALE', async () => { // T57 : trip de 72 h, expiration fin + 72 h, décision fin + 70 h const start = '2031-09-01T10:00:00.000Z'; const end = at(start, 72); await workerTx(at(end, 69), async (tx) => { + // pose sur le FAKE (lot C : à `auth_at`) : la référence du PSP est celle de la caution + const stack = fakeStack(); + const order = await new DepositRailExecutor(stack.provider).place( + { + depositId: randomUUID(), + tripReference: randomUUID(), + tripId: randomUUID(), + segmentId: randomUUID(), + tenderId: randomUUID(), + currency: createCurrencyRegistry([{ code: c.currency, exponent: exponent ?? 0 }]).get( + c.currency, + ), + }, + { + mechanism: 'PREAUTH_SINGLE', + amountMinor: amount, + fundsHoldingEnabled: false, + attemptNo: 1, + }, + ); + stack.psp.customerPays(order.providerReference); + // capacités du FAKE pour la carte, posées dans la transaction annulée (inconnue = non) + for (const name of [ + 'SUPPORTS_PREAUTH', + 'SUPPORTS_VOID', + 'SUPPORTS_PARTIAL_CAPTURE', + 'SUPPORTS_MIT', + ]) { + await tx.query( + `SELECT test_fixture.us024_set_capability('FAKE', $1, '*', $2, 'true'::jsonb, 'VALIDATED_SANDBOX', $3::timestamptz)`, + [c.country, name, at(end, 69)], + ); + } const seeded = await tx.query<{ deposit_id: string; trip_id: string }>( `SELECT * FROM test_fixture.us702_converted_deposit($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, [ @@ -139,7 +174,7 @@ describe.each(countryCases())( at(end, 72), at(end, 72), at(end, 70), - `fake-${randomUUID()}`, + order.providerReference, ], ); const id = seeded.rows[0]!.deposit_id; @@ -160,7 +195,6 @@ describe.each(countryCases())( }); expect(due?.decisionAt.toISOString()).toBe(at(end, 70)); expect(due?.authExpiryAt?.toISOString()).toBe(at(end, 72)); - const stack = fakeStack(); const decided: string[] = []; const timer = new DepositDecisionTimer({ config: (country, provider) => new PgDepositRailConfigReader(tx).read(country, provider), @@ -175,10 +209,12 @@ describe.each(countryCases())( alerts: { send: () => Promise.resolve() }, connectors: { get: (name) => (name === 'FAKE' ? stack.provider : undefined) }, }); - expect(await timer.process(due!)).toBe('EXPIRED'); - expect(decided).toEqual([`EXPIRED:0:${amount}:APPLIED`]); - expect(stack.psp.calls('VOID')).toBe(0); + expect(await timer.process(due!)).toBe('VOIDED'); + // critère 2 : VOID de la caution entière, rien de capturé, aucun mouvement de fonds + expect(decided).toEqual([`VOIDED:0:${amount}:APPLIED`]); + expect(stack.psp.calls('VOID')).toBe(1); expect(stack.psp.calls('CAPTURE')).toBe(0); + expect(stack.psp.movements()).toEqual([]); expect(await mine()).toEqual([]); expect( await store.decide(id, 0, { status: 'VOIDED', capturedMinor: 0n, releasedMinor: amount }), From 305b4338dfeab03d6c21bd8258e6317f50f54d45 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 19:54:30 -0300 Subject: [PATCH 3/5] =?UTF-8?q?docs(US-702):=20schema.md=20recopi=C3=A9=20?= =?UTF-8?q?de=20la=20sortie=20du=20job=20=C2=AB=20base=20de=20donn=C3=A9es?= =?UTF-8?q?=20=C2=BB=20(migration=200148)?= 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 | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/docs/architecture/schema.md b/docs/architecture/schema.md index 180f4d92..68560332 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 -- 148 migrations ; 129 tables ; 3 vues ; 728 politiques RLS ; 295 fonctions `SECURITY DEFINER` ; 253 autres fonctions. +- 149 migrations ; 129 tables ; 3 vues ; 729 politiques RLS ; 297 fonctions `SECURITY DEFINER` ; 253 autres fonctions. - Tables sans RLS `ENABLE` + `FORCE` : aucune. - Rôles applicatifs avec `SUPERUSER` ou `BYPASSRLS` : aucun. @@ -163,6 +163,7 @@ Lu dans le catalogue (`pg_catalog`) d'une base jetable du banc, après les seule | `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_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_payment_deposit_decision` | PAY : décision de la caution à l'heure de décision (libération automatique, transitions | ## Rôles @@ -2626,7 +2627,7 @@ Politiques RLS : - `cmd_golive_sel` (SELECT, PERMISSIVE, cmd_golive_owner) USING `((go_live_request_id IS NOT NULL) OR (key IN ( SELECT d.key FROM core.config_param_definition d WHERE d.go_live_switch)))` - `cmd_hold_cancel_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['free_cancel_lead'::text, 'last_minute_threshold'::text, 'host_penalty'::text, 'platform_funded_host_compensation'::text]))` - `cmd_hold_contract_param_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = 'grace_minutes'::text)` -- `cmd_hold_deposit_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['deposit_always_required'::text, 'deposit_trigger_classes'::text, 'deposit_amount'::text, 'funds_holding_enabled'::text]))` +- `cmd_hold_deposit_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['deposit_always_required'::text, 'deposit_trigger_classes'::text, 'deposit_amount'::text, 'funds_holding_enabled'::text, 'auth_lead_h'::text, 'release_delay_h'::text, 'deposit_safety_h'::text, 'deposit_reauth_lead_h'::text]))` - `cmd_hold_meeting_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = 'review_window_days'::text)` - `cmd_hold_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['buffer_minutes'::text, 'hold_ttl_minutes'::text, 'hold_max_total_minutes'::text, 'max_active_holds_per_guest'::text, 'hold_creations_per_guest_vehicle_hour'::text, 'sweep_grace_s'::text, 'flagged_booking_payment_order'::text, 'review_hold_minutes'::text, 'payment_in_flight_margin_s'::text, 'psp_call_timeout_s'::text, 'conversion_start_tolerance_minutes'::text, 'payment_attempts_per_hold'::text, 'max_trip_days'::text, 'advance_notice_minutes'::text, 'no_show_grace_minutes'::text, 'overdue_detection_minutes'::text, 'p2p_private_hosts_enabled'::text, 'insurer_contract_active'::text]))` - `cmd_hold_request_param_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['booking_request_mode_enabled'::text, 'booking_request_expiry_hours'::text]))` @@ -4146,6 +4147,7 @@ Politiques RLS : - `catalog_cmd_event_insert` (INSERT, PERMISSIVE, catalog_cmd_owner) WITH CHECK `((((type = 'catalog.addition_request.resolved'::text) AND (aggregate_type = 'catalog_addition_request'::text)) OR ((type = 'catalog.vehicle.released'::text) AND (aggregate_type = 'catalog_vehicle'::text))) AND (actor_role = ANY (ARRAY['OPS_AGENT'::text, 'ADMIN'::text])) AND (actor_user_id IS NOT NULL))` - `cmd_golive_event_ins` (INSERT, PERMISSIVE, cmd_golive_owner) WITH CHECK `((type = 'config.param.changed'::text) AND (aggregate_type = 'param_value'::text) AND (actor_role = 'SUPERADMIN'::text) AND (actor_user_id IS NOT NULL))` - `cmd_hold_contract_event_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((aggregate_type = 'contract_document'::text) AND (((type = 'contract.document.generated'::text) AND (actor_role = 'SYSTEM'::text) AND (actor_user_id IS NULL)) OR ((type = 'contract.document.signed'::text) AND (actor_role = 'GUEST'::text) AND (actor_user_id IS NOT NULL))))` +- `cmd_hold_deposit_event_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((aggregate_type = 'deposit_hold'::text) AND (type = 'deposit.decision.executed'::text) AND (actor_role = 'SYSTEM'::text) AND (actor_user_id IS NULL) AND (app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` - `cmd_hold_event_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((aggregate_type = 'checkout_hold'::text) AND (type = ANY (ARRAY['booking.hold.created'::text, 'booking.hold.released'::text, 'booking.hold.release_deferred'::text, 'booking.hold.payment_in_flight'::text])) AND (app.actor_kind() = 'GUEST'::text) AND (actor_role = 'GUEST'::text) AND (actor_user_id = app.actor_id()))` - `cmd_hold_request_event_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((aggregate_type = 'checkout_hold'::text) AND (((app.actor_kind() = 'HOST'::text) AND (actor_role = 'HOST'::text) AND (actor_user_id = app.actor_id()) AND (type = ANY (ARRAY['booking.request.accepted'::text, 'booking.request.declined'::text, 'booking.request.access_denied'::text]))) OR ((app.actor_kind() = 'WORKER'::text) AND (actor_role = 'SYSTEM'::text) AND (app.worker_name() = ANY (ARRAY['hold_expiry'::text, 'booking_conversion'::text])) AND (type = ANY (ARRAY['booking.request.received'::text, 'booking.request.expired'::text, 'booking.request.void_requested'::text, 'booking.request.capture_unconfirmed'::text])))))` - `cmd_hold_request_event_sel` (SELECT, PERMISSIVE, cmd_hold_owner) USING `((type = 'booking.request.access_denied'::text) AND (actor_user_id = app.actor_id()))` @@ -4248,6 +4250,9 @@ Déclencheurs : | `created_at` | `timestamp with time zone` | oui | `platform.now()` | | `updated_at` | `timestamp with time zone` | oui | `platform.now()` | | `row_version` | `integer` | oui | `0` | +| `captured_minor` | `bigint` | non | — | +| `released_minor` | `bigint` | non | — | +| `decision_executed_at` | `timestamp with time zone` | non | — | Contraintes : @@ -4256,6 +4261,7 @@ Contraintes : - `deposit_hold_country_format` : `CHECK (country_code ~ '^[A-Z]{2}$'::text)` - `deposit_hold_currency_format` : `CHECK (currency ~ '^[A-Z]{3}$'::text)` - `deposit_hold_decision_window` : `CHECK (decision_at IS NULL OR decision_at <= release_at AND decision_at >= auth_at AND (auth_expiry_at IS NULL OR decision_at <= auth_expiry_at OR mechanism = 'REAUTH'::text AND reauth_due_at IS NOT NULL))` +- `deposit_hold_final_shape` : `CHECK (COALESCE(status = ANY (ARRAY['PARTIALLY_CAPTURED'::text, 'VOIDED'::text, 'REFUNDED'::text, 'EXPIRED'::text]), false) = (decision_executed_at IS NOT NULL) AND (decision_executed_at IS NULL) = (captured_minor IS NULL) AND (decision_executed_at IS NULL) = (released_minor IS NULL) AND (decision_executed_at IS NULL OR captured_minor >= 0 AND released_minor >= 0 AND (captured_minor + released_minor) = amount_minor AND (status = 'PARTIALLY_CAPTURED'::text) = (captured_minor > 0)))` - `deposit_hold_h_required_positive` : `CHECK (h_required_hours > 0)` - `deposit_hold_hold_fk` : `FOREIGN KEY (hold_id) REFERENCES core.booking_checkout_hold(id)` - `deposit_hold_hold_unique` : `UNIQUE (hold_id)` @@ -4275,6 +4281,7 @@ Contraintes : Index : +- `deposit_hold_decision_due_idx` : `CREATE INDEX deposit_hold_decision_due_idx ON core.payment_deposit_hold USING btree (decision_at) WHERE (status = 'AUTHORIZED'::text)` - `deposit_hold_reauth_due_idx` : `CREATE INDEX deposit_hold_reauth_due_idx ON core.payment_deposit_hold USING btree (reauth_due_at) WHERE (reauth_due_at IS NOT NULL)` Politiques RLS : @@ -6702,6 +6709,7 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.kyc_worker_prune(p_batch integer)` | `integer` | `kyc_cmd_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; kyc_cmd_owner: EXECUTE | | `core.payment_assert_operation_legs()` | `trigger` | `integrity_owner` | search_path=pg_catalog, pg_temp | integrity_owner: EXECUTE | | `core.payment_cmd_apply_operation_status(p_operation_id uuid, p_status text, p_source text, p_raw_ref uuid, p_provider_reference text)` | `text` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | +| `core.payment_cmd_deposit_decide(p_deposit_id uuid, p_expected_seq integer, p_status text, p_captured_minor bigint, p_released_minor bigint)` | `text` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE | | `core.payment_cmd_deposit_transition(p_deposit_id uuid, p_event text, p_expected_seq integer, p_auth_expiry_at timestamp with time zone, p_decision_at timestamp with time zone, p_reauth_due_at timestamp with time zone, p_provider_reference text)` | `text` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE | | `core.payment_cmd_plan_refund(p_instance_id uuid, p_operation_id uuid, p_settlement_id uuid, p_refunded_operation_id uuid, p_instance_seq integer, p_rail text, p_legs jsonb, p_idem_plain text, p_idem_sent text)` | `TABLE(instance_id uuid, operation_id uuid, advance_id uuid, status text, blocked_reason text, replayed boolean)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.payment_cmd_receive_webhook(p_account_id uuid, p_provider_event_id text, p_dedup_key bytea, p_signature_valid boolean, p_signed_at timestamp with time zone, p_headers jsonb, p_normalized jsonb)` | `TABLE(outcome text, inbox_id uuid)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_api: EXECUTE ; cmd_money_owner: EXECUTE | @@ -6714,6 +6722,7 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.payment_cmd_register_submerchant(p_id uuid, p_org_id uuid, p_psp_account_id uuid, p_attempt_no integer)` | `TABLE(submerchant_id uuid, idem_plain text, replayed boolean)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.payment_cmd_submit_refund(p_instance_id uuid)` | `TABLE(outcome text, blocked_reason text)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.payment_deposit_checkout(p_token_hash bytea, p_hold_id uuid)` | `TABLE(outcome text, country_code text, currency text, value_class text, scheduled_start timestamp with time zone, scheduled_end timestamp with time zone, provider text, now timestamp with time zone, mechanism text, amount_minor bigint, release_at timestamp with time zone)` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_api: EXECUTE ; cmd_hold_owner: EXECUTE | +| `core.payment_deposit_decision_due(p_limit integer)` | `TABLE(deposit_id uuid, trip_id uuid, segment_id uuid, tender_id uuid, country_code text, currency text, provider text, provider_reference text, mechanism text, amount_minor bigint, decision_at timestamp with time zone, auth_expiry_at timestamp with time zone, reauth_seq integer, now timestamp with time zone)` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE | | `core.payment_deposit_reauth_due(p_limit integer)` | `TABLE(deposit_id uuid, trip_id uuid, segment_id uuid, tender_id uuid, country_code text, currency text, provider text, provider_reference text, auth_expiry_at timestamp with time zone, release_at timestamp with time zone, reauth_seq integer, now timestamp with time zone)` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE | | `core.payment_refund_instance_gate()` | `trigger` | `integrity_owner` | search_path=pg_catalog, pg_temp | integrity_owner: EXECUTE | | `core.payment_refund_instance_sync()` | `trigger` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_money_owner: EXECUTE | From 1aa4d4798a99bf213659ab74ef59622c2f742433 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 20:39:52 -0300 Subject: [PATCH 4/5] =?UTF-8?q?docs(US-702):=20schema.md=20recopi=C3=A9=20?= =?UTF-8?q?de=20la=20sortie=20du=20job=20=C2=AB=20base=20de=20donn=C3=A9es?= =?UTF-8?q?=20=C2=BB=20(migration=200149)?= 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 | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/docs/architecture/schema.md b/docs/architecture/schema.md index 63d771c9..1aae81fd 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 ; 729 politiques RLS ; 297 fonctions `SECURITY DEFINER` ; 253 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_payment_deposit_decision` | PAY : décision de la caution à l'heure de décision (libération automatique, transitions | ## Rôles @@ -2627,7 +2628,7 @@ Politiques RLS : - `cmd_golive_sel` (SELECT, PERMISSIVE, cmd_golive_owner) USING `((go_live_request_id IS NOT NULL) OR (key IN ( SELECT d.key FROM core.config_param_definition d WHERE d.go_live_switch)))` - `cmd_hold_cancel_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['free_cancel_lead'::text, 'last_minute_threshold'::text, 'host_penalty'::text, 'platform_funded_host_compensation'::text]))` - `cmd_hold_contract_param_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = 'grace_minutes'::text)` -- `cmd_hold_deposit_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['deposit_always_required'::text, 'deposit_trigger_classes'::text, 'deposit_amount'::text, 'funds_holding_enabled'::text]))` +- `cmd_hold_deposit_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['deposit_always_required'::text, 'deposit_trigger_classes'::text, 'deposit_amount'::text, 'funds_holding_enabled'::text, 'auth_lead_h'::text, 'release_delay_h'::text, 'deposit_safety_h'::text, 'deposit_reauth_lead_h'::text]))` - `cmd_hold_meeting_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = 'review_window_days'::text)` - `cmd_hold_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['buffer_minutes'::text, 'hold_ttl_minutes'::text, 'hold_max_total_minutes'::text, 'max_active_holds_per_guest'::text, 'hold_creations_per_guest_vehicle_hour'::text, 'sweep_grace_s'::text, 'flagged_booking_payment_order'::text, 'review_hold_minutes'::text, 'payment_in_flight_margin_s'::text, 'psp_call_timeout_s'::text, 'conversion_start_tolerance_minutes'::text, 'payment_attempts_per_hold'::text, 'max_trip_days'::text, 'advance_notice_minutes'::text, 'no_show_grace_minutes'::text, 'overdue_detection_minutes'::text, 'p2p_private_hosts_enabled'::text, 'insurer_contract_active'::text]))` - `cmd_hold_request_param_read` (SELECT, PERMISSIVE, cmd_hold_owner) USING `(key = ANY (ARRAY['booking_request_mode_enabled'::text, 'booking_request_expiry_hours'::text]))` @@ -4147,6 +4148,7 @@ Politiques RLS : - `catalog_cmd_event_insert` (INSERT, PERMISSIVE, catalog_cmd_owner) WITH CHECK `((((type = 'catalog.addition_request.resolved'::text) AND (aggregate_type = 'catalog_addition_request'::text)) OR ((type = 'catalog.vehicle.released'::text) AND (aggregate_type = 'catalog_vehicle'::text))) AND (actor_role = ANY (ARRAY['OPS_AGENT'::text, 'ADMIN'::text])) AND (actor_user_id IS NOT NULL))` - `cmd_golive_event_ins` (INSERT, PERMISSIVE, cmd_golive_owner) WITH CHECK `((type = 'config.param.changed'::text) AND (aggregate_type = 'param_value'::text) AND (actor_role = 'SUPERADMIN'::text) AND (actor_user_id IS NOT NULL))` - `cmd_hold_contract_event_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((aggregate_type = 'contract_document'::text) AND (((type = 'contract.document.generated'::text) AND (actor_role = 'SYSTEM'::text) AND (actor_user_id IS NULL)) OR ((type = 'contract.document.signed'::text) AND (actor_role = 'GUEST'::text) AND (actor_user_id IS NOT NULL))))` +- `cmd_hold_deposit_event_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((aggregate_type = 'deposit_hold'::text) AND (type = 'deposit.decision.executed'::text) AND (actor_role = 'SYSTEM'::text) AND (actor_user_id IS NULL) AND (app.actor_kind() = 'WORKER'::text) AND (app.worker_name() = 'payment_command'::text))` - `cmd_hold_event_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((aggregate_type = 'checkout_hold'::text) AND (type = ANY (ARRAY['booking.hold.created'::text, 'booking.hold.released'::text, 'booking.hold.release_deferred'::text, 'booking.hold.payment_in_flight'::text])) AND (app.actor_kind() = 'GUEST'::text) AND (actor_role = 'GUEST'::text) AND (actor_user_id = app.actor_id()))` - `cmd_hold_request_event_ins` (INSERT, PERMISSIVE, cmd_hold_owner) WITH CHECK `((aggregate_type = 'checkout_hold'::text) AND (((app.actor_kind() = 'HOST'::text) AND (actor_role = 'HOST'::text) AND (actor_user_id = app.actor_id()) AND (type = ANY (ARRAY['booking.request.accepted'::text, 'booking.request.declined'::text, 'booking.request.access_denied'::text]))) OR ((app.actor_kind() = 'WORKER'::text) AND (actor_role = 'SYSTEM'::text) AND (app.worker_name() = ANY (ARRAY['hold_expiry'::text, 'booking_conversion'::text])) AND (type = ANY (ARRAY['booking.request.received'::text, 'booking.request.expired'::text, 'booking.request.void_requested'::text, 'booking.request.capture_unconfirmed'::text])))))` - `cmd_hold_request_event_sel` (SELECT, PERMISSIVE, cmd_hold_owner) USING `((type = 'booking.request.access_denied'::text) AND (actor_user_id = app.actor_id()))` @@ -4249,6 +4251,9 @@ Déclencheurs : | `created_at` | `timestamp with time zone` | oui | `platform.now()` | | `updated_at` | `timestamp with time zone` | oui | `platform.now()` | | `row_version` | `integer` | oui | `0` | +| `captured_minor` | `bigint` | non | — | +| `released_minor` | `bigint` | non | — | +| `decision_executed_at` | `timestamp with time zone` | non | — | Contraintes : @@ -4257,6 +4262,7 @@ Contraintes : - `deposit_hold_country_format` : `CHECK (country_code ~ '^[A-Z]{2}$'::text)` - `deposit_hold_currency_format` : `CHECK (currency ~ '^[A-Z]{3}$'::text)` - `deposit_hold_decision_window` : `CHECK (decision_at IS NULL OR decision_at <= release_at AND decision_at >= auth_at AND (auth_expiry_at IS NULL OR decision_at <= auth_expiry_at OR mechanism = 'REAUTH'::text AND reauth_due_at IS NOT NULL))` +- `deposit_hold_final_shape` : `CHECK (COALESCE(status = ANY (ARRAY['PARTIALLY_CAPTURED'::text, 'VOIDED'::text, 'REFUNDED'::text, 'EXPIRED'::text]), false) = (decision_executed_at IS NOT NULL) AND (decision_executed_at IS NULL) = (captured_minor IS NULL) AND (decision_executed_at IS NULL) = (released_minor IS NULL) AND (decision_executed_at IS NULL OR captured_minor >= 0 AND released_minor >= 0 AND (captured_minor + released_minor) = amount_minor AND (status = 'PARTIALLY_CAPTURED'::text) = (captured_minor > 0)))` - `deposit_hold_h_required_positive` : `CHECK (h_required_hours > 0)` - `deposit_hold_hold_fk` : `FOREIGN KEY (hold_id) REFERENCES core.booking_checkout_hold(id)` - `deposit_hold_hold_unique` : `UNIQUE (hold_id)` @@ -4276,6 +4282,7 @@ Contraintes : Index : +- `deposit_hold_decision_due_idx` : `CREATE INDEX deposit_hold_decision_due_idx ON core.payment_deposit_hold USING btree (decision_at) WHERE (status = 'AUTHORIZED'::text)` - `deposit_hold_reauth_due_idx` : `CREATE INDEX deposit_hold_reauth_due_idx ON core.payment_deposit_hold USING btree (reauth_due_at) WHERE (reauth_due_at IS NOT NULL)` Politiques RLS : @@ -6703,6 +6710,7 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.kyc_worker_prune(p_batch integer)` | `integer` | `kyc_cmd_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; kyc_cmd_owner: EXECUTE | | `core.payment_assert_operation_legs()` | `trigger` | `integrity_owner` | search_path=pg_catalog, pg_temp | integrity_owner: EXECUTE | | `core.payment_cmd_apply_operation_status(p_operation_id uuid, p_status text, p_source text, p_raw_ref uuid, p_provider_reference text)` | `text` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | +| `core.payment_cmd_deposit_decide(p_deposit_id uuid, p_expected_seq integer, p_status text, p_captured_minor bigint, p_released_minor bigint)` | `text` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE | | `core.payment_cmd_deposit_transition(p_deposit_id uuid, p_event text, p_expected_seq integer, p_auth_expiry_at timestamp with time zone, p_decision_at timestamp with time zone, p_reauth_due_at timestamp with time zone, p_provider_reference text)` | `text` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE | | `core.payment_cmd_plan_refund(p_instance_id uuid, p_operation_id uuid, p_settlement_id uuid, p_refunded_operation_id uuid, p_instance_seq integer, p_rail text, p_legs jsonb, p_idem_plain text, p_idem_sent text)` | `TABLE(instance_id uuid, operation_id uuid, advance_id uuid, status text, blocked_reason text, replayed boolean)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.payment_cmd_receive_webhook(p_account_id uuid, p_provider_event_id text, p_dedup_key bytea, p_signature_valid boolean, p_signed_at timestamp with time zone, p_headers jsonb, p_normalized jsonb)` | `TABLE(outcome text, inbox_id uuid)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_api: EXECUTE ; cmd_money_owner: EXECUTE | @@ -6715,6 +6723,7 @@ Chacune a un propriétaire `NOLOGIN` dédié (ADR-053) et un `search_path` figé | `core.payment_cmd_register_submerchant(p_id uuid, p_org_id uuid, p_psp_account_id uuid, p_attempt_no integer)` | `TABLE(submerchant_id uuid, idem_plain text, replayed boolean)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.payment_cmd_submit_refund(p_instance_id uuid)` | `TABLE(outcome text, blocked_reason text)` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_money_owner: EXECUTE | | `core.payment_deposit_checkout(p_token_hash bytea, p_hold_id uuid)` | `TABLE(outcome text, country_code text, currency text, value_class text, scheduled_start timestamp with time zone, scheduled_end timestamp with time zone, provider text, now timestamp with time zone, mechanism text, amount_minor bigint, release_at timestamp with time zone)` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_api: EXECUTE ; cmd_hold_owner: EXECUTE | +| `core.payment_deposit_decision_due(p_limit integer)` | `TABLE(deposit_id uuid, trip_id uuid, segment_id uuid, tender_id uuid, country_code text, currency text, provider text, provider_reference text, mechanism text, amount_minor bigint, decision_at timestamp with time zone, auth_expiry_at timestamp with time zone, reauth_seq integer, now timestamp with time zone)` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE | | `core.payment_deposit_reauth_due(p_limit integer)` | `TABLE(deposit_id uuid, trip_id uuid, segment_id uuid, tender_id uuid, country_code text, currency text, provider text, provider_reference text, auth_expiry_at timestamp with time zone, release_at timestamp with time zone, reauth_seq integer, now timestamp with time zone)` | `cmd_hold_owner` | search_path=pg_catalog, pg_temp | app_worker: EXECUTE ; cmd_hold_owner: EXECUTE | | `core.payment_refund_instance_gate()` | `trigger` | `integrity_owner` | search_path=pg_catalog, pg_temp | integrity_owner: EXECUTE | | `core.payment_refund_instance_sync()` | `trigger` | `cmd_money_owner` | search_path=pg_catalog, pg_temp | cmd_money_owner: EXECUTE | From f72e2e6068124b79a66a3bebfe5a2fa4951c8606 Mon Sep 17 00:00:00 2001 From: Projetapploccar <351336702+Projetapploccar@users.noreply.github.com> Date: Wed, 18 Nov 2026 21:03:22 -0300 Subject: [PATCH 5/5] =?UTF-8?q?test(US-702):=20l0-us043=20=E2=80=94=20paym?= =?UTF-8?q?ent=5Fcmd=5Frecord=5Fdeposit=5Fdecision=20lit=20platform.deploy?= =?UTF-8?q?ment=5Fenv()=20(COALESCE,=20compte=20marchand)?= 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/team/handoffs/US-702.md | 1 + packages/db/test/l0/l0-us043-env-guard.test.ts | 2 ++ 2 files changed, 3 insertions(+) diff --git a/docs/team/handoffs/US-702.md b/docs/team/handoffs/US-702.md index 96fb0696..1be5c5bf 100644 --- a/docs/team/handoffs/US-702.md +++ b/docs/team/handoffs/US-702.md @@ -25,6 +25,7 @@ Non couvert ici : pose réelle à `auth_at` (S-1, lot C) — en production aucun - `pay/internal/deposit-checkout.test.ts`, `pay/testing/deposit-timer.fake.test.ts` : montant de test lu par exposant (T57 en centimes, T73 a sans décimale) au lieu de 300 mis à l'échelle ; aucun attendu de règle changé (échéancier indépendant du montant). - `packages/db/test/l0/l0-us701-deposit-hold.test.ts` : PYG 300 ⇒ 1 500 000 (T73) ; aucune assertion retirée ni relâchée. - `packages/db/test/int/outbox-schema.test.ts` (sécurité) : une entrée ajoutée à la liste exhaustive des politiques, `cmd_hold_deposit_event_ins` (cmd_hold_owner, INSERT) ; toute autre politique reste refusée. +- `packages/db/test/l0/l0-us043-env-guard.test.ts` (sécurité) : `core.payment_cmd_record_deposit_decision` ajoutée à la liste exacte des fonctions qui lisent `platform.deployment_env()` (lecture `COALESCE(…, 'production')` vérifiée par le test lui-même, même choix du compte marchand que T1) ; égalité de liste conservée. - `ntf/internal/dispatcher.test.ts` : `deposit.decision.executed` ajouté à la liste exacte des abonnements ; nouveau cas. - `apps/web/e2e/checkout-payment.spec.ts` : la sortie du refus vérifie maintenant `href="/search"`. diff --git a/packages/db/test/l0/l0-us043-env-guard.test.ts b/packages/db/test/l0/l0-us043-env-guard.test.ts index 82f11dda..9b5f379f 100644 --- a/packages/db/test/l0/l0-us043-env-guard.test.ts +++ b/packages/db/test/l0/l0-us043-env-guard.test.ts @@ -68,6 +68,8 @@ const READERS = [ // US-223 (0116) : preuve POLL / API_RESPONSE d'un compte de bac à sable hors production seulement 'core.payment_cmd_apply_operation_status', 'core.payment_cmd_receive_webhook', + // US-702 (0149) : fournisseur de la caution recalculé par la base, même choix que T1 (0116) + 'core.payment_cmd_record_deposit_decision', 'core.payment_cmd_record_operation', 'core.payment_cmd_register_submerchant', // US-701 (0146) : compte marchand du pays de la caution, même choix que T1 (0116)