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

package/src/loaders/cart/full.ts

@@ -1,67 +0,0 @@
-/**
- * `vtex/loaders/cart/full` — the drawer/minicart loader.
- *
- * Returns the full canonical `Minicart`, but requests only `SECTIONS_DRAWER`
- * from VTEX (not the legacy 15-section superset). Call it when the user opens
- * the cart drawer — not on every page view.
- *
- * Like the summary loader, a first-time visitor gets an empty `Minicart` shell
- * with no VTEX call.
- *
- * Registered in the app manifest as `vtex/loaders/cart/full`
- * (`invoke.vtex.loaders.cart.full`).
- */
-
-import type { Minicart } from "@decocms/apps-commerce/types";
-import { SECTIONS_DRAWER } from "@decocms/apps-commerce/types";
-import { getOrCreateCartV2 } from "../../actions/checkout";
-import type { OrderForm } from "../../types";
-import { resolveOrderFormId } from "./orderFormId";
-
-export interface CartFullProps {
-  orderFormId?: string;
-  /** Free-shipping threshold in major units. `0` disables the progress bar. */
-  freeShippingTarget?: number;
-  /** Override the OrderForm's 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;
-}
-
-function emptyMinicart(props: CartFullProps): Minicart<OrderForm | null> {
-  return {
-    original: null,
-    storefront: {
-      items: [],
-      subtotal: 0,
-      discounts: 0,
-      total: 0,
-      locale: props.locale ?? "pt-BR",
-      currency: "BRL",
-      enableCoupon: props.enableCoupon ?? true,
-      freeShippingTarget: props.freeShippingTarget ?? 0,
-      checkoutHref: props.checkoutHref ?? "/checkout",
-    },
-  };
-}
-
-export default async function cartFull(
-  props: CartFullProps = {},
-): Promise<Minicart<OrderForm | null>> {
-  const orderFormId = resolveOrderFormId(props.orderFormId);
-  if (!orderFormId) return emptyMinicart(props);
-
-  return (await getOrCreateCartV2({
-    orderFormId,
-    projection: "minicart",
-    sections: SECTIONS_DRAWER,
-    minicartOptions: {
-      freeShippingTarget: props.freeShippingTarget,
-      locale: props.locale,
-      checkoutHref: props.checkoutHref,
-      enableCoupon: props.enableCoupon,
-    },
-  })) as Minicart<OrderForm>;
-}

package/src/loaders/cart/gifts.ts

@@ -1,43 +0,0 @@
-/**
- * `vtex/loaders/cart/gifts` — selectable gifts + promotion teasers only.
- *
- * A focused read: fetches just the `ratesAndBenefitsData` (+ `items` so gift
- * eligibility resolves) and returns the gift-relevant slice, so a "you earned a
- * gift" UI does not have to load the whole cart. Empty for visitors with no
- * cart yet (no VTEX call).
- */
-
-import { getOrCreateCartV2 } from "../../actions/checkout";
-import type { OrderForm } from "../../types";
-import { resolveOrderFormId } from "./orderFormId";
-
-export interface CartGiftsProps {
-  orderFormId?: string;
-}
-
-export interface CartGifts {
-  orderFormId: string | null;
-  /** VTEX `selectableGifts` — gifts the shopper can choose. */
-  selectableGifts: unknown[];
-  /** VTEX `ratesAndBenefitsData` — active promotions / teasers. */
-  ratesAndBenefits: OrderForm["ratesAndBenefitsData"] | null;
-}
-
-const EMPTY: CartGifts = { orderFormId: null, selectableGifts: [], ratesAndBenefits: null };
-
-export default async function cartGifts(props: CartGiftsProps = {}): Promise<CartGifts> {
-  const orderFormId = resolveOrderFormId(props.orderFormId);
-  if (!orderFormId) return EMPTY;
-
-  const orderForm = (await getOrCreateCartV2({
-    orderFormId,
-    projection: "raw",
-    sections: ["items", "ratesAndBenefitsData", "messages"],
-  })) as OrderForm;
-
-  return {
-    orderFormId: orderForm.orderFormId ?? null,
-    selectableGifts: orderForm.selectableGifts ?? [],
-    ratesAndBenefits: orderForm.ratesAndBenefitsData ?? null,
-  };
-}

package/src/loaders/cart/orderFormId.ts

@@ -1,31 +0,0 @@
-/**
- * Read the current visitor's `orderFormId` from the request cookie.
- *
- * Shared by every Cart v2 loader. Returns `undefined` for first-time visitors
- * (no cart yet) — loaders MUST treat that as "empty, do not create" so a page
- * view never provisions a zero-item OrderForm on VTEX.
- */
-
-import { RequestContext } from "@decocms/blocks/sdk/requestContext";
-
-export const ORDER_FORM_COOKIE = "checkout.vtex.com__orderFormId";
-
-/** Extract `orderFormId` from the inbound request cookie header, if present. */
-export function readOrderFormIdFromRequest(cookieName = ORDER_FORM_COOKIE): string | undefined {
-  const ctx = RequestContext.current;
-  const cookieHeader = ctx?.request.headers.get("cookie");
-  if (!cookieHeader) return undefined;
-  const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${cookieName}=([^;]+)`));
-  return match?.[1] ? decodeURIComponent(match[1]) : undefined;
-}
-
-/**
- * Resolve the orderFormId a loader should use: an explicit prop wins, else the
- * cookie. `undefined` means "no cart exists yet".
- */
-export function resolveOrderFormId(
-  explicit?: string,
-  cookieName = ORDER_FORM_COOKIE,
-): string | undefined {
-  return explicit ?? readOrderFormIdFromRequest(cookieName);
-}

package/src/loaders/cart/shipping.test.ts

@@ -1,125 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { configureVtex } from "../../client";
-
-const simulateCartMock = vi.fn(async (props: any) => ({
-	logisticsInfo: [{ slas: [{ id: "sla-1" }] }],
-	echo: props,
-}));
-
-vi.mock("../../actions/checkout", () => ({
-	simulateCart: (props: any) => simulateCartMock(props),
-}));
-
-import cartShipping, { getShippingSimulation } from "./shipping";
-import { __resetSimulationCacheForTests } from "../../utils/simulationCache";
-
-describe("getShippingSimulation (#373)", () => {
-	beforeEach(() => {
-		configureVtex({ account: "acme", salesChannel: "1" });
-		__resetSimulationCacheForTests();
-		simulateCartMock.mockClear();
-	});
-
-	afterEach(() => {
-		__resetSimulationCacheForTests();
-	});
-
-	const props = {
-		items: [{ id: "1", quantity: 1, seller: "1" }],
-		postalCode: "01310-100",
-	};
-
-	it("calls simulateCart on a cache MISS and caches the response body", async () => {
-		const result = await getShippingSimulation(props);
-		expect(simulateCartMock).toHaveBeenCalledTimes(1);
-		expect(result).toEqual({ logisticsInfo: [{ slas: [{ id: "sla-1" }] }], echo: expect.anything() });
-	});
-
-	it("serves the cached response on a second call with the same tuple — no 2nd simulateCart call", async () => {
-		await getShippingSimulation(props);
-		await getShippingSimulation(props);
-		expect(simulateCartMock).toHaveBeenCalledTimes(1);
-	});
-
-	it("calls simulateCart again for a different postalCode (different cache key)", async () => {
-		await getShippingSimulation(props);
-		await getShippingSimulation({ ...props, postalCode: "20040-020" });
-		expect(simulateCartMock).toHaveBeenCalledTimes(2);
-	});
-
-	it("calls simulateCart again for a different items composition", async () => {
-		await getShippingSimulation(props);
-		await getShippingSimulation({ ...props, items: [{ id: "2", quantity: 1, seller: "1" }] });
-		expect(simulateCartMock).toHaveBeenCalledTimes(2);
-	});
-
-	it("is order-insensitive for the items array (same composition, different order)", async () => {
-		const twoItems = {
-			...props,
-			items: [
-				{ id: "1", quantity: 1, seller: "1" },
-				{ id: "2", quantity: 2, seller: "1" },
-			],
-		};
-		const reordered = {
-			...props,
-			items: [
-				{ id: "2", quantity: 2, seller: "1" },
-				{ id: "1", quantity: 1, seller: "1" },
-			],
-		};
-		await getShippingSimulation(twoItems);
-		await getShippingSimulation(reordered);
-		expect(simulateCartMock).toHaveBeenCalledTimes(1);
-	});
-
-	it("varies the cache key by salesChannel (different sc → different simulation)", async () => {
-		await getShippingSimulation(props);
-		configureVtex({ account: "acme", salesChannel: "2" });
-		await getShippingSimulation(props);
-		expect(simulateCartMock).toHaveBeenCalledTimes(2);
-	});
-
-	it("the cached response never carries cookies — only the plain JSON body", async () => {
-		const result = await getShippingSimulation(props);
-		expect(result).not.toHaveProperty("headers");
-		expect(JSON.stringify(result)).not.toContain("set-cookie");
-	});
-});
-
-describe("cartShipping (drawer loader, built on getShippingSimulation)", () => {
-	beforeEach(() => {
-		configureVtex({ account: "acme", salesChannel: "1" });
-		__resetSimulationCacheForTests();
-		simulateCartMock.mockClear();
-	});
-
-	afterEach(() => {
-		__resetSimulationCacheForTests();
-	});
-
-	const props = {
-		items: [{ id: "1", quantity: 1, seller: "1" }],
-		postalCode: "01310-100",
-	};
-
-	it("returns empty options when items or postalCode are missing", async () => {
-		expect(await cartShipping({ items: [], postalCode: "" })).toEqual({
-			postalCode: "",
-			options: [],
-		});
-	});
-
-	it("normalizes SLAs from the (cached) simulation into a de-duplicated option list", async () => {
-		const result = await cartShipping(props);
-		expect(result.postalCode).toBe(props.postalCode);
-		expect(result.options).toHaveLength(1);
-		expect(result.options[0].id).toBe("sla-1");
-	});
-
-	it("shares the underlying simulation cache — a second call does not re-simulate", async () => {
-		await cartShipping(props);
-		await cartShipping(props);
-		expect(simulateCartMock).toHaveBeenCalledTimes(1);
-	});
-});

package/src/loaders/cart/shipping.ts

@@ -1,136 +0,0 @@
-/**
- * Cached shipping simulation loader (#373).
- *
- * Wraps `simulateCart` (a POST to `/api/checkout/pub/orderForms/simulation`)
- * with a cache keyed only on the non-personalized inputs — items,
- * postalCode, country, and salesChannel. See `../../utils/simulationCache.ts`
- * for why this can't just be `vtexCachedFetch` (POST + cookie-rotation).
- *
- * On a cache MISS, `simulateCart` still goes through `vtexFetchWithCookies`
- * as normal — cookies rotate exactly as before. Only the response BODY
- * (SLAs + logistics info) is cached; cookies are never stored or replayed.
- */
-import { djb2 } from "@decocms/blocks/sdk/djb2";
-import { simulateCart, type SimulateCartProps, type SimulationItem } from "../../actions/checkout";
-import { getVtexConfig } from "../../client";
-import { getSimulationCache } from "../../utils/simulationCache";
-
-/** Shipping SLAs can shift with promotions/stock — keep the TTL short. */
-const DEFAULT_TTL_SECONDS = 5 * 60;
-
-export interface ShippingSimulationProps {
-	items: SimulationItem[];
-	postalCode: string;
-	country?: string;
-	/** Override the cache TTL (seconds). Defaults to 5 minutes. */
-	ttlSeconds?: number;
-}
-
-function buildCacheKey(props: ShippingSimulationProps): string {
-	const config = getVtexConfig();
-	const normalizedItems = [...props.items]
-		.map((item) => ({ id: String(item.id), quantity: item.quantity, seller: item.seller }))
-		.sort((a, b) => (a.id === b.id ? a.seller.localeCompare(b.seller) : a.id.localeCompare(b.id)));
-
-	const raw = JSON.stringify({
-		account: config.account,
-		salesChannel: config.salesChannel ?? null,
-		items: normalizedItems,
-		postalCode: props.postalCode,
-		country: props.country ?? config.country ?? "BRA",
-	});
-	return `shipping-sim:${djb2(raw)}`;
-}
-
-/**
- * Fetch shipping SLAs for a cart, serving a cached response body when
- * available for the same `{items, postalCode, salesChannel}` tuple.
- */
-export async function getShippingSimulation(props: ShippingSimulationProps): Promise<any> {
-	const cache = getSimulationCache();
-	const key = buildCacheKey(props);
-
-	const cached = await cache.get(key);
-	if (cached != null) {
-		try {
-			return JSON.parse(cached);
-		} catch {
-			// Corrupted cache entry — fall through to a fresh simulation.
-		}
-	}
-
-	const simulateProps: SimulateCartProps = {
-		items: props.items,
-		postalCode: props.postalCode,
-		country: props.country,
-	};
-	const result = await simulateCart(simulateProps);
-	await cache.put(key, JSON.stringify(result), props.ttlSeconds ?? DEFAULT_TTL_SECONDS);
-	return result;
-}
-
-// ---------------------------------------------------------------------------
-// `vtex/loaders/cart/shipping` — normalized shipping options for the drawer
-// ---------------------------------------------------------------------------
-//
-// Runs a (cached) VTEX cart simulation for the given items + postal code and
-// returns a normalized, de-duplicated list of shipping SLAs (price in major
-// units). Separate from the cart mutation path so the drawer can show
-// delivery estimates without re-fetching the whole OrderForm. Built on
-// `getShippingSimulation` above instead of calling `simulateCart` directly,
-// so repeated drawer opens for the same {items, postalCode} share the cache.
-
-const CENTS_PER_MAJOR = 100;
-
-export interface CartShippingProps {
-	items: SimulationItem[];
-	postalCode: string;
-	country?: string;
-}
-
-export interface ShippingOption {
-	id: string;
-	name: string;
-	/** Price in major units. */
-	price: number;
-	shippingEstimate: string;
-	deliveryChannel?: string;
-}
-
-export interface CartShipping {
-	postalCode: string;
-	options: ShippingOption[];
-}
-
-interface SimSla {
-	id: string;
-	name: string;
-	price: number;
-	shippingEstimate: string;
-	deliveryChannel?: string;
-}
-
-export default async function cartShipping(props: CartShippingProps): Promise<CartShipping> {
-	const { items, postalCode, country } = props;
-	if (!items?.length || !postalCode) return { postalCode, options: [] };
-
-	const sim = await getShippingSimulation({ items, postalCode, country });
-	const logisticsInfo: Array<{ slas?: SimSla[] }> = sim?.logisticsInfo ?? [];
-
-	// Collapse SLAs across all items into one unique-by-id option list.
-	const byId = new Map<string, ShippingOption>();
-	for (const info of logisticsInfo) {
-		for (const sla of info.slas ?? []) {
-			if (byId.has(sla.id)) continue;
-			byId.set(sla.id, {
-				id: sla.id,
-				name: sla.name,
-				price: (sla.price ?? 0) / CENTS_PER_MAJOR,
-				shippingEstimate: sla.shippingEstimate,
-				deliveryChannel: sla.deliveryChannel,
-			});
-		}
-	}
-
-	return { postalCode, options: [...byId.values()] };
-}

package/src/loaders/cart/summary.ts

@@ -1,36 +0,0 @@
-/**
- * `vtex/loaders/cart/summary` — the badge loader.
- *
- * Returns the smallest useful cart shape: `{ orderFormId, totalItems, total }`.
- * For a first-time visitor (no orderFormId cookie) it returns an empty summary
- * **without touching VTEX** — this is the "don't create a cart on page load"
- * guarantee. Only visitors who already have a cart pay a checkout API call, and
- * that call requests just `items`+`totalizers` (via `SECTIONS_MINIMAL`).
- *
- * Registered in the app manifest as `vtex/loaders/cart/summary`, so it is
- * invoke-callable from the client (`invoke.vtex.loaders.cart.summary`) in both
- * Next.js and TanStack Start.
- */
-
-import type { CartSummary } from "@decocms/apps-commerce/types";
-import { SECTIONS_MINIMAL } from "@decocms/apps-commerce/types";
-import { getOrCreateCartV2 } from "../../actions/checkout";
-import { resolveOrderFormId } from "./orderFormId";
-
-export interface CartSummaryProps {
-  /** Override the orderFormId; defaults to the request cookie. */
-  orderFormId?: string;
-}
-
-const EMPTY_SUMMARY: CartSummary = { orderFormId: null, totalItems: 0, total: 0 };
-
-export default async function cartSummary(props: CartSummaryProps = {}): Promise<CartSummary> {
-  const orderFormId = resolveOrderFormId(props.orderFormId);
-  if (!orderFormId) return EMPTY_SUMMARY;
-
-  return (await getOrCreateCartV2({
-    orderFormId,
-    projection: "summary",
-    sections: SECTIONS_MINIMAL,
-  })) as CartSummary;
-}

package/src/loaders/cart.ts

@@ -1,52 +0,0 @@
-/**
- * VTEX Cart (OrderForm) loader.
- * Pure async function — requires configureVtex() to have been called.
- *
- * Ported from deco-cx/apps:
- *   vtex/loaders/cart.ts
- *
- * @see https://developers.vtex.com/docs/api-reference/checkout-api#get-/api/checkout/pub/orderForm
- */
-
-import { DEFAULT_EXPECTED_SECTIONS } from "../actions/checkout";
-import { getVtexConfig, vtexFetch } from "../client";
-import { forceHttpsOnAssets } from "../utils/transform";
-import type { OrderForm } from "../utils/types";
-
-/**
- * Fetch the current cart (OrderForm).
- *
- * When `orderFormId` is provided the existing cart is retrieved;
- * otherwise a fresh OrderForm is created via POST.
- *
- * @param orderFormId - Optional existing orderForm ID (from checkout cookie)
- * @param salesChannel - Optional sales channel override
- * @param authCookie - Optional cookie string for authenticated requests
- */
-export async function getCart(
-	orderFormId?: string,
-	opts?: { salesChannel?: string; authCookie?: string },
-): Promise<OrderForm> {
-	const { salesChannel } = getVtexConfig();
-	const sc = opts?.salesChannel ?? salesChannel;
-	const headers: Record<string, string> = {};
-	if (opts?.authCookie) headers.cookie = opts.authCookie;
-
-	const scParam = sc ? `?sc=${sc}` : "";
-
-	const body = JSON.stringify({ expectedOrderFormSections: DEFAULT_EXPECTED_SECTIONS });
-
-	const cart = orderFormId
-		? await vtexFetch<OrderForm>(`/api/checkout/pub/orderForm/${orderFormId}${scParam}`, {
-				method: "POST",
-				headers,
-				body,
-			})
-		: await vtexFetch<OrderForm>(`/api/checkout/pub/orderForm${scParam}`, {
-				method: "POST",
-				headers,
-				body,
-			});
-
-	return forceHttpsOnAssets(cart);
-}

package/src/loaders/catalog.ts

@@ -1,163 +0,0 @@
-/**
- * VTEX Catalog System API loaders.
- * Pure async functions using vtexFetch. Require configureVtex() to have been called.
- *
- * Ported from deco-cx/apps vtex/loaders/legacy/*.ts and vtex/utils/client.ts
- * @see https://developers.vtex.com/docs/api-reference/catalog-api
- */
-import { getVtexConfig, vtexFetch } from "../client";
-
-// ---------------------------------------------------------------------------
-// Product search (public)
-// ---------------------------------------------------------------------------
-
-export type LegacySort =
-	| ""
-	| "OrderByTopSaleDESC"
-	| "OrderByReleaseDateDESC"
-	| "OrderByBestDiscountDESC"
-	| "OrderByPriceDESC"
-	| "OrderByPriceASC"
-	| "OrderByNameASC"
-	| "OrderByNameDESC"
-	| "OrderByScoreDESC";
-
-export interface SearchProductsOpts {
-	fq?: string | string[];
-	ft?: string;
-	sort?: LegacySort;
-	from?: number;
-	to?: number;
-}
-
-/**
- * Search products using the VTEX Catalog API.
- * @see https://developers.vtex.com/docs/api-reference/search-api#get-/api/catalog_system/pub/products/search
- */
-export async function searchProducts<T = any>(opts: SearchProductsOpts = {}): Promise<T[]> {
-	const params = new URLSearchParams();
-	const fqs = Array.isArray(opts.fq) ? opts.fq : opts.fq ? [opts.fq] : [];
-	for (const f of fqs) params.append("fq", f);
-	if (opts.ft) params.set("ft", opts.ft);
-	if (opts.sort) params.set("O", opts.sort);
-	if (opts.from != null) params.set("_from", String(opts.from));
-	if (opts.to != null) params.set("_to", String(opts.to));
-
-	const { salesChannel } = getVtexConfig();
-	if (salesChannel) params.set("sc", salesChannel);
-
-	return vtexFetch<T[]>(`/api/catalog_system/pub/products/search/?${params}`);
-}
-
-/**
- * Get a product by productId or skuId.
- * @see https://developers.vtex.com/docs/api-reference/search-api#get-/api/catalog_system/pub/products/search
- */
-export async function getProductByIdOrSku<T = any>(opts: {
-	productId?: string;
-	skuId?: string;
-}): Promise<T | null> {
-	let fq: string;
-	if (opts.productId) fq = `productId:${opts.productId}`;
-	else if (opts.skuId) fq = `skuId:${opts.skuId}`;
-	else throw new Error("Neither productId nor skuId provided.");
-
-	const results = await searchProducts<T>({ fq });
-	return results[0] ?? null;
-}
-
-// ---------------------------------------------------------------------------
-// Product variations (public)
-// ---------------------------------------------------------------------------
-
-/**
- * Get product SKU variations.
- * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/products/variations/-productId-
- */
-export async function getProductVariations<T = any>(productId: string): Promise<T> {
-	return vtexFetch<T>(`/api/catalog_system/pub/products/variations/${productId}`);
-}
-
-// ---------------------------------------------------------------------------
-// Product specification (private — requires appKey/appToken)
-// ---------------------------------------------------------------------------
-
-/**
- * Get product specifications (private API).
- * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pvt/products/-productId-/specification
- */
-export async function getProductSpecification<T = any>(productId: string): Promise<T> {
-	return vtexFetch<T>(`/api/catalog_system/pvt/products/${productId}/Specification`);
-}
-
-// ---------------------------------------------------------------------------
-// Cross-selling
-// ---------------------------------------------------------------------------
-
-export type CrossSellingType =
-	| "similars"
-	| "suggestions"
-	| "accessories"
-	| "whosawalsosaw"
-	| "whosawalsobought"
-	| "whoboughtalsobought"
-	| "showtogether";
-
-/**
- * Get cross-selling products.
- * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/products/crossselling/-type-/-productId-
- */
-export async function getCrossSelling<T = any>(
-	type: CrossSellingType,
-	productId: string,
-): Promise<T[]> {
-	return vtexFetch<T[]>(`/api/catalog_system/pub/products/crossselling/${type}/${productId}`);
-}
-
-// ---------------------------------------------------------------------------
-// Categories
-// ---------------------------------------------------------------------------
-
-/**
- * Get the category tree up to a given depth level.
- * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/category/tree/-categoryLevels-
- */
-export async function getCategoryTree<T = any>(levels = 3): Promise<T[]> {
-	return vtexFetch<T[]>(`/api/catalog_system/pub/category/tree/${levels}`);
-}
-
-// ---------------------------------------------------------------------------
-// Brands
-// ---------------------------------------------------------------------------
-
-/**
- * Get all brands.
- * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/brand/list
- */
-export async function getBrands<T = any>(): Promise<T[]> {
-	return vtexFetch<T[]>("/api/catalog_system/pub/brand/list");
-}
-
-// ---------------------------------------------------------------------------
-// Page type
-// ---------------------------------------------------------------------------
-
-/**
- * Get the page type for a given term/path.
- * @see https://developers.vtex.com/docs/api-reference/catalog-api#get-/api/catalog_system/pub/portal/pagetype/-term-
- */
-export async function getPageType<T = any>(term: string): Promise<T> {
-	return vtexFetch<T>(`/api/catalog_system/pub/portal/pagetype/${term}`);
-}
-
-// ---------------------------------------------------------------------------
-// Facets (legacy)
-// ---------------------------------------------------------------------------
-
-/**
- * Get facets/filters for a search term.
- * @see https://developers.vtex.com/docs/api-reference/search-api#get-/api/catalog_system/pub/facets/search/-term-
- */
-export async function getFacets<T = any>(term: string): Promise<T> {
-	return vtexFetch<T>(`/api/catalog_system/pub/facets/search/${term}`);
-}