refactor(payment): centralize route lifecycle

src/app/_hooks/use-pending-payment-order-lifecycle.ts

@@ -0,0 +1,115 @@
+"use client";
+
+import { type Dispatch, useEffect, useRef } from "react";
+
+import {
+  clearPendingPaymentOrder,
+  getPendingPaymentOrderForType,
+  type PendingPaymentSubscriptionType,
+} from "@/lib/payment/pending_payment_order";
+import type { PaymentEvent } from "@/stores/payment/payment-events";
+
+export interface PaymentOrderLifecycleState {
+  currentOrderId: string | null;
+  isPaid: boolean;
+  isPollingOrder: boolean;
+  status: string;
+}
+
+export interface ShouldInspectPendingPaymentOrderInput
+  extends PaymentOrderLifecycleState {
+  shouldResumePendingOrder: boolean;
+}
+
+export interface UsePendingPaymentOrderLifecycleInput {
+  payment: PaymentOrderLifecycleState;
+  paymentDispatch: Dispatch<PaymentEvent>;
+  paymentType: PendingPaymentSubscriptionType;
+  shouldResumePendingOrder: boolean;
+}
+
+export function shouldInspectPendingPaymentOrder({
+  isPaid,
+  isPollingOrder,
+  shouldResumePendingOrder,
+  status,
+}: ShouldInspectPendingPaymentOrderInput): boolean {
+  return (
+    status === "ready" ||
+    (!shouldResumePendingOrder &&
+      (isPollingOrder || isPaid || status === "failed"))
+  );
+}
+
+export function usePendingPaymentOrderLifecycle({
+  payment,
+  paymentDispatch,
+  paymentType,
+  shouldResumePendingOrder,
+}: UsePendingPaymentOrderLifecycleInput): void {
+  const resumedPendingOrderRef = useRef<string | null>(null);
+
+  useEffect(() => {
+    if (
+      !shouldInspectPendingPaymentOrder({
+        currentOrderId: payment.currentOrderId,
+        isPaid: payment.isPaid,
+        isPollingOrder: payment.isPollingOrder,
+        shouldResumePendingOrder,
+        status: payment.status,
+      })
+    ) {
+      return;
+    }
+
+    let cancelled = false;
+
+    const handlePendingOrder = async () => {
+      const result = await getPendingPaymentOrderForType(paymentType);
+      if (cancelled || !result.success || result.data === null) return;
+
+      if (!shouldResumePendingOrder) {
+        await clearPendingPaymentOrder();
+        if (
+          payment.currentOrderId === result.data.orderId &&
+          (payment.isPollingOrder ||
+            payment.isPaid ||
+            payment.status === "failed")
+        ) {
+          paymentDispatch({ type: "PaymentReset" });
+        }
+        return;
+      }
+
+      if (payment.currentOrderId === result.data.orderId) return;
+      if (resumedPendingOrderRef.current === result.data.orderId) return;
+
+      resumedPendingOrderRef.current = result.data.orderId;
+      paymentDispatch({
+        type: "PaymentReturned",
+        orderId: result.data.orderId,
+        createdAt: result.data.createdAt,
+      });
+    };
+
+    void handlePendingOrder();
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    payment.currentOrderId,
+    payment.isPaid,
+    payment.isPollingOrder,
+    payment.status,
+    paymentDispatch,
+    paymentType,
+    shouldResumePendingOrder,
+  ]);
+
+  useEffect(() => {
+    if (!payment.currentOrderId) return;
+    if (!payment.isPaid && payment.status !== "failed") return;
+
+    void clearPendingPaymentOrder();
+  }, [payment.currentOrderId, payment.isPaid, payment.status]);
+}