@decocms/apps-vtex 8.0.0 → 8.1.0-next.1

package/src/commerceLoaders.ts

@@ -1,267 +0,0 @@
-/**
- * Standard VTEX commerce loader map factory for CMS block resolution.
- *
- * Wraps all VTEX loaders with createCachedLoader, applies universal
- * workarounds (slug fallback, IS sort sanitization, map=productClusterIds),
- * and registers both `.ts` and `.ts`-less aliases.
- *
- * Sites call `createVtexCommerceLoaders()` instead of manually wiring ~30
- * individual loader entries. Site-specific loaders are merged via `extra`.
- */
-
-import { createCachedLoader } from "@decocms/blocks/sdk/cachedLoader";
-import type { CacheProfileName } from "@decocms/blocks/sdk/cacheHeaders";
-import { getCategoryTree } from "./loaders/catalog";
-import vtexProductDetailsPage from "./loaders/intelligentSearch/productDetailsPage";
-import vtexProductListShelf from "./loaders/intelligentSearch/productList";
-import vtexProductListingPage from "./loaders/intelligentSearch/productListingPage";
-import vtexSuggestions from "./loaders/intelligentSearch/suggestions";
-import vtexRelatedProducts from "./loaders/legacy/relatedProductsLoader";
-import vtexProductList from "./loaders/productListFull";
-import vtexWorkflowProducts from "./loaders/workflow/products";
-import { registerVtexSchemas } from "./schemas";
-import { VALID_IS_SORTS } from "./utils/intelligentSearch";
-
-export type CommerceLoaderFn = (props: any) => Promise<any>;
-
-export interface VtexCommerceLoadersOptions {
-	/** Override cache profiles per loader type. */
-	cacheProfiles?: {
-		listing?: CacheProfileName;
-		product?: CacheProfileName;
-		search?: CacheProfileName;
-		static?: CacheProfileName;
-	};
-	/** Additional loaders to merge into the map (site-specific). */
-	extra?: Record<string, CommerceLoaderFn>;
-}
-
-/**
- * Bridge __pagePath → slug when CMS doesn't set slug explicitly.
- * VTEX PDP pages receive __pagePath (e.g. "/produto-slug/p") but the
- * inline loader only reads the `slug` field.
- */
-function pdpWithSlugFallback(props: any): Promise<any> {
-	if ((!props.slug || props.slug.length === 0) && props.__pagePath) {
-		props = { ...props, slug: props.__pagePath };
-	}
-	return vtexProductDetailsPage(props);
-}
-
-/**
- * Extract collection name from PLP product data.
- * Products carry cluster info in additionalProperty with name="cluster".
- */
-function extractCollectionName(result: any, collectionId: string): string | null {
-	if (!result?.products?.length) return null;
-	for (const product of result.products) {
-		const props = product.additionalProperty || product.isVariantOf?.additionalProperty || [];
-		for (const prop of props) {
-			if (prop.name === "cluster" && prop.propertyID === collectionId) {
-				return prop.value || null;
-			}
-		}
-	}
-	return null;
-}
-
-/**
- * Returns the standard VTEX commerce loader map for CMS resolution.
- *
- * Includes all Intelligent Search, legacy, category tree, and navbar loaders
- * with SWR caching. Also registers `.ts`-less aliases for invoke compatibility.
- *
- * @example
- * ```ts
- * import { createVtexCommerceLoaders } from "@decocms/apps/vtex/commerceLoaders";
- *
- * const COMMERCE_LOADERS = {
- *   ...createVtexCommerceLoaders(),
- *   // site-specific only:
- *   "site/loaders/myCustomLoader": async (props) => { ... },
- * };
- * registerCommerceLoaders(COMMERCE_LOADERS);
- * ```
- */
-export function createVtexCommerceLoaders(
-	options?: VtexCommerceLoadersOptions,
-): Record<string, CommerceLoaderFn> {
-	// Real props schemas for the admin meta. The stub registration that
-	// registerCommerceLoaders() later performs for this returned map never
-	// overwrites these (real-over-stub precedence in the schema registry).
-	registerVtexSchemas();
-
-	const profiles = {
-		listing: options?.cacheProfiles?.listing ?? "listing",
-		product: options?.cacheProfiles?.product ?? "product",
-		search: options?.cacheProfiles?.search ?? "search",
-		static: options?.cacheProfiles?.static ?? "static",
-	};
-
-	const _cachedProductList = createCachedLoader(
-		"vtex/productList",
-		vtexProductList,
-		profiles.listing,
-	);
-	const cachedProductListShelf = createCachedLoader(
-		"vtex/productListShelf",
-		vtexProductListShelf,
-		profiles.listing,
-	);
-	const cachedPDP = createCachedLoader(
-		"vtex/productDetailsPage",
-		pdpWithSlugFallback,
-		profiles.product,
-	);
-	const _cachedPLP = createCachedLoader(
-		"vtex/productListingPage",
-		vtexProductListingPage,
-		profiles.listing,
-	);
-	const cachedSuggestions = createCachedLoader(
-		"vtex/suggestions",
-		vtexSuggestions,
-		profiles.search,
-	);
-	const cachedRelatedProducts = createCachedLoader(
-		"vtex/relatedProducts",
-		vtexRelatedProducts,
-		profiles.product,
-	);
-	const cachedWorkflowProducts = createCachedLoader(
-		"vtex/workflowProducts",
-		vtexWorkflowProducts,
-		profiles.listing,
-	);
-
-	/**
-	 * PLP wrapper: handles `map=productClusterIds` legacy URLs and sanitizes
-	 * IS sort parameters that would cause VTEX API 400 errors.
-	 */
-	const cachedPLP: CommerceLoaderFn = async (props) => {
-		if (props.__pageUrl && !props.selectedFacets?.length) {
-			try {
-				const pageUrl = new URL(props.__pageUrl, "https://localhost");
-				const mapParam = pageUrl.searchParams.get("map");
-				if (mapParam && props.__pagePath) {
-					const segments = props.__pagePath.split("/").filter(Boolean);
-					const mapValues = mapParam.split(",");
-					const facets: Array<{ key: string; value: string }> = [];
-					for (let i = 0; i < Math.min(segments.length, mapValues.length); i++) {
-						const key = mapValues[i].trim();
-						const value = decodeURIComponent(segments[i]);
-						if (key && value) facets.push({ key, value });
-					}
-					if (facets.length) {
-						const rawSort = pageUrl.searchParams.get("sort") ?? "";
-						const cleanSort = VALID_IS_SORTS.has(rawSort) ? rawSort : "";
-
-						if (rawSort !== cleanSort) {
-							if (cleanSort) {
-								pageUrl.searchParams.set("sort", cleanSort);
-							} else {
-								pageUrl.searchParams.delete("sort");
-							}
-						}
-
-						const result = await _cachedPLP({
-							...props,
-							selectedFacets: facets,
-							sort: cleanSort || undefined,
-							__pageUrl: pageUrl.toString(),
-						});
-
-						const clusterFacet = facets.find((f) => f.key === "productClusterIds");
-						if (result && clusterFacet) {
-							const collectionName = extractCollectionName(result, clusterFacet.value);
-							if (collectionName) {
-								result.breadcrumb = {
-									"@type": "BreadcrumbList",
-									itemListElement: [
-										{
-											"@type": "ListItem",
-											name: collectionName,
-											item: props.__pagePath || "/",
-											position: 1,
-										},
-									],
-									numberOfItems: 1,
-								};
-								result.seo = { ...result.seo, title: collectionName };
-							}
-						}
-						return result;
-					}
-				}
-			} catch (e) {
-				console.error("[PLP] Error parsing map param:", e);
-			}
-		}
-		return _cachedPLP(props);
-	};
-
-	/**
-	 * Related products wrapper: extracts slug from __pagePath when the CMS
-	 * requestToParam stub returns null (standard in TanStack sites).
-	 */
-	const relatedWithSlugFallback: CommerceLoaderFn = (props) => {
-		if (!props.slug && props.__pagePath) {
-			const path = props.__pagePath.replace(/\/p$/, "").replace(/^\//, "");
-			props = { ...props, slug: path };
-		}
-		return cachedRelatedProducts(props);
-	};
-
-	const loaders: Record<string, CommerceLoaderFn> = {
-		// Intelligent Search loaders
-		"vtex/loaders/intelligentSearch/productListingPage.ts": cachedPLP,
-		"vtex/loaders/intelligentSearch/productList.ts": cachedProductListShelf,
-		"vtex/loaders/intelligentSearch/productDetailsPage.ts": cachedPDP,
-		"vtex/loaders/intelligentSearch/suggestions.ts": cachedSuggestions,
-		// Legacy loaders (map to same cached functions)
-		"vtex/loaders/legacy/productDetailsPage.ts": cachedPDP,
-		"vtex/loaders/legacy/productList.ts": cachedProductListShelf,
-		"vtex/loaders/legacy/relatedProductsLoader.ts": relatedWithSlugFallback,
-		// Workflow
-		"vtex/loaders/workflow/products.ts": cachedWorkflowProducts,
-		// Top-level aliases (used by some CMS block configs)
-		"vtex/loaders/ProductList.ts": cachedProductListShelf,
-		"vtex/loaders/ProductDetailsPage.ts": cachedPDP,
-		"vtex/loaders/ProductListingPage.ts": cachedPLP,
-		// Category tree
-		"vtex/loaders/categories/tree": (props: any) => getCategoryTree(props?.categoryLevels ?? 3),
-		// Commerce passthrough loaders
-		"commerce/loaders/navbar.ts": async (props: any) => props.items ?? [],
-		"commerce/loaders/product/extensions/detailsPage.ts": async (props: any) => {
-			const data = props.data;
-			if (data?.product) return data;
-			return cachedPDP({ __pagePath: props.__pagePath });
-		},
-		// requestToParam stub — unresolvable in TanStack, pdpWithSlugFallback bridges it
-		"website/functions/requestToParam.ts": async () => null,
-	};
-
-	// Register .ts-less aliases for invoke compatibility
-	const withAliases: Record<string, CommerceLoaderFn> = { ...loaders };
-	for (const key of Object.keys(loaders)) {
-		if (key.endsWith(".ts")) {
-			withAliases[key.slice(0, -3)] = loaders[key];
-		}
-	}
-
-	if (options?.extra) {
-		Object.assign(withAliases, options.extra);
-	}
-
-	return withAliases;
-}
-
-/**
- * Exposes the cached PDP loader for site-specific section loaders that need
- * to call it directly (e.g. ProductDescription fallback).
- *
- * Returns a new instance each call — sites should cache the reference.
- */
-export function createCachedPDPLoader(profile: CacheProfileName = "product"): CommerceLoaderFn {
-	return createCachedLoader("vtex/productDetailsPage", pdpWithSlugFallback, profile);
-}

package/src/hooks/__tests__/createCart.render.test.ts

@@ -1,114 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Render-based tests for the `createCart` factory (Cart v2).
- *
- * The factory-shape tests in `createCart.test.ts` run in node and never render.
- * These exercise the actual hook behaviour that needs a React renderer:
- * `useAddToCart().add()` returning the server's projected payload (so a caller
- * can drive a toast without a second fetch) and the optimistic badge bump.
- *
- * No `@testing-library/react` in the tree — we hand-roll a tiny render harness
- * on `react-dom/client` (jsdom env, declared in the docblock above).
- */
-
-import type { CartSummaryWithItems } from "@decocms/apps-commerce/types";
-import { act, createElement } from "react";
-import { createRoot } from "react-dom/client";
-import { describe, expect, it } from "vitest";
-import { type CreateCartInvoke, createCart } from "../createCart";
-
-// React's act() requires this flag when driving updates manually.
-(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
-
-function renderHook<T>(useHook: () => T) {
-  const ref = { current: undefined as unknown as T };
-  function Probe() {
-    ref.current = useHook();
-    return null;
-  }
-  const container = document.createElement("div");
-  const root = createRoot(container);
-  act(() => {
-    root.render(createElement(Probe));
-  });
-  return { ref, unmount: () => act(() => root.unmount()) };
-}
-
-/** Fake invoke whose addItemsToCartV2 returns a `summary+items` projection. */
-function makeInvoke(): CreateCartInvoke {
-  const projected: CartSummaryWithItems = {
-    orderFormId: "of-1",
-    totalItems: 1,
-    total: 100,
-    items: [
-      {
-        item_id: "sku-1",
-        item_name: "Camiseta",
-        item_variant: "P Azul",
-        image: "https://img.example/x.jpg",
-        price: 100,
-        quantity: 1,
-      },
-    ],
-  };
-  return {
-    vtex: {
-      actions: {
-        getOrCreateCartV2: async () => ({ orderFormId: "of-1", totalItems: 0, total: 0 }),
-        addItemsToCartV2: async () => projected as never,
-        updateCartItemsV2: async () => ({ ok: true }) as never,
-        addCouponToCartV2: async () => ({ ok: true }) as never,
-      },
-      loaders: {
-        cart: {
-          summary: async () => ({ orderFormId: "of-1", totalItems: 0, total: 0 }),
-          full: async () => ({ original: null }) as never,
-          shipping: async () => ({ postalCode: "00000-000", options: [] }),
-          gifts: async () => ({ orderFormId: "of-1", selectableGifts: [], ratesAndBenefits: null }),
-          attachments: async () => ({
-            orderFormId: "of-1",
-            itemIndex: 0,
-            attachments: [],
-            attachmentOfferings: [],
-          }),
-        },
-      },
-    },
-  };
-}
-
-describe("createCart — useAddToCart.add()", () => {
-  it("returns the projected payload for a toast without a second fetch", async () => {
-    const cart = createCart({ invoke: makeInvoke() });
-    const { ref, unmount } = renderHook(() => cart.useAddToCart());
-
-    let result: unknown;
-    await act(async () => {
-      result = await ref.current.add({ id: "sku-1", seller: "1" });
-    });
-
-    expect(result).toMatchObject({
-      totalItems: 1,
-      total: 100,
-      items: [{ item_name: "Camiseta", item_variant: "P Azul", price: 100 }],
-    });
-    unmount();
-  });
-
-  it("reconciles the summary badge from the projected response", async () => {
-    const cart = createCart({ invoke: makeInvoke() });
-    const add = renderHook(() => cart.useAddToCart());
-    const badge = renderHook(() => cart.useCartSummary());
-
-    expect(badge.ref.current.totalItems).toBe(0);
-
-    await act(async () => {
-      await add.ref.current.add({ id: "sku-1", seller: "1" });
-    });
-
-    // Reconciled from the server projection (1), not just the optimistic bump.
-    expect(badge.ref.current.totalItems).toBe(1);
-    add.unmount();
-    badge.unmount();
-  });
-});

package/src/hooks/__tests__/createCart.test.ts

@@ -1,92 +0,0 @@
-/**
- * Tests for the `createCart` factory (Cart v2).
- *
- * Like `createUseCart`, hook render semantics need a React renderer that
- * apps-start does not pull in, so we cover the factory's shape and instance
- * isolation. The optimistic + reconciliation behaviour is exercised by the
- * site-level smoke test.
- */
-
-import { describe, expect, it, vi } from "vitest";
-import { type CreateCartInvoke, createCart } from "../createCart";
-
-function makeInvoke(): CreateCartInvoke {
-  const summary = async () => ({ orderFormId: "of-1", totalItems: 0, total: 0 });
-  const anyNoop = async () => ({ ok: true }) as never;
-  return {
-    vtex: {
-      actions: {
-        getOrCreateCartV2: async () => ({ orderFormId: "of-1", totalItems: 0, total: 0 }),
-        addItemsToCartV2: anyNoop,
-        updateCartItemsV2: anyNoop,
-        addCouponToCartV2: anyNoop,
-      },
-      loaders: {
-        cart: {
-          summary,
-          full: async () => ({
-            original: null,
-            storefront: {
-              items: [],
-              total: 0,
-              subtotal: 0,
-              discounts: 0,
-              locale: "pt-BR",
-              currency: "BRL",
-              freeShippingTarget: 0,
-              checkoutHref: "/checkout",
-            },
-          }),
-          shipping: async () => ({ postalCode: "00000-000", options: [] }),
-          gifts: async () => ({ orderFormId: "of-1", selectableGifts: [], ratesAndBenefits: null }),
-          attachments: async () => ({
-            orderFormId: "of-1",
-            itemIndex: 0,
-            attachments: [],
-            attachmentOfferings: [],
-          }),
-        },
-      },
-    },
-  };
-}
-
-describe("createCart — factory shape", () => {
-  it("returns the full granular hook set", () => {
-    const cart = createCart({ invoke: makeInvoke() });
-    expect(typeof cart.useCart).toBe("function");
-    expect(typeof cart.useCartSummary).toBe("function");
-    expect(typeof cart.useAddToCart).toBe("function");
-    expect(typeof cart.useShipping).toBe("function");
-    expect(typeof cart.useGifts).toBe("function");
-    expect(typeof cart.useAttachments).toBe("function");
-    expect(typeof cart.resetCart).toBe("function");
-  });
-
-  it("two factory calls produce independent hook identities", () => {
-    const a = createCart({ invoke: makeInvoke() });
-    const b = createCart({ invoke: makeInvoke() });
-    expect(a.useCart).not.toBe(b.useCart);
-    expect(a.useAddToCart).not.toBe(b.useAddToCart);
-    expect(a.resetCart).not.toBe(b.resetCart);
-  });
-
-  it("accepts custom cookie name / max-age without throwing", () => {
-    expect(() =>
-      createCart({
-        invoke: makeInvoke(),
-        orderFormCookieName: "custom_of",
-        orderFormCookieMaxAge: 3600,
-      }),
-    ).not.toThrow();
-  });
-
-  it("does not call any invoke method at construction time (lazy)", () => {
-    const invoke = makeInvoke();
-    const getOrCreate = vi.spyOn(invoke.vtex.actions, "getOrCreateCartV2");
-    const summary = vi.spyOn(invoke.vtex.loaders.cart, "summary");
-    createCart({ invoke });
-    expect(getOrCreate).not.toHaveBeenCalled();
-    expect(summary).not.toHaveBeenCalled();
-  });
-});

package/src/hooks/__tests__/createUseCart.test.ts

@@ -1,184 +0,0 @@
-/**
- * Tests for the `createUseCart` factory.
- *
- * The hook itself depends on React (useState/useEffect), and apps-start
- * does not pull in @testing-library/react. So we test the parts of the
- * factory that don't require a React renderer: shape, isolation, and the
- * pure `itemToAnalyticsItem` helper. Hook semantics are exercised by the
- * site-level integration smoke test (the template has shipped to two
- * production sites).
- */
-
-import { describe, expect, it } from "vitest";
-import { type CreateUseCartInvoke, createUseCart } from "../createUseCart";
-
-function makeInvoke(): CreateUseCartInvoke {
-	const noop = async () => ({ orderFormId: "of-1", items: [] }) as never;
-	return {
-		vtex: {
-			actions: {
-				getOrCreateCart: noop,
-				addItemsToCart: noop,
-				updateCartItems: noop,
-				addCouponToCart: noop,
-				updateOrderFormAttachment: noop,
-				simulateCart: noop,
-			},
-		},
-	};
-}
-
-describe("createUseCart — factory shape", () => {
-	it("returns useCart, resetCart, itemToAnalyticsItem", () => {
-		const cart = createUseCart({ invoke: makeInvoke() });
-		expect(typeof cart.useCart).toBe("function");
-		expect(typeof cart.resetCart).toBe("function");
-		expect(typeof cart.itemToAnalyticsItem).toBe("function");
-	});
-
-	it("two factory calls produce independent itemToAnalyticsItem references", () => {
-		const a = createUseCart({ invoke: makeInvoke() });
-		const b = createUseCart({ invoke: makeInvoke() });
-		// Different closures => different function identities.
-		expect(a.itemToAnalyticsItem).not.toBe(b.itemToAnalyticsItem);
-		expect(a.useCart).not.toBe(b.useCart);
-		expect(a.resetCart).not.toBe(b.resetCart);
-	});
-
-	it("accepts custom orderFormCookieName / maxAge without throwing", () => {
-		expect(() =>
-			createUseCart({
-				invoke: makeInvoke(),
-				orderFormCookieName: "custom_of_id",
-				orderFormCookieMaxAge: 3600,
-			}),
-		).not.toThrow();
-	});
-});
-
-describe("createUseCart — itemToAnalyticsItem", () => {
-	const { itemToAnalyticsItem } = createUseCart({ invoke: makeInvoke() });
-
-	it("maps the canonical fields", () => {
-		const out = itemToAnalyticsItem(
-			{
-				id: "sku-1",
-				productId: "prod-1",
-				name: "Widget",
-				skuName: "Widget Blue",
-				sellingPrice: 1990,
-				price: 2490,
-				listPrice: 2490,
-				quantity: 2,
-				seller: "1",
-				additionalInfo: { brandName: "Acme" },
-			} as never,
-			0,
-		);
-		expect(out).toEqual({
-			item_id: "prod-1",
-			item_group_id: "prod-1",
-			item_name: "Widget",
-			item_variant: "Widget Blue",
-			item_brand: "Acme",
-			price: 19.9,
-			discount: 5,
-			quantity: 2,
-			coupon: undefined,
-			affiliation: "1",
-			index: 0,
-		});
-	});
-
-	it("falls back to skuName when name is missing", () => {
-		const out = itemToAnalyticsItem(
-			{
-				productId: "p",
-				skuName: "Fallback",
-				sellingPrice: 100,
-				listPrice: 100,
-				quantity: 1,
-				seller: "1",
-			} as never,
-			3,
-		);
-		expect(out.item_name).toBe("Fallback");
-		expect(out.index).toBe(3);
-	});
-
-	it("uses price when sellingPrice is missing", () => {
-		const out = itemToAnalyticsItem(
-			{
-				productId: "p",
-				name: "n",
-				price: 1000,
-				listPrice: 1000,
-				quantity: 1,
-				seller: "1",
-			} as never,
-			0,
-		);
-		expect(out.price).toBe(10);
-	});
-
-	it("computes zero discount when listPrice equals sellingPrice", () => {
-		const out = itemToAnalyticsItem(
-			{
-				productId: "p",
-				name: "n",
-				sellingPrice: 500,
-				listPrice: 500,
-				quantity: 1,
-				seller: "1",
-			} as never,
-			0,
-		);
-		expect(out.discount).toBe(0);
-	});
-
-	it("rounds discount to 2 decimal places", () => {
-		const out = itemToAnalyticsItem(
-			{
-				productId: "p",
-				name: "n",
-				sellingPrice: 1000,
-				listPrice: 1333,
-				quantity: 1,
-				seller: "1",
-			} as never,
-			0,
-		);
-		expect(out.discount).toBe(3.33);
-	});
-
-	it("preserves coupon when supplied", () => {
-		const out = itemToAnalyticsItem(
-			{
-				productId: "p",
-				name: "n",
-				sellingPrice: 100,
-				listPrice: 100,
-				quantity: 1,
-				seller: "1",
-				coupon: "SAVE10",
-			} as never,
-			0,
-		);
-		expect(out.coupon).toBe("SAVE10");
-	});
-
-	it("uses empty string brand when additionalInfo is missing", () => {
-		const out = itemToAnalyticsItem(
-			{
-				productId: "p",
-				name: "n",
-				sellingPrice: 100,
-				listPrice: 100,
-				quantity: 1,
-				seller: "1",
-			} as never,
-			0,
-		);
-		expect(out.item_brand).toBe("");
-	});
-});

package/src/hooks/__tests__/createUseUser.test.ts

@@ -1,48 +0,0 @@
-/**
- * Tests for the `createUseUser` factory.
- *
- * Same approach as `createUseCart.test.ts`: apps-start does not pull
- * @testing-library/react, so we test factory shape and isolation. Hook
- * semantics are covered by site-level smoke tests.
- */
-
-import { describe, expect, it } from "vitest";
-import { type CreateUseUserInvoke, createUseUser } from "../createUseUser";
-
-function makeInvoke(): CreateUseUserInvoke {
-	return {
-		vtex: {
-			loaders: {
-				user: async () => null,
-			},
-		},
-	};
-}
-
-describe("createUseUser — factory shape", () => {
-	it("returns useUser, resetUser", () => {
-		const u = createUseUser({ invoke: makeInvoke() });
-		expect(typeof u.useUser).toBe("function");
-		expect(typeof u.resetUser).toBe("function");
-	});
-
-	it("two factory calls produce independent function references", () => {
-		const a = createUseUser({ invoke: makeInvoke() });
-		const b = createUseUser({ invoke: makeInvoke() });
-		expect(a.useUser).not.toBe(b.useUser);
-		expect(a.resetUser).not.toBe(b.resetUser);
-	});
-
-	it("does not throw at construction time even with a failing invoke", () => {
-		const invoke: CreateUseUserInvoke = {
-			vtex: {
-				loaders: {
-					user: async () => {
-						throw new Error("boom");
-					},
-				},
-			},
-		};
-		expect(() => createUseUser({ invoke })).not.toThrow();
-	});
-});