@carlonicora/nextjs-jsonapi 5.5.0 → 5.6.0

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,54 @@
+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;
+}
+
+function errorStatus(error: any): number | undefined {
+  return error?.status ?? error?.response?.status;
+}
+
+/**
+ * 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: any): string | undefined {
+  const body = error?.body;
+  const first = body?.errors?.[0];
+  const code = first?.code ?? first?.meta?.context?.code ?? 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: any): 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: any): 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);
   });