@code-collective/booking-widget 1.0.15 → 1.0.16

package/src/lib/checkout-payment-flow.svelte.ts

@@ -1,7 +1,7 @@
 // The state of one shopper's current Peach payment attempt, from minting it through to a settled outcome -
 // split out of CheckoutModal.svelte because this was the single largest, most tangled concern in that file
 // (roughly a third of it): initiating a payment, resuming one after a reload, releasing/reporting a dead or
-// declined attempt, and polling the cart's status until it settles. None of it needs the cart's own item list,
+// spent checkout, and polling the cart's status until it settles. None of it needs the cart's own item list,
 // the contact form, or the wizard's cart/edit views - only the current payment attempt and where it stands.
 
 import type { BookingApi } from './api';
@@ -89,19 +89,18 @@ export function createCheckoutPaymentFlow(deps: CheckoutPaymentFlowDeps): Checko
   // A reload mid-payment: the server still holds this cart in AwaitingPaymentConfirmation for the Peach
   // checkout recorded before the reload, and will refuse every edit and a second payCart until that attempt
   // is settled or abandoned. Where to land depends on how far the shopper got before the reload, and only the
-  // server knows: Peach's form may have completed a moment earlier - a charge, or a decline the server reads
-  // straight back from Peach's status endpoint, since Peach sends no webhook for one - so it is asked once
-  // first, and a recorded outcome is shown exactly as it would have been without the reload. Only "not paid"
-  // puts the shopper back on that same card form, whose Peach handlers then route as they do without a
-  // reload: a completed charge confirms, a cancel/expiry/error abandons the attempt and reopens the cart.
+  // server knows: the charge may have landed a moment earlier, so the cart is read once first and a settled
+  // outcome is shown exactly as it would have been without the reload. Anything short of that puts the shopper
+  // back on the same card form, whose Peach handlers then route as they do without a reload: a completed
+  // charge confirms, a cancel/expiry/error releases the checkout and reopens the cart. A card declined in
+  // between changes nothing here - it never ended Peach's checkout, so the form is still the right place.
   // Same resume as payNow's own paymentResult short-cut.
   async function resumeInterruptedPayment(): Promise<void> {
     const interruptedAttempt = recallPaymentAttempt(deps.getApi().cartToken);
     if (!interruptedAttempt) return;
     paymentResult = interruptedAttempt;
-    // Posted before the answer is known, as payNow does: CartExpiryGuard must treat the attempt as in flight
-    // whichever screen it ends up on, and a decline's own payment:ended (releaseDeclinedAttempt) then reads the
-    // same as it does without a reload.
+    // Posted before the answer is known, as payNow does: CartExpiryGuard must treat the payment as in flight
+    // whichever screen it ends up on.
     postMessage({ type: 'payment:started' });
     if (await resumeOntoRecordedOutcome()) return;
     deps.setView('payment');
@@ -111,14 +110,13 @@ export function createCheckoutPaymentFlow(deps: CheckoutPaymentFlowDeps): Checko
     if (cartDeadline(deps.getCart()).getTime() <= Date.now()) void onPaymentTimedOut();
   }
 
-  // Where a reload lands. One status read decides it: a settled attempt (a charge, a supplier-side partial
-  // failure, or a decline) goes straight to the result screen; a confirmation in flight joins the ordinary
-  // poll to read its outcome; a cart the server no longer has closes the modal, as a 401 does everywhere else
-  // here. Anything still genuinely unresolved - a shopper who never submitted the card, or one who reloaded
-  // mid-3-D Secure, which cannot be told apart from here (PR 8447 review) - goes back to the card form, since
-  // that is Peach's own form for this same checkoutId rather than a fresh charge. An unreachable server is
-  // treated the same way, rather than parking them on a screen telling them not to pay again for a card they
-  // may never have submitted.
+  // Where a reload lands. One status read decides it: a confirmed cart goes straight to the result screen; a
+  // confirmation in flight joins the ordinary poll to read its outcome; a cart the server no longer has closes
+  // the modal, as a 401 does everywhere else here. Anything still unresolved - a shopper who never submitted
+  // the card, one who reloaded mid-3-D Secure, or one still working through declines on Peach's own form,
+  // none of which can be told apart from here - goes back to the card form, since that is Peach's own form for
+  // this same checkoutId rather than a fresh charge. An unreachable server is treated the same way, rather
+  // than parking them on a screen telling them not to pay again for a card they may never have submitted.
   async function resumeOntoRecordedOutcome(): Promise<boolean> {
     isConfirming = true;
     deps.setView('result');
@@ -141,9 +139,13 @@ export function createCheckoutPaymentFlow(deps: CheckoutPaymentFlowDeps): Checko
       return true;
     }
 
-    if (status.paymentOutcome === 'failed' || status.paymentOutcome === 'abandoned') {
+    // Expired while the tab was away - the sweep found a cart nobody came back to. There is no card form to
+    // return to, so this owns where the shopper lands rather than falling through to one.
+    if (status.cartStatus === 'expired') {
       confirmOutcome = 'notCharged';
-      await releaseDeclinedAttempt();
+      forgetPaymentAttempt();
+      paymentResult = null;
+      postMessage({ type: 'payment:ended' });
       isConfirming = false;
       return true;
     }
@@ -158,24 +160,20 @@ export function createCheckoutPaymentFlow(deps: CheckoutPaymentFlowDeps): Checko
     return false;
   }
 
-  // Tells the server this attempt is over so a fresh payCart will be accepted - without it the cart stays
-  // AwaitingPaymentConfirmation, no webhook ever comes for a checkout nobody submitted, and the only thing a
-  // retry could do is reopen a Peach session that is already dead. 'settled' means Peach has this attempt as
-  // paid, or still in flight (PAYMENT_PENDING) - either way the cart must not be reopened, and the confirm loop
+  // Tells the server this checkout is over so a fresh payCart will be accepted - without it the cart stays
+  // AwaitingPaymentConfirmation, no webhook ever comes for a checkout nobody paid, and the only thing a retry
+  // could do is reopen a Peach session that is already dead. 'settled' means Peach has this checkout as paid,
+  // or still in flight (PAYMENT_PENDING) - either way the cart must not be reopened, and the confirm loop
   // already handles "not paid yet" by landing on the pending screen, so both take the same path here; 'failed'
   // means the server could not be reached or refused for another reason, in which case paymentResult is kept
-  // so payNow falls back to resuming the same still-open attempt.
-  // Two endpoints, one guard behind them: a shopper backing out or a clock running out is an abandon, while
-  // Peach's own SDK reporting a failure carries a reason worth recording against the attempt - and for a card
-  // declined inside the checkout, where Peach sends no webhook, that payload is the only place its code exists.
-  async function abandonPaymentAttempt(checkoutId: string, failure?: PaymentSdkResult):
-    Promise<'abandoned' | 'settled' | 'failed'> {
+  // so payNow falls back to resuming the same still-open checkout.
+  // One endpoint for every way out: a shopper backing out, a clock running out, and Peach's own SDK reporting
+  // the checkout unusable are all the same thing to this gateway - a checkout nothing was charged on. A
+  // declined card is not among them: Peach keeps the shopper on its own form to try again, and none of that
+  // ever reaches here.
+  async function abandonPaymentAttempt(checkoutId: string): Promise<'abandoned' | 'settled' | 'failed'> {
     try {
-      if (failure) {
-        await deps.getApi().reportPaymentFailure(checkoutId, failure.resultCode, failure.description);
-      } else {
-        await deps.getApi().abandonPayment(checkoutId);
-      }
+      await deps.getApi().abandonPayment(checkoutId);
       return 'abandoned';
     } catch (e) {
       return isPaymentSettled(e) || isPaymentPending(e) ? 'settled' : 'failed';
@@ -250,19 +248,14 @@ export function createCheckoutPaymentFlow(deps: CheckoutPaymentFlowDeps): Checko
   }
 
   async function onPaymentComplete(result: PaymentSdkResult): Promise<void> {
-    // Neither cancelled, expired nor error ever reached a real charge - Peach's own SDK is reporting that the
-    // checkout itself didn't go through (the shopper backed out, session timeout, a declined card, a 3DS
-    // failure, a client-side error), not that a successful charge's confirmation is in question. That
-    // distinction matters: the confirm path at the bottom is only reachable once onCompleted has fired, which
-    // Peach does for a settled outcome of either kind - a charge, or a decline (the server reads that back from
-    // Peach's status endpoint, since Peach sends no webhook for one, and answers PAYMENT_FAILED). So "try again"
-    // there is only ever offered once the server itself has said nothing was charged. Here nothing was charged,
-    // so the attempt is abandoned server-side (a retry then starts a genuinely new Peach checkout instead of
-    // reopening this dead one) and re-opening the card form is exactly correct.
+    // None of cancelled, expired or error is a decline - a declined card never ends Peach's checkout at all,
+    // it re-prompts inside the same form, and the shopper only comes back to us once they give up or pay. What
+    // these three mean is that this checkout is unusable: the shopper backed out, the session timed out, or
+    // the SDK itself broke. Nothing was charged, so the checkout is released server-side (a retry then mints a
+    // genuinely new one rather than reopening this dead one) - and the abandon's own Peach-status guard is
+    // what makes that safe in the case where the SDK is wrong about no charge having landed.
     if (result.status === 'cancelled' || result.status === 'expired' || result.status === 'error') {
-      // Only the two genuine failures carry Peach's own reason; a shopper backing out has none to give.
-      const failure = result.status === 'cancelled' ? undefined : result;
-      if (!(await releaseAbandonedAttempt(failure))) return;
+      if (!(await releaseAbandonedAttempt())) return;
     }
 
     if (result.status === 'cancelled') {
@@ -277,27 +270,21 @@ export function createCheckoutPaymentFlow(deps: CheckoutPaymentFlowDeps): Checko
       return;
     }
 
-    // Peach's form has reported the checkout complete, which covers a declined card as much as a charged one.
-    // The server is asked once to go and find out which, because no webhook is coming for a decline; the poll
-    // below then reads whatever it established. Best effort - a failure here only means the answer arrives
-    // from the webhook or the sweep instead, which is exactly what the poll is already waiting for.
+    // Peach's form has reported the checkout complete, which after the branch above can only be a charge.
+    // Nothing is asserted from here regardless: the webhook is what moves the cart to Paid, and this poll only
+    // reads the cart until it says so.
     deps.setView('result');
-    try {
-      await deps.getApi().resolvePayment();
-    } catch {
-      // see above
-    }
     await runStatusPoll();
   }
 
   // False when this flow has already taken over what happens next - the cart turned out to be paid and is
   // being confirmed, or it has expired - so the caller must not route the shopper anywhere else.
-  async function releaseAbandonedAttempt(failure?: PaymentSdkResult): Promise<boolean> {
+  async function releaseAbandonedAttempt(): Promise<boolean> {
     // Already cleared by an earlier call for this same attempt (e.g. a second Peach callback after the first
     // already abandoned it) - nothing left to tell the server about.
     if (!paymentResult) return await deps.reloadCart();
 
-    const abandoned = await abandonPaymentAttempt(paymentResult.checkoutId, failure);
+    const abandoned = await abandonPaymentAttempt(paymentResult.checkoutId);
     if (abandoned === 'settled') {
       deps.setView('result');
       await runStatusPoll();
@@ -323,49 +310,21 @@ export function createCheckoutPaymentFlow(deps: CheckoutPaymentFlowDeps): Checko
   }
 
   // Back to the contact form rather than straight to 'payment'. Every outcome that offers Try Again is one
-  // where nothing was charged, and in all but one of them the attempt has already been released (a decline
-  // here, a Peach-reported expiry or error in onPaymentComplete) - so there is no card form left to return to:
-  // Peach's SDK will not re-render a checkoutId it has unmounted, and a checkout that reached a decline is
-  // finished on Peach's side regardless. Contact is where payNow creates a genuinely new one, with the
-  // shopper's details still filled in (they live in the parent component, not in ContactForm) so paying again -
-  // on another card, if that is what the decline was about - is one click away. The exception needs no handling
-  // of its own: after an abandon the server refused, the attempt is still open and payNow's own paymentResult
-  // short-cut resumes that same one from here, which is exactly what it is there for.
+  // where nothing was charged and the checkout behind it has already been released (a Peach-reported expiry or
+  // error in onPaymentComplete) - so there is no card form left to return to: Peach's SDK will not re-render a
+  // checkoutId it has unmounted. Contact is where payNow creates a genuinely new checkout, with the shopper's
+  // details still filled in (they live in the parent component, not in ContactForm) so paying again is one
+  // click away. The one exception needs no handling of its own: after an abandon the server refused, the
+  // checkout is still open and payNow's own paymentResult short-cut resumes that same one from here, which is
+  // exactly what it is there for.
   function retry(): void {
     deps.setView('contact');
   }
 
-  // The declined counterpart to releaseAbandonedAttempt, and deliberately without its abandon call: the server
-  // has already resolved this attempt itself - a decline reached it (Peach's webhook, or its own read of Peach's
-  // status endpoint on the status poll, since Peach sends no webhook for a declined card), which is what moved
-  // the cart to Failed - so there is nothing left to report. AbandonPaymentAsync answers a Failed cart with
-  // AlreadyOpen, an explicit no-op.
-  // Clearing the attempt is what makes Try Again start a NEW Peach checkout instead of reopening the dead one:
-  // payNow resumes paymentResult when it is still set, and resumeInterruptedPayment would land a reload
-  // straight back on that same spent card form.
-  async function releaseDeclinedAttempt(): Promise<void> {
-    paymentResult = null;
-    forgetPaymentAttempt();
-    // Failed is live and still payable again - the decline leaves the cart's one clock exactly where it was -
-    // so this re-reads whatever time Try Again actually has left rather than the deadline from before the card
-    // form. A cart whose clock ran out meanwhile 401s here and closes the modal, same as anywhere else. Any
-    // other failure of the re-read must not escape: this runs inside resumeOntoRecordedOutcome's own catch,
-    // from where a throw would strand the shopper on "Verifying payment..." with no button at all, and the
-    // decline itself is already recorded - Try Again simply counts down from the older deadline (PR 8447 review).
-    try {
-      if (await deps.reloadCart()) deps.notifyCartUpdated(deps.getCart());
-    } catch {
-      // see above
-    }
-    // Without this CartExpiryGuard keeps treating a payment as in flight for the rest of the page's life, so it
-    // never prompts or expires this cart again.
-    postMessage({ type: 'payment:ended' });
-  }
-
   // One status read, interpreted - the single place that decides what a given cart state means, shared by the
-  // automatic poll and the manual on-demand recheck. 'settled' has recorded the outcome (success, a
-  // supplier-side partial failure, or a decline); 'waiting' means the backend has not finished and another
-  // read is worth making.
+  // automatic poll and the manual on-demand recheck. 'settled' has recorded the outcome (success, or a
+  // supplier-side partial failure); 'waiting' means the backend has not finished and another read is worth
+  // making.
   async function pollOnce(signal?: AbortSignal): Promise<'settled' | 'waiting'> {
     let status;
     try {
@@ -394,15 +353,12 @@ export function createCheckoutPaymentFlow(deps: CheckoutPaymentFlowDeps): Checko
       return 'settled';
     }
 
-    // A settled non-success attempt. The server has already asked Peach directly if no webhook arrived (Peach
-    // sends none for a card declined inside a checkout), so this is a real answer rather than a guess, and the
-    // cart is payable again - nothing was captured.
-    if (status.paymentOutcome === 'failed' || status.paymentOutcome === 'abandoned') {
+    // The stuck-payment sweep released this cart: nothing was charged, nothing is coming, and the holds
+    // behind it are being cancelled. Terminal - polling on would just wait out the window.
+    if (status.cartStatus === 'expired') {
       confirmOutcome = 'notCharged';
-      // Clears the spent Peach checkout so Try Again mints a new one rather than reopening a dead card form,
-      // and re-reads the cart's remaining time. The server has already resolved this attempt itself, so there
-      // is nothing left to report to it.
-      await releaseDeclinedAttempt();
+      forgetPaymentAttempt();
+      paymentResult = null;
       return 'settled';
     }
 

package/src/lib/generated-types.ts

@@ -108,23 +108,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/checkout/cart/resolve-payment": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /** Resolve checkout cart payment */
-        post: operations["ResolveCheckoutCartPayment_v1"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/v1/checkout/cart/status": {
         parameters: {
             query?: never;
@@ -159,23 +142,6 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/v1/checkout/cart/payment-failure": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /** Report checkout cart payment failure */
-        post: operations["ReportCheckoutCartPaymentFailure_v1"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/v1/checkout/cart/abandon-payment": {
         parameters: {
             query?: never;
@@ -454,11 +420,6 @@ export interface components {
         CheckoutCartPayDto: {
             contact?: components["schemas"]["OctoContact"];
         };
-        CheckoutCartPaymentFailureDto: {
-            checkoutId?: string | null;
-            resultCode?: string | null;
-            description?: string | null;
-        };
         CheckoutCartPaymentInitiationDto: {
             checkoutId?: string | null;
             redirectUrl?: string | null;
@@ -484,9 +445,6 @@ export interface components {
         };
         CheckoutCartStatusDto: {
             cartStatus?: string | null;
-            paymentOutcome?: string | null;
-            resolvedBy?: string | null;
-            resultCode?: string | null;
             confirmResult?: components["schemas"]["CheckoutCartConfirmResultDto"];
         };
         CheckoutFaqDto: {
@@ -814,24 +772,6 @@ export interface operations {
             };
         };
     };
-    ResolveCheckoutCartPayment_v1: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description No Content */
-            204: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-        };
-    };
     GetCheckoutCartStatus_v1: {
         parameters: {
             query?: never;
@@ -872,28 +812,6 @@ export interface operations {
             };
         };
     };
-    ReportCheckoutCartPaymentFailure_v1: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody: {
-            content: {
-                "application/json": components["schemas"]["CheckoutCartPaymentFailureDto"];
-            };
-        };
-        responses: {
-            /** @description No Content */
-            204: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-        };
-    };
     AbandonCheckoutCartPayment_v1: {
         parameters: {
             query?: never;