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

package/src/utils/fetchCache.ts

@@ -1,199 +0,0 @@
-/**
- * SWR in-memory fetch cache for VTEX API responses.
- *
- * Inspired by deco-cx/deco runtime/fetch/fetchCache.ts.
- * Provides in-flight deduplication + stale-while-revalidate for GET requests.
- *
- * Only caches on the server side. Keyed by full URL string.
- */
-
-import {
-  FETCH_CACHE_FRESH_TTL_MS,
-  FETCH_CACHE_INFLIGHT_BACKSTOP_MS,
-  FETCH_CACHE_MAX_ENTRIES,
-  FETCH_CACHE_STALE_IF_ERROR_MS,
-} from "./constants";
-
-interface CacheEntry {
-  body: unknown;
-  status: number;
-  createdAt: number;
-  refreshing: boolean;
-}
-
-function freshTtlForStatus(status: number): number {
-  if (status >= 200 && status < 300) return FETCH_CACHE_FRESH_TTL_MS.success;
-  if (status === 404) return FETCH_CACHE_FRESH_TTL_MS.notFound;
-  if (status >= 500) return FETCH_CACHE_FRESH_TTL_MS.serverError;
-  return 0;
-}
-
-const store = new Map<string, CacheEntry>();
-const inflight = new Map<string, Promise<CacheEntry>>();
-
-function evictIfNeeded() {
-  if (store.size <= FETCH_CACHE_MAX_ENTRIES) return;
-  const sorted = [...store.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt);
-  const toRemove = sorted.slice(0, store.size - FETCH_CACHE_MAX_ENTRIES);
-  for (const [key] of toRemove) store.delete(key);
-}
-
-/**
- * Race a Promise against a timeout so callers' `.finally()` always runs.
- * Critical for evicting the inflight Map entry when a `fetch()` hangs —
- * without this, a never-settling Promise leaks the Map slot forever and
- * every subsequent request for the same key joins the zombie Promise.
- */
-function withTimeout<T>(work: Promise<T>, ms: number, label: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => {
-      reject(new Error(`${label} timed out after ${ms}ms`));
-    }, ms);
-  });
-  return Promise.race([work, timeout]).finally(() => {
-    clearTimeout(timer);
-  });
-}
-
-async function executeFetch(url: string, doFetch: () => Promise<Response>): Promise<CacheEntry> {
-  // Single attempt on purpose. The resilience layer (`createResilientFetch`,
-  // wired as the VTEX fetch's baseFetch) owns retries, backoff+jitter, the
-  // per-host retry budget, and the circuit breaker. Retrying here would:
-  //   - double-retry network errors (resilience 3× × fetchCache 3× = up to 9
-  //     upstream calls per logical request — the retry storm the budget
-  //     prevents), and
-  //   - re-enter the breaker on every 5xx retry, opening it ~3× too fast.
-  const response = await doFetch();
-
-  if (response.status >= 500) {
-    throw new Error(`fetchWithCache: ${response.status} ${response.statusText} — ${url}`);
-  }
-
-  const body = response.ok ? await response.json() : null;
-  return {
-    body,
-    status: response.status,
-    createdAt: Date.now(),
-    refreshing: false,
-  };
-}
-
-export interface FetchCacheOptions {
-  /**
-   * Custom TTL in ms. If provided, overrides status-based TTL.
-   */
-  ttl?: number;
-  /**
-   * Stale-if-error window in ms. How long past the freshness TTL a last-good
-   * entry may still be served while the origin is failing. Defaults to
-   * {@link FETCH_CACHE_STALE_IF_ERROR_MS} (24h). Set to 0 to disable stale
-   * serving.
-   */
-  sieMs?: number;
-}
-
-/**
- * Wrap a GET fetch call with SWR caching and in-flight dedup.
- *
- * Returns `null` for non-2xx responses that are cached (e.g. 404).
- * 5xx responses throw so the caller can handle them explicitly.
- *
- * @param cacheKey - Unique key (typically the full URL)
- * @param doFetch - The actual fetch call to execute
- * @param opts - Optional overrides
- * @returns Parsed JSON body, or null for cacheable error responses (e.g. 404)
- */
-export function fetchWithCache<T>(
-  cacheKey: string,
-  doFetch: () => Promise<Response>,
-  opts?: FetchCacheOptions,
-): Promise<T | null> {
-  const now = Date.now();
-  const entry = store.get(cacheKey);
-
-  if (entry) {
-    const maxAge = opts?.ttl ?? freshTtlForStatus(entry.status);
-    const age = now - entry.createdAt;
-    const isStale = age > maxAge;
-
-    if (!isStale) return Promise.resolve(entry.body as T | null);
-
-    // Beyond the stale-if-error window the last-good entry is too old to keep
-    // serving during an outage: drop it and fall through to a foreground
-    // refetch (cold path). On a healthy origin this is never reached because
-    // the background refresh below keeps resetting `createdAt`.
-    const sieMs = opts?.sieMs ?? FETCH_CACHE_STALE_IF_ERROR_MS;
-    const tooStale = age > maxAge + sieMs;
-
-    if (!tooStale) {
-      if (!entry.refreshing) {
-        entry.refreshing = true;
-        // Background refresh: no retry — stale data is already being served.
-        // Timeout guards against a hung VTEX response leaving `refreshing`
-        // stuck true forever (which would silently disable revalidation).
-        withTimeout(
-          executeFetch(cacheKey, doFetch),
-          FETCH_CACHE_INFLIGHT_BACKSTOP_MS,
-          `fetchCache stale-refresh ${cacheKey}`,
-        )
-          .then((fresh) => {
-            const ttl = opts?.ttl ?? freshTtlForStatus(fresh.status);
-            const existingWasSuccess = entry.status >= 200 && entry.status < 300;
-            const freshIsError = fresh.status >= 400;
-            const wouldDowngrade = existingWasSuccess && freshIsError;
-            if (ttl > 0 && !wouldDowngrade) {
-              store.set(cacheKey, fresh);
-            } else {
-              entry.refreshing = false;
-            }
-          })
-          .catch(() => {
-            entry.refreshing = false;
-          });
-      }
-      // Serve last-good while it is within the SIE window (stale-if-error).
-      return Promise.resolve(entry.body as T | null);
-    }
-
-    store.delete(cacheKey);
-    // fall through to the cold path below with the dead entry removed
-  }
-
-  const existing = inflight.get(cacheKey);
-  if (existing) return existing.then((e) => e.body as T | null);
-
-  // Wrap with a timeout so the `.finally()` below always runs and evicts
-  // the inflight slot — even if `executeFetch` never settles. See the
-  // FETCH_CACHE_INFLIGHT_BACKSTOP_MS doc comment (constants.ts) for the leak
-  // this guards against.
-  const promise = withTimeout(
-    executeFetch(cacheKey, doFetch),
-    FETCH_CACHE_INFLIGHT_BACKSTOP_MS,
-    `fetchCache ${cacheKey}`,
-  )
-    .then((fresh) => {
-      const ttl = opts?.ttl ?? freshTtlForStatus(fresh.status);
-      if (ttl > 0) {
-        store.set(cacheKey, fresh);
-        evictIfNeeded();
-      }
-      return fresh;
-    })
-    .finally(() => inflight.delete(cacheKey));
-
-  inflight.set(cacheKey, promise);
-  return promise.then((e) => e.body as T | null);
-}
-
-export function clearFetchCache() {
-  store.clear();
-  inflight.clear();
-}
-
-export function getFetchCacheStats() {
-  return {
-    entries: store.size,
-    inflight: inflight.size,
-  };
-}

package/src/utils/index.ts

@@ -1,19 +0,0 @@
-export type { PersonalDataOptions } from "./accountLoaders";
-export { vtexAccountLoaders } from "./accountLoaders";
-export * from "./batch";
-export * from "./cookies";
-export * from "./enrichment";
-export * from "./fetchCache";
-export * from "./intelligentSearch";
-export * from "./legacy";
-export * from "./pickAndOmit";
-export * from "./proxy";
-export * from "./resourceRange";
-export * from "./segment";
-export * from "./similars";
-export * from "./sitemap";
-export * from "./slugCache";
-export * from "./slugify";
-export * from "./transform";
-export * from "./types";
-export * from "./vtexId";

package/src/utils/instrumentedFetch.ts

@@ -1,97 +0,0 @@
-/**
- * Pre-wired instrumented fetch factory for VTEX.
- *
- * Bundles the three pieces a storefront would otherwise have to wire
- * by hand:
- *
- *   1. The `createInstrumentedFetch` boundary from `@decocms/start`
- *      (spans, traceparent injection, URL redaction, cache-header
- *      span attributes).
- *   2. The `vtexOperationRouter` URL→operation mapping so unannotated
- *      callsites still get semantic span names + histogram labels.
- *   3. An `onComplete` callback that records every call into the
- *      canonical `http.client.request.duration` histogram via the
- *      framework's `recordCommerceMetric(...)` helper in
- *      `@decocms/start/sdk/observability` — `provider`, `operation`,
- *      `status_class`, and `cached` labels.
- *
- * Sites opt in once at startup:
- *
- *   ```ts
- *   import { setVtexFetch } from "@decocms/apps/vtex";
- *   import { createVtexFetch } from "@decocms/apps/vtex";
- *
- *   setVtexFetch(createVtexFetch());
- *   ```
- *
- * Sites that need to wrap a custom underlying fetch (cookie passthrough,
- * proxy, retry, etc.) pass it as `baseFetch`. The instrumentation
- * still applies — `createInstrumentedFetch` preserves the wrapped
- * behavior.
- */
-
-import {
-  createInstrumentedFetch,
-  type InstrumentedFetch,
-} from "@decocms/blocks/sdk/instrumentedFetch";
-import { recordCommerceMetric, statusClassFor } from "@decocms/blocks/sdk/observability";
-import { vtexOperationRouter } from "./operationRouter";
-import { createResilientFetch, type ResilienceConfig } from "./resilience";
-
-export interface CreateVtexFetchOptions {
-  /**
-   * Underlying fetch to wrap. Defaults to `globalThis.fetch`.
-   * Pass an existing custom fetch (e.g. one that injects auth cookies
-   * or routes through a proxy) to preserve its behavior while adding
-   * the VTEX instrumentation layer on top.
-   */
-  baseFetch?: typeof fetch;
-  /**
-   * Disable the `http.client.request.duration` histogram emission for
-   * VTEX calls. The framework's span and structured logs still emit.
-   * Useful when the consumer wants to record its own histogram with a
-   * custom shape. Default: false.
-   */
-  disableHistogram?: boolean;
-  /**
-   * Resilience layer (real abort/timeout + per-host circuit breaker +
-   * idempotent-only retry with a budget). ON by default so every VTEX
-   * consumer is protected against upstream slowness/outages without
-   * per-site wiring. Pass a partial config to tune, `false` to opt out,
-   * or flip the `VTEX_RESILIENCE_DISABLED=true` env var as a runtime
-   * kill-switch. See {@link createResilientFetch}.
-   */
-  resilience?: Partial<ResilienceConfig> | false;
-}
-
-/**
- * Construct a pre-wired VTEX `InstrumentedFetch`. Pass the result to
- * `setVtexFetch(...)`. See module docstring for details.
- */
-export function createVtexFetch(options: CreateVtexFetchOptions = {}): InstrumentedFetch {
-  const { baseFetch, disableHistogram = false, resilience } = options;
-  // Compose the resilience layer UNDER the instrumentation so spans/histograms
-  // see the real outcome (including breaker fast-fails and timeouts). A single
-  // instrumented call = one logical request, which may span several underlying
-  // attempts. Covers every VTEX egress path — cached GETs, IS, and checkout
-  // POSTs — because they all funnel through this one fetch.
-  const resilientBase =
-    resilience === false
-      ? baseFetch
-      : createResilientFetch(baseFetch ?? globalThis.fetch, resilience ?? {});
-  return createInstrumentedFetch({
-    name: "vtex",
-    baseFetch: resilientBase,
-    resolveOperation: vtexOperationRouter,
-    onComplete: disableHistogram
-      ? undefined
-      : ({ operation, status, durationMs, cached }) => {
-          recordCommerceMetric(durationMs, {
-            provider: "vtex",
-            operation,
-            status_class: statusClassFor(status),
-            cached,
-          });
-        },
-  });
-}

package/src/utils/intelligentSearch.ts

@@ -1,96 +0,0 @@
-import { vtexFetch } from "../client";
-import type { PageType, SelectedFacet, SimulationBehavior, Sort } from "./types";
-
-export const SESSION_COOKIE = "vtex_is_session";
-export const ANONYMOUS_COOKIE = "vtex_is_anonymous";
-
-export const withDefaultFacets = (allFacets: readonly SelectedFacet[]) => {
-	return [...allFacets];
-};
-
-export const toPath = (facets: SelectedFacet[]) =>
-	facets.map(({ key, value }) => (key ? `${key}/${value}` : value)).join("/");
-
-interface Params {
-	query: string;
-	page: number;
-	count: number;
-	sort: Sort;
-	fuzzy: string;
-	locale: string;
-	hideUnavailableItems: boolean;
-	simulationBehavior: SimulationBehavior;
-}
-
-export const withDefaultParams = ({
-	query = "",
-	page = 0,
-	count = 12,
-	sort = "",
-	fuzzy = "auto",
-	locale = "pt-BR",
-	hideUnavailableItems,
-	simulationBehavior = "default",
-}: Partial<Params>) => ({
-	page: page + 1,
-	count,
-	query,
-	sort,
-	...(fuzzy ? { fuzzy } : {}),
-	locale,
-	hideUnavailableItems: hideUnavailableItems ?? false,
-	simulationBehavior,
-});
-
-export const isFilterParam = (keyFilter: string): boolean => keyFilter.startsWith("filter.");
-
-/**
- * Valid VTEX Intelligent Search sort values.
- * Anything else (e.g. "orders:desc)" with a trailing paren from legacy URLs)
- * causes IS API to return 400.
- */
-export const VALID_IS_SORTS = new Set([
-	"",
-	"orders:desc",
-	"price:asc",
-	"price:desc",
-	"name:asc",
-	"name:desc",
-	"release:desc",
-	"discount:desc",
-]);
-
-/** Sanitize an IS sort parameter — returns empty string for invalid values. */
-export function sanitizeISSort(sort: string): string {
-	return VALID_IS_SORTS.has(sort) ? sort : "";
-}
-
-const segmentsFromTerm = (term: string) => term.split("/").filter(Boolean);
-
-const segmentsFromSearchParams = (url: string) => {
-	const searchParams = new URLSearchParams(url).entries();
-
-	const categories = Array.from(searchParams)
-		.sort()
-		.reduce((acc, [key, value]) => {
-			if (key.includes("filter.category")) {
-				acc.push(value);
-			}
-
-			return acc;
-		}, [] as string[]);
-
-	return categories.length ? categories : segmentsFromTerm(url);
-};
-
-export const pageTypesFromUrl = async (url: string): Promise<PageType[]> => {
-	const segments = segmentsFromSearchParams(url);
-
-	return await Promise.all(
-		segments.map((_, index) =>
-			vtexFetch<PageType>(
-				`/api/catalog_system/pub/portal/pagetype/${segments.slice(0, index + 1).join("/")}`,
-			),
-		),
-	);
-};

package/src/utils/legacy.ts

@@ -1,139 +0,0 @@
-import type { Seo } from "@decocms/apps-commerce/types";
-import { vtexFetch } from "../client";
-import type { WrappedSegment } from "./segment";
-import { slugify } from "./slugify";
-import type { PageType } from "./types";
-
-const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
-
-export const toSegmentParams = ({ payload: segment }: WrappedSegment) =>
-	Object.fromEntries(
-		Object.entries({
-			utmi_campaign: segment.utmi_campaign ?? undefined,
-			utm_campaign: segment.utm_campaign ?? undefined,
-			utm_source: segment.utm_source ?? undefined,
-			sc: segment.channel ?? undefined,
-		}).filter(([_, v]) => v !== undefined),
-	);
-
-const PAGE_TYPE_TO_MAP_PARAM = {
-	Brand: "b",
-	Category: "c",
-	Department: "c",
-	SubCategory: "c",
-	Collection: "productClusterIds",
-	Cluster: "productClusterIds",
-	Search: "ft",
-	FullText: "ft",
-	Product: "p",
-	NotFound: null,
-};
-
-const segmentsFromTerm = (term: string) => term.split("/").filter(Boolean);
-
-export const getValidTypesFromPageTypes = (pagetypes: PageType[]) => {
-	return pagetypes.filter((type) => PAGE_TYPE_TO_MAP_PARAM[type.pageType]);
-};
-
-export const pageTypesFromPathname = async (term: string): Promise<PageType[]> => {
-	const segments = segmentsFromTerm(term);
-
-	return await Promise.all(
-		segments.map((_, index) =>
-			vtexFetch<PageType>(
-				`/api/catalog_system/pub/portal/pagetype/${segments.slice(0, index + 1).join("/")}`,
-			),
-		),
-	);
-};
-
-export const getMapAndTerm = (pageTypes: PageType[]) => {
-	const term = pageTypes
-		.map((type, index) =>
-			type.url ? segmentsFromTerm(new URL(`http://${type.url}`).pathname)[index] : null,
-		)
-		.filter(Boolean)
-		.join("/");
-
-	const map = pageTypes
-		.map((type) => PAGE_TYPE_TO_MAP_PARAM[type.pageType])
-		.filter(Boolean)
-		.join(",");
-
-	if (map === "ft" && term === "s") {
-		return ["", ""];
-	}
-
-	return [map, term];
-};
-
-export const pageTypesToBreadcrumbList = (pages: PageType[], baseUrl: string) => {
-	const filteredPages = pages.filter(
-		({ pageType }) =>
-			pageType === "Category" || pageType === "Department" || pageType === "SubCategory",
-	);
-
-	return filteredPages.map((page, index) => {
-		const position = index + 1;
-		const slug = filteredPages.slice(0, position).map((x) => slugify(x.name!));
-
-		return {
-			"@type": "ListItem" as const,
-			name: page.name!,
-			item: new URL(`/${slug.join("/")}`, baseUrl).href,
-			position,
-		};
-	});
-};
-
-export const pageTypesToSeo = (
-	pages: PageType[],
-	baseUrl: string,
-	currentPage?: number,
-): Seo | null => {
-	const current = pages.at(-1);
-	const url = new URL(baseUrl);
-	const fullTextSearch = url.searchParams.get("q");
-	const hasMapTermOrSkuId = !!(url.searchParams.get("map") || url.searchParams.get("skuId"));
-
-	if (
-		(!current || current.pageType === "Search" || current.pageType === "FullText") &&
-		fullTextSearch
-	) {
-		return {
-			title: capitalize(fullTextSearch),
-			description: capitalize(fullTextSearch),
-			canonical: url.href,
-			noIndexing: hasMapTermOrSkuId,
-		};
-	}
-
-	if (!current) {
-		return null;
-	}
-
-	return {
-		title: current.title || current.name || "",
-		description: current.metaTagDescription!,
-		noIndexing: hasMapTermOrSkuId,
-		canonical: toCanonical(
-			new URL(
-				current.url && current.pageType !== "Collection"
-					? current.url.replace(/^[^/]*\//, "/").toLowerCase()
-					: url,
-				url,
-			),
-			currentPage,
-		),
-	};
-};
-
-function toCanonical(url: URL, page?: number) {
-	if (typeof page === "number") {
-		url.searchParams.set("page", `${page}`);
-	}
-
-	return url.href;
-}
-
-export { isFilterParam } from "./intelligentSearch";

package/src/utils/minicart.ts

@@ -1,139 +0,0 @@
-/**
- * Map a VTEX OrderForm to the canonical `Minicart` contract.
- *
- * Pure function — no I/O, fully unit-testable. Pricing is converted from
- * VTEX's native cents to major units (the canonical unit for `Minicart`).
- *
- * Locale and currency come from `orderForm.storePreferencesData` and follow
- * VTEX's `storePreferencesData.countryCode` / `currencyCode` semantics.
- *
- * @example
- * ```ts
- * import { vtexOrderFormToMinicart } from "@decocms/apps/vtex/utils/minicart";
- * import { getCart } from "@decocms/apps/vtex/loaders/cart";
- *
- * const orderForm = await getCart(orderFormId);
- * const minicart = vtexOrderFormToMinicart(orderForm, {
- *   freeShippingTarget: 0,
- *   checkoutHref: "/checkout",
- * });
- * ```
- */
-
-import type { Minicart, MinicartItem } from "@decocms/apps-commerce/types";
-import type { OrderForm, OrderFormItem, Totalizer } from "../types";
-
-export interface VtexOrderFormToMinicartOptions {
-	/** Free-shipping threshold in major units. `0` disables the progress bar. */
-	freeShippingTarget?: number;
-	/** Override the OrderForm's `clientPreferencesData.locale` (BCP-47, e.g. `"pt-BR"`). */
-	locale?: string;
-	/** Where the checkout button sends the user. Default: `/checkout`. */
-	checkoutHref?: string;
-	/** Whether the UI should expose the coupon input. Default: `true`. */
-	enableCoupon?: boolean;
-}
-
-const CENTS_PER_MAJOR = 100;
-
-/** Convert VTEX cents to major units. Always returns a finite number. */
-function fromCents(cents: number | undefined | null): number {
-	if (cents == null || !Number.isFinite(cents)) return 0;
-	return cents / CENTS_PER_MAJOR;
-}
-
-function findTotalizer(totalizers: Totalizer[] | undefined, id: string): number {
-	if (!totalizers) return 0;
-	const t = totalizers.find((x) => x.id === id);
-	return t?.value ?? 0;
-}
-
-/**
- * Locale heuristic. VTEX exposes `clientPreferencesData.locale` when set, but
- * otherwise we synthesize one from `storePreferencesData.countryCode` so the UI
- * always has a usable value for `Intl.NumberFormat`.
- */
-function inferLocale(orderForm: OrderForm, override?: string): string {
-	if (override) return override;
-	const explicit = orderForm.clientPreferencesData?.locale;
-	if (explicit) return explicit;
-
-	const country = orderForm.storePreferencesData?.countryCode;
-	if (country === "BRA" || country === "BR") return "pt-BR";
-	if (country === "USA" || country === "US") return "en-US";
-	return "en-US";
-}
-
-function vtexItemToMinicartItem(item: OrderFormItem, index: number, coupon?: string): MinicartItem {
-	const sellingPrice = fromCents(item.sellingPrice ?? item.price);
-	const listPrice = fromCents(item.listPrice ?? item.price);
-	const discount = Math.max(0, listPrice - sellingPrice);
-
-	return {
-		// AnalyticsItem identifier — VTEX uses productId; sites map to numeric SKU
-		// when needed via `Number(item.item_id)` (see bagaggio Minicart).
-		item_id: item.id,
-		item_group_id: item.productId,
-		item_name: item.name ?? item.skuName ?? "",
-		item_variant: item.skuName,
-		item_brand: item.additionalInfo?.brandName ?? undefined,
-		item_url: item.detailUrl,
-		coupon,
-		affiliation: item.seller,
-		index,
-		// Cart-required fields
-		image: item.imageUrl?.replace(/^http:/, "https:") ?? "",
-		listPrice,
-		price: sellingPrice,
-		quantity: item.quantity,
-		discount: Number(discount.toFixed(2)),
-		// Platform-specific
-		seller: item.seller,
-		attachments: item.attachments as MinicartItem["attachments"],
-		attachmentOfferings: item.attachmentOfferings as MinicartItem["attachmentOfferings"],
-	};
-}
-
-/**
- * Map a VTEX `OrderForm` to the canonical platform-agnostic `Minicart`.
- *
- * @param orderForm - Result from `getCart()` or `getOrCreateCart()`.
- * @param opts - Storefront-level overrides (free-shipping target, checkout href, ...).
- */
-export function vtexOrderFormToMinicart(
-	orderForm: OrderForm,
-	opts: VtexOrderFormToMinicartOptions = {},
-): Minicart<OrderForm> {
-	const totalizers = orderForm.totalizers;
-	const subtotal = fromCents(findTotalizer(totalizers, "Items"));
-	const discountsRaw = findTotalizer(totalizers, "Discounts");
-	const discounts = Math.abs(fromCents(discountsRaw));
-	const shippingRaw = findTotalizer(totalizers, "Shipping");
-	const shipping = totalizers?.some((t) => t.id === "Shipping")
-		? fromCents(shippingRaw)
-		: undefined;
-	const total = fromCents(orderForm.value);
-
-	const coupon = orderForm.marketingData?.coupon;
-	const items = (orderForm.items ?? []).map((item, index) =>
-		vtexItemToMinicartItem(item, index, coupon),
-	);
-
-	return {
-		original: orderForm,
-		storefront: {
-			items,
-			subtotal,
-			discounts,
-			shipping,
-			total,
-			coupon,
-			locale: inferLocale(orderForm, opts.locale),
-			currency: orderForm.storePreferencesData?.currencyCode ?? "BRL",
-			enableCoupon: opts.enableCoupon ?? true,
-			freeShippingTarget: opts.freeShippingTarget ?? 0,
-			checkoutHref: opts.checkoutHref ?? "/checkout",
-			postalCode: orderForm.shippingData?.address?.postalCode ?? undefined,
-		},
-	};
-}