@carlonicora/nextjs-jsonapi 5.5.0 → 5.7.0

package/src/features/billing/stripe-subscription/hooks/useSubscriptionWizard.ts

@@ -7,9 +7,24 @@ import { useI18nLocale } from "../../../../i18n";
 import { StripeCustomerService } from "../../stripe-customer/data/stripe-customer.service";
 import { ProrationPreviewInterface } from "../../stripe-invoice/data/stripe-invoice.interface";
 import { StripePriceInterface } from "../../stripe-price/data/stripe-price.interface";
+import { StripeCouponCodeService } from "../../stripe-coupon/data/stripe-coupon-code.service";
+import { toPromotionCodeResult } from "../../stripe-coupon/utils/to-promotion-code-result";
 import { PromotionCodeValidationResult, StripePromotionCodeService } from "../../stripe-promotion-code";
 import { BillingInterval } from "../components/widgets/IntervalToggle";
-import { StripeSubscriptionInterface, StripeSubscriptionService, SubscriptionStatus } from "../data";
+import {
+  StripeSubscriptionCreateResponse,
+  StripeSubscriptionInterface,
+  StripeSubscriptionService,
+  SubscriptionStatus,
+} from "../data";
+import {
+  isDiscountSoldOut,
+  isDiscountUnavailable,
+  promotionCodeToSend,
+  shouldLookUpAutomatic,
+} from "./wizard-promotion";
+import { useConfirmSubscriptionPayment } from "./useConfirmSubscriptionPayment";
+import { clientSecretToConfirm, subscriptionIdToSync } from "./wizard-payment";
 
 export type WizardStep = "plan-selection" | "review" | "payment-method";
 
@@ -97,6 +112,7 @@ export type UseSubscriptionWizardOptions = {
 export function useSubscriptionWizard({ subscription, onSuccess, onClose }: UseSubscriptionWizardOptions) {
   const t = useTranslations();
   const locale = useI18nLocale();
+  const { confirmPayment } = useConfirmSubscriptionPayment();
   const [state, dispatch] = useReducer(wizardReducer, {
     ...initialState,
     selectedPrice: subscription?.price || null,
@@ -130,6 +146,42 @@ export function useSubscriptionWizard({ subscription, onSuccess, onClose }: UseS
     dispatch({ type: "SET_STEP", step });
   }, []);
 
+  /**
+   * Puts the automatic code for this price (or none) in the wizard state, so the
+   * review shows what the server would really charge. Returns false when the
+   * lookup itself failed: the caller must then not show a price as the truth.
+   */
+  const lookUpAutomaticCode = useCallback(async (priceId: string): Promise<boolean> => {
+    try {
+      const automaticCode = await StripeCouponCodeService.findAutomatic({ priceId });
+      dispatch({
+        type: "SET_PROMOTION_CODE",
+        code: automaticCode ? toPromotionCodeResult(automaticCode) : null,
+      });
+      return true;
+    } catch (error) {
+      console.error("[useSubscriptionWizard] Failed to look up the automatic promotion code:", error);
+      dispatch({ type: "SET_PROMOTION_CODE", code: null });
+      return false;
+    }
+  }, []);
+
+  /**
+   * Re-reads the automatic code after the review's code changed. When the lookup
+   * fails, the review price cannot be trusted: back to plan selection.
+   */
+  const refreshAutomaticCodeOrLeaveReview = useCallback(
+    async (priceId: string): Promise<void> => {
+      const found = await lookUpAutomaticCode(priceId);
+      if (!found) {
+        // SET_STEP clears the error, so the error goes second
+        dispatch({ type: "SET_STEP", step: "plan-selection" });
+        dispatch({ type: "SET_ERROR", error: t("billing.ui.wizard.errors.prepare_review") });
+      }
+    },
+    [lookUpAutomaticCode, t],
+  );
+
   const goToReview = useCallback(async () => {
     if (!state.selectedPrice) return;
 
@@ -156,6 +208,16 @@ export function useSubscriptionWizard({ subscription, onSuccess, onClose }: UseS
         }
       }
 
+      // Fill the automatic code for this price, unless the GM typed one
+      // A failed lookup never shows full price as if nothing applied: stay off the review
+      if (shouldLookUpAutomatic(state.promotionCode)) {
+        const found = await lookUpAutomaticCode(state.selectedPrice.id);
+        if (!found) {
+          dispatch({ type: "SET_ERROR", error: t("billing.ui.wizard.errors.prepare_review") });
+          return;
+        }
+      }
+
       // If editing subscription, get proration preview
       if (subscription && state.selectedPrice.id !== subscription.price?.id) {
         const preview = await StripeSubscriptionService.getProrationPreview({
@@ -172,7 +234,15 @@ export function useSubscriptionWizard({ subscription, onSuccess, onClose }: UseS
     } finally {
       dispatch({ type: "SET_PROCESSING", isProcessing: false });
     }
-  }, [state.selectedPrice, state.hasPaymentMethod, subscription, checkPaymentMethod, t]);
+  }, [
+    state.selectedPrice,
+    state.hasPaymentMethod,
+    state.promotionCode,
+    subscription,
+    checkPaymentMethod,
+    lookUpAutomaticCode,
+    t,
+  ]);
 
   const confirmSubscription = useCallback(async () => {
     if (!state.selectedPrice) return;
@@ -181,27 +251,71 @@ export function useSubscriptionWizard({ subscription, onSuccess, onClose }: UseS
     dispatch({ type: "SET_ERROR", error: null });
 
     try {
+      let result: StripeSubscriptionCreateResponse;
       if (subscription) {
         // Change existing subscription
         const changePlanParams = {
           id: subscription.id,
           newPriceId: state.selectedPrice.id,
-          promotionCode: state.promotionCode?.promotionCodeId,
+          promotionCode: promotionCodeToSend(state.promotionCode),
         };
-        await StripeSubscriptionService.changePlan(changePlanParams);
+        result = await StripeSubscriptionService.changePlanWithMeta(changePlanParams);
       } else {
         // Create new subscription
         const createParams = {
           id: v4(),
           priceId: state.selectedPrice.id,
-          promotionCode: state.promotionCode?.promotionCodeId,
+          promotionCode: promotionCodeToSend(state.promotionCode),
         };
-        await StripeSubscriptionService.createSubscription(createParams);
+        result = await StripeSubscriptionService.createSubscription(createParams);
+      }
+
+      // The first payment waits on the browser (confirmation, 3D Secure): until it
+      // is confirmed nothing is paid, so the wizard stays open on a failure
+      const clientSecret = clientSecretToConfirm(result.meta);
+      if (clientSecret) {
+        const confirmation = await confirmPayment(clientSecret);
+        if (!confirmation.success) {
+          console.error("[useSubscriptionWizard] Payment not confirmed:", confirmation.error);
+          dispatch({
+            type: "SET_ERROR",
+            error: t("billing.ui.wizard.errors.payment_not_confirmed", { reason: confirmation.error ?? "" }),
+          });
+          return;
+        }
+
+        // Our copy is still incomplete until the webhooks land: store what Stripe has now,
+        // so the billing page shows the plan at once. A failed sync never blocks success.
+        const subscriptionId = subscriptionIdToSync(result.subscription, subscription);
+        if (subscriptionId) {
+          try {
+            await StripeSubscriptionService.syncSubscription({ subscriptionId });
+          } catch (syncError) {
+            console.error("[useSubscriptionWizard] Subscription sync after payment failed:", syncError);
+          }
+        }
       }
 
       onSuccessRef.current();
       onCloseRef.current();
     } catch (error: any) {
+      // 410 discount_sold_out (the automatic discount's last place has just gone) or
+      // 422 discount_unavailable (the automatic code shown is no longer valid): nothing
+      // was charged. Never retry: drop the code and re-read the automatic one, so the
+      // review shows the price that would really be charged now.
+      const soldOut = isDiscountSoldOut(error);
+      if (soldOut || isDiscountUnavailable(error)) {
+        dispatch({
+          type: "SET_ERROR",
+          error: soldOut
+            ? t("billing.ui.wizard.errors.discount_sold_out")
+            : t("billing.ui.wizard.errors.discount_unavailable"),
+        });
+        dispatch({ type: "SET_PROMOTION_CODE", code: null });
+        await refreshAutomaticCodeOrLeaveReview(state.selectedPrice.id);
+        return;
+      }
+
       // Handle 409 Conflict - duplicate recurring subscription
       if (error?.status === 409 || error?.response?.status === 409) {
         dispatch({
@@ -222,13 +336,14 @@ export function useSubscriptionWizard({ subscription, onSuccess, onClose }: UseS
     } finally {
       dispatch({ type: "SET_PROCESSING", isProcessing: false });
     }
-  }, [state.selectedPrice, state.promotionCode, subscription, t]);
+  }, [state.selectedPrice, state.promotionCode, subscription, refreshAutomaticCodeOrLeaveReview, confirmPayment, t]);
 
   const handlePaymentMethodSuccess = useCallback(async () => {
     dispatch({ type: "SET_HAS_PAYMENT_METHOD", hasMethod: true });
-    // Go back to review to confirm subscription
-    dispatch({ type: "SET_STEP", step: "review" });
-  }, []);
+    // Prepare the review exactly as "Next: Review" does: the trial path sent the GM
+    // here before the automatic-code lookup and the proration preview had run
+    await goToReview();
+  }, [goToReview]);
 
   const reset = useCallback(() => {
     dispatch({ type: "RESET" });
@@ -267,11 +382,22 @@ export function useSubscriptionWizard({ subscription, onSuccess, onClose }: UseS
     [state.selectedPrice?.id, t, locale],
   );
 
-  const clearPromoCode = useCallback(() => {
+  const clearPromoCode = useCallback(async () => {
     dispatch({ type: "SET_PROMOTION_CODE", code: null });
     dispatch({ type: "SET_PROMO_CODE_ERROR", error: null });
     dispatch({ type: "SET_ERROR", error: null });
-  }, []);
+
+    if (!state.selectedPrice) return;
+
+    // Removing a typed code: the server attaches the automatic code again, so the
+    // review must show it again
+    dispatch({ type: "SET_PROCESSING", isProcessing: true });
+    try {
+      await refreshAutomaticCodeOrLeaveReview(state.selectedPrice.id);
+    } finally {
+      dispatch({ type: "SET_PROCESSING", isProcessing: false });
+    }
+  }, [state.selectedPrice, refreshAutomaticCodeOrLeaveReview]);
 
   const actions = useMemo(
     () => ({

package/src/features/billing/stripe-subscription/hooks/wizard-payment.ts

@@ -0,0 +1,30 @@
+import { StripeSubscriptionCreateMeta } from "../data/stripe-subscription.interface";
+
+/**
+ * The client secret the wizard must confirm in the browser after a subscribe
+ * or a trial upgrade, or null when the payment needs nothing more.
+ *
+ * The API creates a subscription with `payment_behavior: "default_incomplete"`:
+ * its first PaymentIntent waits on the browser (`requires_confirmation`, or 3D
+ * Secure). Until it is confirmed nothing is paid and the subscription stays
+ * `incomplete`, so closing the wizard on the API answer alone is wrong.
+ */
+export function clientSecretToConfirm(meta: Partial<StripeSubscriptionCreateMeta> | null | undefined): string | null {
+  if (!meta?.requiresAction) return null;
+  return meta.clientSecret || null;
+}
+
+/**
+ * The subscription to re-read from Stripe after the browser confirmed its first
+ * payment: the one the API just answered with (subscribe), else the one the wizard
+ * was opened on (trial upgrade). Null when there is none to sync.
+ *
+ * Right after the confirmation our copy is still `incomplete` (the webhooks land a
+ * second later), so the billing page would show no plan until a reload.
+ */
+export function subscriptionIdToSync(
+  answered: { id?: string } | null | undefined,
+  opened: { id?: string } | null | undefined,
+): string | null {
+  return answered?.id || opened?.id || null;
+}

package/src/features/billing/stripe-subscription/hooks/wizard-promotion.ts

@@ -0,0 +1,61 @@
+import { PromotionCodeValidationResult } from "../../stripe-promotion-code/data/stripe-promotion-code.interface";
+
+/**
+ * The promotion code the wizard sends to the API: the one the review shows,
+ * typed or automatic. Sending the automatic code too lets the server refuse
+ * the payment when that code is no longer valid, instead of charging a price
+ * the GM was not shown.
+ */
+export function promotionCodeToSend(code: PromotionCodeValidationResult | null): string | undefined {
+  if (!code) return undefined;
+  return code.promotionCodeId;
+}
+
+/**
+ * True when the wizard should ask for the automatic code: no code yet, or the
+ * current one is automatic. A code the GM typed always wins.
+ */
+export function shouldLookUpAutomatic(code: PromotionCodeValidationResult | null): boolean {
+  return !code || code.automatic === true;
+}
+
+/** `value[key]` when `value` is an object, else undefined. */
+function read(value: unknown, key: string): unknown {
+  return typeof value === "object" && value !== null ? Reflect.get(value, key) : undefined;
+}
+
+function errorStatus(error: unknown): number | undefined {
+  const status = read(error, "status") ?? read(read(error, "response"), "status");
+  return typeof status === "number" ? status : undefined;
+}
+
+/**
+ * The `code` of an API error. The nestjs-neo4jsonapi `HttpExceptionFilter`
+ * answers with a JSON:API error document, which `AbstractService.callApi`
+ * attaches to the thrown error as `body`:
+ * `{ message, errors: [{ status, code, title, detail, meta: { context: { code } } }] }`.
+ */
+function errorCode(error: unknown): string | undefined {
+  const body = read(error, "body");
+  const errors = read(body, "errors");
+  const first = Array.isArray(errors) ? errors[0] : undefined;
+  const code = read(first, "code") ?? read(read(read(first, "meta"), "context"), "code") ?? read(body, "code");
+  return typeof code === "string" ? code : undefined;
+}
+
+/**
+ * True when the API refused the payment because the automatic discount has no
+ * places left (HTTP 410, code `discount_sold_out`). Nothing was charged.
+ */
+export function isDiscountSoldOut(error: unknown): boolean {
+  return errorStatus(error) === 410 && errorCode(error) === "discount_sold_out";
+}
+
+/**
+ * True when the API refused the payment because the automatic code the review
+ * showed is no longer valid (HTTP 422, code `discount_unavailable`). Nothing was
+ * charged.
+ */
+export function isDiscountUnavailable(error: unknown): boolean {
+  return errorStatus(error) === 422 && errorCode(error) === "discount_unavailable";
+}

package/src/features/user/contexts/CurrentUserContext.tsx

@@ -225,6 +225,31 @@ export const CurrentUserProvider = ({ children }: { children: React.ReactNode })
   // Track refresh in progress to prevent duplicate API calls
   const isRefreshingRef = useRef(false);
 
+  // Revalidate the cached user each time the live connection comes up.
+  //
+  // The cache above is trusted on mount, and changes reach an open page through
+  // `company:subscription_updated`. A change made while no page was connected
+  // (the browser closed when a Stripe webhook ended the subscription) never
+  // arrives, so the cache kept the old company until a token refresh: the sidebar
+  // hid "Upgrade" for a company that no longer had a plan, across reloads. The
+  // moment the connection comes up (page load, or back from a network drop) is
+  // exactly when such an event may have been missed, so re-read the user once.
+  const wasConnectedRef = useRef(false);
+  useEffect(() => {
+    if (!isConnected) {
+      wasConnectedRef.current = false;
+      return;
+    }
+    if (wasConnectedRef.current) return;
+    wasConnectedRef.current = true;
+
+    if (!getCookie("token") || isRefreshingRef.current) return;
+    isRefreshingRef.current = true;
+    refreshUserRef.current({ skipCookieUpdate: true }).finally(() => {
+      isRefreshingRef.current = false;
+    });
+  }, [isConnected]);
+
   // Listen for company WebSocket events that trigger user refresh
   useEffect(() => {
     if (!socket || !isConnected || !currentUser?.company?.id) {

package/src/features/user/contexts/__tests__/CurrentUserContext.spec.tsx

@@ -21,6 +21,8 @@ const permissionsMock = vi.hoisted(() => ({
 const socketMock = vi.hoisted(() => {
   const handlers: Record<string, ((data: any) => void)[]> = {};
   return {
+    // Read on every render, so a test can drop and restore the live connection
+    isConnected: false,
     socket: {
       on: (event: string, handler: (data: any) => void) => {
         (handlers[event] ??= []).push(handler);
@@ -39,7 +41,7 @@ const socketMock = vi.hoisted(() => {
 });
 
 vi.mock("../../../../contexts/SocketContext", () => ({
-  useSocketContext: () => ({ socket: socketMock.socket, isConnected: true }),
+  useSocketContext: () => ({ socket: socketMock.socket, isConnected: socketMock.isConnected }),
 }));
 
 vi.mock("../../../../core", () => {
@@ -113,6 +115,8 @@ describe("CurrentUserProvider", () => {
   beforeEach(() => {
     localStorage.clear();
     vi.clearAllMocks();
+    socketMock.reset();
+    socketMock.isConnected = false;
   });
 
   it("keeps user hydrated from localStorage when token cookie is absent", async () => {
@@ -161,7 +165,7 @@ describe("CurrentUserProvider", () => {
     expect(updateToken).not.toHaveBeenCalled();
   });
 
-  it("does not hit the API when localStorage already holds the user", async () => {
+  it("does not hit the API on mount when localStorage already holds the user and no live connection is up", async () => {
     vi.mocked(getCookie).mockImplementation((name: any) => (name === "token" ? "jwt" : undefined));
     localStorage.setItem("user", JSON.stringify({ id: "cached", roles: [], company: null, modules: [] }));
 
@@ -239,6 +243,117 @@ describe("CurrentUserProvider", () => {
   });
 });
 
+describe("CurrentUserProvider live connection revalidation", () => {
+  const ACTIVE = { id: "user-1", roles: [], modules: [], company: { id: "company-1", isActiveSubscription: true } };
+  const ENDED = { id: "user-1", roles: [], modules: [], company: { id: "company-1", isActiveSubscription: false } };
+
+  function SubscriptionConsumer() {
+    const { company } = useCurrentUserContext();
+    return <div data-testid="active">{company ? String((company as any).isActiveSubscription) : "null"}</div>;
+  }
+
+  beforeEach(() => {
+    localStorage.clear();
+    socketMock.reset();
+    vi.clearAllMocks();
+    vi.mocked(getCookie).mockImplementation((name: any) => (name === "token" ? "jwt" : undefined));
+    vi.mocked(UserService.findFullUser).mockResolvedValue({ ...ENDED, dehydrate: () => ENDED } as any);
+  });
+
+  it("re-reads the user when the live connection comes up, so a change missed while no page was open shows", async () => {
+    // The subscription ended (Stripe webhook) while the browser was closed: the cache still says active
+    localStorage.setItem("user", JSON.stringify(ACTIVE));
+    socketMock.isConnected = true;
+
+    const { getByTestId } = render(
+      <CurrentUserProvider>
+        <SubscriptionConsumer />
+      </CurrentUserProvider>,
+    );
+
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+
+    expect(UserService.findFullUser).toHaveBeenCalledTimes(1);
+    expect(getByTestId("active").textContent).toBe("false");
+  });
+
+  it("re-reads once per connection, not on every render", async () => {
+    localStorage.setItem("user", JSON.stringify(ACTIVE));
+    socketMock.isConnected = true;
+
+    const { rerender } = render(
+      <CurrentUserProvider>
+        <SubscriptionConsumer />
+      </CurrentUserProvider>,
+    );
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+    rerender(
+      <CurrentUserProvider>
+        <SubscriptionConsumer />
+      </CurrentUserProvider>,
+    );
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+
+    expect(UserService.findFullUser).toHaveBeenCalledTimes(1);
+  });
+
+  it("re-reads again after the connection drops and comes back", async () => {
+    localStorage.setItem("user", JSON.stringify(ACTIVE));
+    socketMock.isConnected = true;
+
+    const tree = (
+      <CurrentUserProvider>
+        <SubscriptionConsumer />
+      </CurrentUserProvider>
+    );
+    const { rerender } = render(tree);
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+
+    socketMock.isConnected = false;
+    rerender(
+      <CurrentUserProvider>
+        <SubscriptionConsumer />
+      </CurrentUserProvider>,
+    );
+    socketMock.isConnected = true;
+    rerender(
+      <CurrentUserProvider>
+        <SubscriptionConsumer />
+      </CurrentUserProvider>,
+    );
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+
+    expect(UserService.findFullUser).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not re-read without a session cookie", async () => {
+    vi.mocked(getCookie).mockReturnValue(undefined);
+    localStorage.setItem("user", JSON.stringify(ACTIVE));
+    socketMock.isConnected = true;
+
+    render(
+      <CurrentUserProvider>
+        <SubscriptionConsumer />
+      </CurrentUserProvider>,
+    );
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    });
+
+    expect(UserService.findFullUser).not.toHaveBeenCalled();
+  });
+});
+
 describe("CurrentUserProvider token updates", () => {
   const STORED_USER = {
     id: "user-1",
@@ -265,6 +380,9 @@ describe("CurrentUserProvider token updates", () => {
     localStorage.clear();
     socketMock.reset();
     vi.clearAllMocks();
+    // Connected, with no session cookie: these tests are about socket events, not the reconnect re-read
+    socketMock.isConnected = true;
+    vi.mocked(getCookie).mockReturnValue(undefined);
   });
 
   it("patches balances from company:credits_updated without refetching the user", async () => {
@@ -352,6 +470,7 @@ describe("CurrentUserProvider path permissions", () => {
   beforeEach(() => {
     localStorage.clear();
     vi.clearAllMocks();
+    socketMock.isConnected = false;
     ctx = undefined;
     permissionsMock.checkPermissions.mockImplementation(() => true);
   });