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..7ecde005 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` (0149 : 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 (0149, 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..acece885 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', () => { + // 0149 : 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..658f0eca 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 ; 0149, 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` (0149) 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` (0149, 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..2c9b297c --- /dev/null +++ b/apps/api/src/modules/pay/testing/deposit-timer-store.int.test.ts @@ -0,0 +1,225 @@ +/** + * 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` (0149) : file des décisions échues (montant en `bigint`, rail, + * expiration) et transition finale ; `DepositDecisionTimer` de bout en bout avec la configuration + * 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é. + */ +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'; +import { DepositRailExecutor } from '../internal/deposit-executor.js'; +import { createCurrencyRegistry } from '@rueda/money'; + +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, 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)`, + [ + c.country, + c.currency, + timezone, + start, + end, + amount.toString(), + 'PREAUTH_SINGLE', + at(end, 72), + at(end, 72), + at(end, 70), + order.providerReference, + ], + ); + 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 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('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 }), + ).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..19b4397b 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` (0149), 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..00d901e2 --- /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 0149, 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..26109b53 --- /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 0149, `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/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 | diff --git a/docs/ops/GO_LIVE_CHECKLIST.md b/docs/ops/GO_LIVE_CHECKLIST.md index 7d7f3a8f..e1f69d20 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 0149). **À 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 1de8ee9a..67ccfc8e 100644 --- a/docs/team/COMME_TURO.md +++ b/docs/team/COMME_TURO.md @@ -223,3 +223,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..1be5c5bf --- /dev/null +++ b/docs/team/handoffs/US-702.md @@ -0,0 +1,41 @@ +# 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 `0149_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** (0149, `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. +- `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"`. + +## 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 500e0f41..9704478a 100644 --- a/packages/db/README.md +++ b/packages/db/README.md @@ -1089,3 +1089,12 @@ Migration `0148_hardening_country_open`. Fixture `9935_test_hardening_fixtures` - **N-342** : corps de `core.booking_trip_receipt` (0137) remplacé : l'hôte est jugé par `core.iam_host_accounts` (titulaire au rôle `P2P_HOST` `ACTIVE`, comme `booking_host_earnings`) ; co-hôte ou adhésion retirée ⇒ `NOT_FOUND`. - **N-313** : corps de `core.catalog_value_class_resolve` (0135) remplacé : marque comparée sans ses tirets, modèle de la règle reconnu au début du modèle saisi (tirets facultatifs, suivi de la fin, d'un tiret, d'un chiffre ou d'une lettre selon la fin de la règle) ; graine `core.catalog_value_class_rule` complétée (`source_ref` « N-313 »). Une classe posée n'est jamais recalculée. - **Preuves** : `test/l0/l0-us224e-defaulted-host.test.ts`, `test/l0/l0-us217-host-receipt.test.ts`, `test/l0/l0-n83-value-class.test.ts` (PA USD, PY PYG ; rôles de production). + +## Décision de la caution (US-702 ; 08 BR-PAY-06 ; ADR-172) + +Migration `0149_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/0149_payment_deposit_decision.sql b/packages/db/migrations/0149_payment_deposit_decision.sql new file mode 100644 index 00000000..9c9a7f2e --- /dev/null +++ b/packages/db/migrations/0149_payment_deposit_decision.sql @@ -0,0 +1,403 @@ +-- 0149 — 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 8e3e4893..44b7ae1e 100644 --- a/packages/db/security-definer-allowlist.json +++ b/packages/db/security-definer-allowlist.json @@ -2078,6 +2078,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..eb91b8cd 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 (0149, 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-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) 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..a8ee00ee --- /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 0149, 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, 0149) 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 91790d82..4293f8bd 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 d4ad852c..92abe2b7 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 a895a9a8..c82654a3 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 c05fe331..71601558 100644 --- a/packages/i18n/src/catalogs/index.ts +++ b/packages/i18n/src/catalogs/index.ts @@ -277,8 +277,11 @@ export type { Catalog, Message, PluralCategory, PluralMessage, VersionedCatalog (`ctr.constancia.title`, `ctr.constancia.platform`, `web.s09.documents.constancia`) ; tutoiement du centre juridique (`web.legalCenter.trip.body`, `web.legalCenter.disputes.body1` à `body3`, es et fr). Textes juridiques toujours BROUILLON (GL-39). + 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 = 86; +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 cdbb70c5..3c016cd5 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',