@tuturuuu/ui 0.37.2 → 0.39.0

package/src/components/ui/finance/invoices/subscription-invoice.tsx

@@ -1,14 +1,12 @@
 'use client';
 
 import { useQueryClient } from '@tanstack/react-query';
-import { AlertTriangle, Calculator, Loader2, Plus } from '@tuturuuu/icons';
+import { AlertTriangle, Calculator, Plus } from '@tuturuuu/icons';
 import { Button } from '@tuturuuu/ui/button';
 import { Card, CardContent, CardHeader, CardTitle } from '@tuturuuu/ui/card';
 import { Separator } from '@tuturuuu/ui/separator';
-import { toast } from '@tuturuuu/ui/sonner';
 import { resolveSupportedCurrency } from '@tuturuuu/utils/currencies';
 import { shouldLockFinanceWalletSelectionOnCreate } from '@tuturuuu/utils/finance';
-import { useRouter } from 'next/navigation';
 import { useLocale, useTranslations } from 'next-intl';
 import { parseAsArrayOf, parseAsString, useQueryState } from 'nuqs';
 import {
@@ -20,7 +18,6 @@ import {
   useState,
 } from 'react';
 import { useDebounce } from '../../../../hooks/use-debounce';
-import { useFinanceHref } from '../finance-route-context';
 import { FinancePermissionWarningDialog } from '../shared/finance-permission-warning-dialog';
 import { useFinanceConfidentialVisibility } from '../shared/use-finance-confidential-visibility';
 import { InvoiceBlockedState } from './components/invoice-blocked-state';
@@ -34,6 +31,7 @@ import {
   isPermissionRequestError,
 } from './components/invoice-products-permission-warning';
 import { SubscriptionAttendanceSummary } from './components/subscription-attendance-summary';
+import { SubscriptionCreateAction } from './components/subscription-create-action';
 import { SubscriptionGroupSelector } from './components/subscription-group-selector';
 import { SubscriptionInvoiceProposal } from './components/subscription-invoice-proposal';
 import { SubscriptionPrepaidControls } from './components/subscription-prepaid-controls';
@@ -57,12 +55,17 @@ import { useBestPromotionSelection } from './hooks/use-best-promotion-selection'
 import { useInvoiceRounding } from './hooks/use-invoice-rounding';
 import { useInvoiceSubtotal } from './hooks/use-invoice-subtotal';
 import { useSubscriptionAutoSelection } from './hooks/use-subscription-auto-selection';
+import { useSubscriptionCreate } from './hooks/use-subscription-create';
 import { useSubscriptionInvoiceContent } from './hooks/use-subscription-invoice-content';
-import { createSubscriptionInvoiceWithInternalApi } from './internal-api';
-import { formatInvoiceRecalculationDescription } from './invoice-visibility-format';
 import { ProductSelection } from './product-selection';
-import { invalidateInvoiceMutationQueries } from './query-invalidation';
-import { useSubscriptionBillingGroups } from './subscription-billing-groups';
+import {
+  getSubscriptionBlockReason,
+  isSelectedSubscriptionRangePaid,
+} from './subscription-admission';
+import {
+  getBillingScheduleWindow,
+  useSubscriptionBillingGroups,
+} from './subscription-billing-groups';
 import type { SubscriptionInvoiceProps } from './subscription-invoice-props';
 import type { SelectedProductItem } from './types';
 import {
@@ -78,7 +81,6 @@ import {
   getGroupsDateRange,
   getMonthStartDate,
   getSubscriptionAttendanceDisplayData,
-  isSubscriptionRangeFullyPaidForGroups,
   PREPAID_MONTH_OPTION_HORIZON,
   resolveSubscriptionInvoiceCategoryId,
 } from './utils';
@@ -103,12 +105,10 @@ export function SubscriptionInvoice({
 }: SubscriptionInvoiceProps) {
   const t = useTranslations();
   const locale = useLocale();
+  const queryClient = useQueryClient();
   const defaultCurrency = resolveSupportedCurrency(rawDefaultCurrency);
   const { isConfidential: areNumbersHidden } =
     useFinanceConfidentialVisibility();
-  const router = useRouter();
-  const queryClient = useQueryClient();
-  const financeHref = useFinanceHref();
 
   const [selectedUserId, setSelectedUserId] = useQueryState('user_id', {
     defaultValue: '',
@@ -242,7 +242,6 @@ export function SubscriptionInvoice({
 
   const [invoiceContent, setInvoiceContent] = useState<string>('');
   const [invoiceNotes, setInvoiceNotes] = useState<string>('');
-  const [isCreating, setIsCreating] = useState(false);
   const [createPromotionOpen, setCreatePromotionOpen] = useState(false);
 
   const prevUserIdRef = useRef<string | null>(null);
@@ -334,10 +333,15 @@ export function SubscriptionInvoice({
   const userAttendance = subscriptionInvoiceContext?.attendance ?? [];
   const latestSubscriptionInvoices =
     subscriptionInvoiceContext?.latestInvoices ?? [];
+  const scheduleWindow = useMemo(
+    () => getBillingScheduleWindow(effectiveSelectedMonth, prepaidMonthCount),
+    [effectiveSelectedMonth, prepaidMonthCount]
+  );
   const { billingUserGroups, groupsWithScheduleIds } =
     useSubscriptionBillingGroups(
       userGroups,
-      subscriptionInvoiceContext?.scheduledSessionsByGroupId
+      subscriptionInvoiceContext?.scheduledSessionsByGroupId,
+      scheduleWindow
     );
   const userAttendanceError =
     subscriptionInvoiceContextError instanceof Error
@@ -365,27 +369,12 @@ export function SubscriptionInvoice({
     [effectiveSelectedMonth, locale, prepaidMonthCount]
   );
 
-  const isSelectedRangePaid = useMemo(() => {
-    if (selectedGroupIds.length === 0 || !effectiveSelectedMonth) return false;
-
-    const selectedMonthStart = getMonthStartDate(effectiveSelectedMonth);
-
-    // A range is paid only if all selected groups have coverage for every month.
-    // If any selected group has an unpaid month, invoice creation stays enabled.
-    if (Number.isNaN(selectedMonthStart.getTime())) return false;
-
-    return isSubscriptionRangeFullyPaidForGroups(
-      selectedGroupIds,
-      effectiveSelectedMonth,
-      prepaidMonthCount,
-      latestSubscriptionInvoices
-    );
-  }, [
+  const isSelectedRangePaid = isSelectedSubscriptionRangePaid(
+    selectedGroupIds,
     effectiveSelectedMonth,
-    latestSubscriptionInvoices,
     prepaidMonthCount,
-    selectedGroupIds,
-  ]);
+    latestSubscriptionInvoices
+  );
 
   const billableAttendance = useMemo(
     () =>
@@ -539,7 +528,7 @@ export function SubscriptionInvoice({
     return map;
   }, [referralDiscountRows]);
 
-  useSubscriptionAutoSelection({
+  const autoSelection = useSubscriptionAutoSelection({
     enabled: true,
     selectedGroupIds,
     selectedMonth: effectiveSelectedMonth,
@@ -770,37 +759,30 @@ export function SubscriptionInvoice({
       : currentIndex < availableMonths.length - 1;
   };
 
-  const handleCreateSubscriptionInvoice = async () => {
-    if (
-      !selectedUser ||
-      selectedGroupIdsForCreate.length === 0 ||
-      subscriptionSelectedProducts.length === 0 ||
-      !selectedWalletId ||
-      !selectedCategoryId
-    ) {
-      toast(t('ws-invoices.create_subscription_invoice_validation'));
-      return;
-    }
-
-    const productsPayload = subscriptionSelectedProducts
-      .filter((item) => item.quantity > 0)
-      .map((item) => ({
-        product_id: item.product.id,
-        unit_id: item.inventory.unit_id,
-        warehouse_id: item.inventory.warehouse_id,
-        quantity: item.quantity,
-        price: item.inventory.price,
-        category_id: item.product.category_id,
-      }));
-
-    if (productsPayload.length === 0) {
-      toast(t('ws-invoices.no_products_to_invoice'));
-      return;
-    }
-
-    setIsCreating(true);
-    try {
-      const result = await createSubscriptionInvoiceWithInternalApi(wsId, {
+  const blockedReason = getSubscriptionBlockReason(
+    autoSelection?.blocked ?? false,
+    !!scheduleWindow,
+    isLoadingSubscriptionData || productsLoading,
+    [
+      subscriptionInvoiceContextError,
+      groupProductsError,
+      productsError,
+      userGroupsError,
+    ],
+    selectedGroupIds,
+    subscriptionInvoiceContext?.scheduledSessionsByGroupId
+  );
+  const checkoutReady = !!(
+    selectedUser &&
+    selectedGroupIdsForCreate.length &&
+    subscriptionSelectedProducts.length &&
+    selectedWalletId &&
+    selectedCategoryId
+  );
+  const { submit: handleCreateSubscriptionInvoice, creating: isCreating } =
+    useSubscriptionCreate({
+      wsId,
+      payload: {
         customer_id: selectedUserId,
         group_ids: selectedGroupIdsForCreate,
         selected_month: effectiveSelectedMonth,
@@ -809,45 +791,32 @@ export function SubscriptionInvoice({
         wallet_id: selectedWalletId,
         promotion_id:
           selectedPromotionId !== 'none' ? selectedPromotionId : undefined,
-        products: productsPayload,
+        products: subscriptionSelectedProducts
+          .filter((item) => item.quantity > 0)
+          .map((item) => ({
+            product_id: item.product.id,
+            unit_id: item.inventory.unit_id,
+            warehouse_id: item.inventory.warehouse_id,
+            quantity: item.quantity,
+            price: item.inventory.price,
+            category_id: item.product.category_id,
+          })),
         category_id: selectedCategoryId,
         frontend_subtotal: subtotal,
         frontend_discount_amount: discountAmount,
         frontend_total: subscriptionRoundedTotal,
         prepaid_month_count: prepaidMonthCount,
-      });
-      void invalidateInvoiceMutationQueries(queryClient, wsId);
-
-      if (result.data?.values_recalculated) {
-        const { calculated_values, frontend_values } = result.data;
-
-        toast(t('ws-invoices.subscription_invoice_created_recalculated'), {
-          description: formatInvoiceRecalculationDescription({
-            areNumbersHidden,
-            calculatedTotal: calculated_values.total,
-            currency: defaultCurrency,
-            frontendTotal: frontend_values?.total || 0,
-            roundingApplied: calculated_values.rounding_applied,
-            t,
-          }),
-          duration: 5000,
-        });
-      } else {
-        toast(
-          t('ws-invoices.subscription_invoice_created_success', {
-            invoiceId: result.invoice_id,
-          })
-        );
-      }
-
-      if (!createMultipleInvoices) {
-        const queryParams = new URLSearchParams();
-        if (printAfterCreate) queryParams.set('print', 'true');
-        if (downloadImageAfterCreate) queryParams.set('image', 'true');
-        router.push(
-          `/${wsId}${financeHref(`/invoices/${result.invoice_id}`)}${queryParams.toString() ? `?${queryParams.toString()}` : ''}`
-        );
-      } else {
+      },
+      options: {
+        createMultipleInvoices,
+        printAfterCreate,
+        downloadImageAfterCreate,
+      },
+      blockedReason,
+      checkoutReady,
+      areNumbersHidden,
+      currency: defaultCurrency,
+      onReset: () => {
         setSubscriptionSelectedProducts([]);
         setSelectedPromotionId('none');
         setInvoiceContent('');
@@ -859,20 +828,8 @@ export function SubscriptionInvoice({
         setSelectedGroupIds(null);
         setPrepaidMonthCount(1);
         setCustomerSearch('');
-      }
-    } catch (error) {
-      toast(
-        t('ws-invoices.error_creating_subscription_invoice', {
-          error:
-            error instanceof Error
-              ? error.message
-              : t('ws-invoices.failed_to_create_subscription_invoice'),
-        })
-      );
-    } finally {
-      setIsCreating(false);
-    }
-  };
+      },
+    });
 
   if (
     isLoadingData ||
@@ -1158,28 +1115,12 @@ export function SubscriptionInvoice({
                         currency={defaultCurrency}
                       />
 
-                      <Button
-                        className="w-full"
-                        onClick={handleCreateSubscriptionInvoice}
-                        disabled={
-                          !selectedUser ||
-                          selectedGroupIds.length === 0 ||
-                          subscriptionSelectedProducts.length === 0 ||
-                          !selectedWalletId ||
-                          !selectedCategoryId ||
-                          isCreating ||
-                          isSelectedRangePaid
-                        }
-                      >
-                        {isCreating ? (
-                          <>
-                            <Loader2 className="mr-2 h-4 w-4 animate-spin" />
-                            {t('ws-invoices.creating_subscription_invoice')}
-                          </>
-                        ) : (
-                          t('ws-invoices.create_subscription_invoice')
-                        )}
-                      </Button>
+                      <SubscriptionCreateAction
+                        onCreate={handleCreateSubscriptionInvoice}
+                        blockedReason={blockedReason}
+                        creating={isCreating}
+                        disabled={!checkoutReady || isSelectedRangePaid}
+                      />
                     </div>
                   </CardContent>
                 </Card>

package/src/components/ui/finance/invoices/types.ts

@@ -83,11 +83,11 @@ export interface UserGroupProducts {
     name: string | null;
     product_categories: {
       name: string | null;
-    };
-  };
+    } | null;
+  } | null;
   inventory_units: {
     name: string | null;
     id: string;
-  };
+  } | null;
   warehouse_id: string | null;
 }

package/src/components/ui/finance/invoices/user-groups-actor.test.tsx

@@ -0,0 +1,334 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, cleanup, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  useWorkspaceActor,
+  WorkspaceVisibilityProvider,
+} from '../../../../hooks/use-workspace-visibility';
+import { useSubscriptionInvoiceContext, useUserGroups } from './hooks';
+import { invalidateInvoiceMutationQueries } from './query-invalidation';
+import type { UserGroup } from './utils';
+
+function context(owner: string): UserGroup[] {
+  return [
+    {
+      workspace_user_groups: {
+        archived: false,
+        cert_template: 'original',
+        created_at: null,
+        creator_id: null,
+        description: null,
+        is_course_published: false,
+        is_guest: false,
+        notes: null,
+        ws_id: 'ws-1',
+        id: 'group-1',
+        name: owner,
+        starting_date: null,
+        ending_date: null,
+        sessions: ['2026-09-01'],
+      },
+    },
+  ];
+}
+function reply(owner: string) {
+  return new Response(JSON.stringify(context(owner)), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+}
+function held() {
+  let resolve!: (response: Response) => void;
+  let reject!: (error: Error) => void;
+  const promise = new Promise<Response>((yes, no) => {
+    resolve = yes;
+    reject = no;
+  });
+  return { promise, resolve, reject };
+}
+const transport = vi.fn();
+let observedQuery: ReturnType<typeof useUserGroups>;
+let actorLease: ReturnType<typeof useWorkspaceActor>;
+function Probe({ wsId, customerId }: { wsId: string; customerId: string }) {
+  actorLease = useWorkspaceActor();
+  const query = useUserGroups(wsId, customerId);
+  observedQuery = query;
+  return (
+    <output aria-label="Synthetic context owner">
+      {query.data?.[0]?.workspace_user_groups?.name ?? 'pending'}
+    </output>
+  );
+}
+function mount() {
+  // Matches satellite ClientProviders: the QueryClient survives actor remounts.
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  const view = (actor: string, wsId: string, customerId: string) => (
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId={actor}>
+        <Probe wsId={wsId} customerId={customerId} />
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  const result = render(view('account-A', 'ws-1', 'customer-1'));
+  return {
+    ...result,
+    client,
+    redraw: (actor = 'account-A', ws = 'ws-1', customer = 'customer-1') =>
+      result.rerender(view(actor, ws, customer)),
+  };
+}
+async function displayed(owner: string) {
+  await waitFor(() =>
+    expect(screen.getByLabelText('Synthetic context owner')).toHaveTextContent(
+      owner
+    )
+  );
+}
+afterEach(() => {
+  cleanup();
+  vi.unstubAllGlobals();
+});
+beforeEach(() => {
+  transport.mockReset();
+  transport.mockImplementation(() => Promise.resolve(reply('account-A')));
+  vi.stubGlobal('fetch', transport);
+});
+
+describe('actual user groups transport and shared cache actor lifetime', () => {
+  it('reauthorizes a fresh account-A context after changing to account-B at identical coordinates', async () => {
+    const view = mount();
+    await displayed('account-A');
+    const expired = actorLease;
+    transport.mockImplementation(() => Promise.resolve(reply('account-B')));
+    view.redraw('account-B');
+    expect(() => expired?.assertActive()).toThrow('Workspace account changed');
+    await waitFor(() => expect(transport).toHaveBeenCalledTimes(2));
+    await displayed('account-B');
+    expect(transport.mock.calls[0]?.[0]).toContain(
+      '/api/v1/workspaces/ws-1/users/customer-1/user-groups'
+    );
+    expect(transport.mock.calls[1]?.[1]).toEqual(
+      expect.objectContaining({
+        cache: 'no-store',
+        signal: expect.any(AbortSignal),
+      })
+    );
+  });
+  it('does not deliver an old account-A held transport into the account-B observer or cache', async () => {
+    const old = held();
+    transport
+      .mockReturnValueOnce(old.promise)
+      .mockImplementation(() => Promise.resolve(reply('account-B')));
+    const view = mount();
+    await waitFor(() => expect(transport).toHaveBeenCalledOnce());
+    const expired = actorLease;
+    view.redraw('account-B');
+    expect(() => expired?.assertActive()).toThrow('Workspace account changed');
+    await act(async () => {
+      old.resolve(reply('account-A'));
+      await old.promise;
+    });
+    await waitFor(() => expect(transport).toHaveBeenCalledTimes(2));
+    await displayed('account-B');
+    expect(
+      view.client
+        .getQueryCache()
+        .getAll()
+        .filter(
+          (entry) =>
+            entry.queryKey[0] === 'user-groups' && entry.getObserversCount() > 0
+        )
+        .map((entry) => entry.state.data)
+    ).toEqual([context('account-B')]);
+  });
+  it('reuses fresh context inside the same actor lifetime', async () => {
+    const view = mount();
+    await displayed('account-A');
+    view.redraw();
+    await displayed('account-A');
+    expect(transport).toHaveBeenCalledOnce();
+  });
+  for (const boundary of ['workspace', 'customer'] as const) {
+    it(`keeps same-actor ${boundary} contexts distinct`, async () => {
+      const view = mount();
+      await displayed('account-A');
+      transport.mockImplementation(() =>
+        Promise.resolve(reply('other-context'))
+      );
+      view.redraw(
+        'account-A',
+        boundary === 'workspace' ? 'ws-2' : 'ws-1',
+        boundary === 'customer' ? 'customer-2' : 'customer-1'
+      );
+      await displayed('other-context');
+      expect(transport).toHaveBeenCalledTimes(2);
+      const url = new URL(transport.mock.calls[1]?.[0], window.location.origin);
+      expect(url.pathname).toContain(
+        boundary === 'workspace' ? '/workspaces/ws-2/' : '/workspaces/ws-1/'
+      );
+      expect(url.pathname).toContain(
+        `/users/${boundary === 'customer' ? 'customer-2' : 'customer-1'}/user-groups`
+      );
+    });
+  }
+  for (const outcome of ['success', 'error'] as const) {
+    it(`rejects held old actor ${outcome} after account ABA`, async () => {
+      const old = held();
+      transport
+        .mockReturnValueOnce(old.promise)
+        .mockImplementation(() => Promise.resolve(reply('new-lifetime')));
+      const view = mount();
+      await waitFor(() => expect(transport).toHaveBeenCalledOnce());
+      const expired = actorLease;
+      view.redraw('account-B');
+      await displayed('new-lifetime');
+      view.redraw('account-A');
+      await displayed('new-lifetime');
+      expect(transport).toHaveBeenCalledTimes(3);
+      expect(() => expired?.assertActive()).toThrow(
+        'Workspace account changed'
+      );
+      await act(async () => {
+        if (outcome === 'success') old.resolve(reply('expired-lifetime'));
+        else old.reject(new Error('Synthetic expired transport failure'));
+        await old.promise.catch(() => {});
+      });
+      await displayed('new-lifetime');
+      await waitFor(() =>
+        expect(
+          view.client
+            .getQueryCache()
+            .getAll()
+            .find((entry) => entry.state.error)?.state.error
+        ).toEqual(new Error('Workspace account changed'))
+      );
+      expect(
+        view.client
+          .getQueryCache()
+          .getAll()
+          .filter((entry) => entry.getObserversCount() > 0)
+          .map((entry) => entry.state.data)
+      ).toEqual([context('new-lifetime')]);
+    });
+  }
+  it('requires a verified actor for automatic and manual reads', async () => {
+    const client = new QueryClient();
+    render(
+      <QueryClientProvider client={client}>
+        <Probe wsId="ws-1" customerId="customer-1" />
+      </QueryClientProvider>
+    );
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(transport).not.toHaveBeenCalled();
+    let manualResult!: Awaited<ReturnType<typeof observedQuery.refetch>>;
+    await act(async () => {
+      manualResult = await observedQuery.refetch();
+    });
+    expect(manualResult.error).toEqual(
+      new Error('Workspace account unavailable')
+    );
+    expect(transport).not.toHaveBeenCalled();
+  });
+  it('preserves current actor transport error and explicit retry', async () => {
+    transport.mockRejectedValueOnce(
+      new Error('Synthetic current transport failure')
+    );
+    mount();
+    await waitFor(() =>
+      expect(observedQuery.error).toEqual(
+        new Error('Synthetic current transport failure')
+      )
+    );
+    expect(transport).toHaveBeenCalledOnce();
+    transport.mockImplementation(() => Promise.resolve(reply('recovered')));
+    await act(async () => {
+      await observedQuery.refetch();
+    });
+    await displayed('recovered');
+    expect(transport).toHaveBeenCalledTimes(2);
+  });
+  it('retains workspace-prefix refetch and existing invoice invalidation exclusions', async () => {
+    const view = mount();
+    await displayed('account-A');
+    transport.mockImplementation(() => Promise.resolve(reply('refreshed')));
+    await act(async () => {
+      await invalidateInvoiceMutationQueries(view.client, 'ws-1');
+    });
+    expect(transport).toHaveBeenCalledOnce();
+    await act(async () => {
+      await view.client.invalidateQueries({
+        queryKey: ['user-groups', 'ws-1'],
+      });
+    });
+    await displayed('refreshed');
+    expect(transport).toHaveBeenCalledTimes(2);
+  });
+  it('shares the same permanent actor token with the actual context hook', async () => {
+    function Both() {
+      useUserGroups('ws-1', 'customer-1');
+      useSubscriptionInvoiceContext(
+        'ws-1',
+        'customer-1',
+        ['group-1'],
+        '2026-09'
+      );
+      return null;
+    }
+    transport.mockImplementation((url: string) =>
+      Promise.resolve(
+        url.includes('/finance/invoices/')
+          ? new Response(
+              JSON.stringify({
+                attendance: [],
+                latestInvoices: [],
+                scheduledSessionsByGroupId: {},
+              }),
+              { status: 200 }
+            )
+          : reply('shared')
+      )
+    );
+    const client = new QueryClient();
+    const content = (actor: string) => (
+      <QueryClientProvider client={client}>
+        <WorkspaceVisibilityProvider actorId={actor}>
+          <Both />
+        </WorkspaceVisibilityProvider>
+      </QueryClientProvider>
+    );
+    const view = render(content('account-A'));
+    await waitFor(() =>
+      expect(
+        client
+          .getQueryCache()
+          .getAll()
+          .filter((entry) => entry.state.status === 'success')
+      ).toHaveLength(2)
+    );
+    const keys = client
+      .getQueryCache()
+      .getAll()
+      .map((entry) => entry.queryKey);
+    const original = keys.find((key) => key[0] === 'user-groups')?.[4];
+    expect(original).toEqual(
+      keys.find((key) => key[0] === 'subscription-invoice-context')?.[7]
+    );
+    view.rerender(content('account-B'));
+    await waitFor(() => expect(transport).toHaveBeenCalledTimes(4));
+    const active = client
+      .getQueryCache()
+      .getAll()
+      .filter((entry) => entry.getObserversCount() > 0)
+      .map((entry) => entry.queryKey);
+    expect(active.find((key) => key[0] === 'user-groups')?.[4]).toEqual(
+      active.find((key) => key[0] === 'subscription-invoice-context')?.[7]
+    );
+    expect(active.find((key) => key[0] === 'user-groups')?.[4]).not.toEqual(
+      original
+    );
+  });
+});