@decocms/apps 0.23.3 → 0.24.0

package/vtex/utils/enrichment.ts

@@ -32,6 +32,28 @@ import { pickSku, toInventories, toProduct, toReview } from "./transform";
 import type { LegacyProduct } from "./types";
 import { buildAuthCookieHeader, VTEX_AUTH_COOKIE } from "./vtexId";
 
+// -------------------------------------------------------------------------
+// Constants
+// -------------------------------------------------------------------------
+
+/** VTEX prices come in cents — divide by this to get the currency value. */
+const CENTS_DIVISOR = 100;
+
+/** Default number of products per simulation API call. */
+const DEFAULT_SIMULATION_BATCH_SIZE = 50;
+
+/** Maximum wishlist items to fetch in a single query. */
+const WISHLIST_MAX_ITEMS = 500;
+
+/** Batch size for kit-item product lookups. */
+const KIT_ITEMS_BATCH_SIZE = 10;
+
+/** Batch size for variant product lookups. */
+const VARIANTS_BATCH_SIZE = 15;
+
+/** Number of reviews to fetch per product. */
+const REVIEWS_PAGE_SIZE = 10;
+
 // -------------------------------------------------------------------------
 // Types
 // -------------------------------------------------------------------------
@@ -47,10 +69,7 @@ export interface EnrichmentContext {
  * A product enricher takes a list of products and returns an enriched list.
  * Enrichers are composed via `createProductPipeline`.
  */
-export type ProductEnricher = (
-	products: Product[],
-	ctx: EnrichmentContext,
-) => Promise<Product[]>;
+export type ProductEnricher = (products: Product[], ctx: EnrichmentContext) => Promise<Product[]>;
 
 // -------------------------------------------------------------------------
 // Pipeline
@@ -63,9 +82,7 @@ export type ProductEnricher = (
  * This is intentional: some enrichers depend on previous enrichments
  * (e.g., wishlist may need SKU IDs added by simulation).
  */
-export function createProductPipeline(
-	...enrichers: ProductEnricher[]
-): ProductEnricher {
+export function createProductPipeline(...enrichers: ProductEnricher[]): ProductEnricher {
 	return async (products, ctx) => {
 		if (!products.length) return products;
 
@@ -115,20 +132,15 @@ interface SimulationResult {
  *
  * @param options.batchSize - Max products per simulation call. @default 50
  */
-export function withSimulation(options?: {
-	batchSize?: number;
-}): ProductEnricher {
-	const batchSize = options?.batchSize ?? 50;
+export function withSimulation(options?: { batchSize?: number }): ProductEnricher {
+	const batchSize = options?.batchSize ?? DEFAULT_SIMULATION_BATCH_SIZE;
 
 	return async (products, ctx) => {
 		const config = getVtexConfig();
 		const sc = ctx.salesChannel ?? config.salesChannel ?? "1";
 
 		const skuItems: SimulationItem[] = [];
-		const skuToProductIndex = new Map<
-			string,
-			{ productIdx: number; offerIdx: number }
-		>();
+		const skuToProductIndex = new Map<string, { productIdx: number; offerIdx: number }>();
 
 		for (let pi = 0; pi < products.length; pi++) {
 			const product = products[pi];
@@ -191,7 +203,7 @@ export function withSimulation(options?: {
 					const offers = [...aggOffer.offers];
 					const offer = { ...offers[mapping.offerIdx] };
 
-					offer.price = simItem.sellingPrice / 100;
+					offer.price = simItem.sellingPrice / CENTS_DIVISOR;
 					if (simItem.listPrice) {
 						(offer as any).priceSpecification = [
 							...(Array.isArray((offer as any).priceSpecification)
@@ -199,10 +211,10 @@ export function withSimulation(options?: {
 								: []),
 						].map((spec: any) => {
 							if (spec?.priceType === "https://schema.org/ListPrice") {
-								return { ...spec, price: simItem.listPrice / 100 };
+								return { ...spec, price: simItem.listPrice / CENTS_DIVISOR };
 							}
 							if (spec?.priceType === "https://schema.org/SalePrice") {
-								return { ...spec, price: simItem.sellingPrice / 100 };
+								return { ...spec, price: simItem.sellingPrice / CENTS_DIVISOR };
 							}
 							return spec;
 						});
@@ -217,10 +229,7 @@ export function withSimulation(options?: {
 					result[mapping.productIdx] = product;
 				}
 			} catch (error) {
-				console.error(
-					"[Simulation] Batch failed:",
-					error instanceof Error ? error.message : error,
-				);
+				console.error("[Simulation] Batch failed:", error instanceof Error ? error.message : error);
 			}
 		}
 
@@ -275,9 +284,7 @@ export function withWishlist(): ProductEnricher {
 		try {
 			const parts = authCookie.split(".");
 			if (parts.length === 3) {
-				const payload = JSON.parse(
-					atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")),
-				);
+				const payload = JSON.parse(atob(parts[1].replace(/-/g, "+").replace(/_/g, "/")));
 				email = payload.sub ?? payload.userId;
 			}
 		} catch {
@@ -290,7 +297,7 @@ export function withWishlist(): ProductEnricher {
 			const data = await vtexIOGraphQL<WishlistData>(
 				{
 					query: WISHLIST_QUERY,
-					variables: { shopperId: email, name: "Wishlist", from: 0, to: 500 },
+					variables: { shopperId: email, name: "Wishlist", from: 0, to: WISHLIST_MAX_ITEMS },
 				},
 				{ Cookie: buildAuthCookieHeader(authCookie, getVtexConfig().account) },
 			);
@@ -369,7 +376,7 @@ export function withKitItems(): ProductEnricher {
 			? `https://${config.publicUrl}`
 			: `https://${config.account}.vtexcommercestable.${config.domain ?? "com.br"}`;
 
-		const batches = batch([...productIDs], 10);
+		const batches = batch([...productIDs], KIT_ITEMS_BATCH_SIZE);
 		const productsById = new Map<string, ProductLeaf>();
 
 		for (const ids of batches) {
@@ -389,10 +396,7 @@ export function withKitItems(): ProductEnricher {
 					}
 				}
 			} catch (e) {
-				console.error(
-					"[KitItems] Batch failed:",
-					e instanceof Error ? e.message : e,
-				);
+				console.error("[KitItems] Batch failed:", e instanceof Error ? e.message : e);
 			}
 		}
 
@@ -428,7 +432,7 @@ export function withVariants(): ProductEnricher {
 			? `https://${config.publicUrl}`
 			: `https://${config.account}.vtexcommercestable.${config.domain ?? "com.br"}`;
 
-		const batches = batch([...productIDs], 15);
+		const batches = batch([...productIDs], VARIANTS_BATCH_SIZE);
 		const productsById = new Map<string, Product>();
 
 		for (const ids of batches) {
@@ -446,10 +450,7 @@ export function withVariants(): ProductEnricher {
 					productsById.set(product.productID, product);
 				}
 			} catch (e) {
-				console.error(
-					"[Variants] Batch failed:",
-					e instanceof Error ? e.message : e,
-				);
+				console.error("[Variants] Batch failed:", e instanceof Error ? e.message : e);
 			}
 		}
 
@@ -476,14 +477,28 @@ export function withReviews(): ProductEnricher {
 
 		const reviewPromises = products.map((product) =>
 			vtexFetch<any>(
-				`https://${myHost}/reviews-and-ratings/api/reviews?product_id=${product.inProductGroupWithID ?? ""}&from=0&to=10&status=true`,
-			).catch(() => ({})),
+				`https://${myHost}/reviews-and-ratings/api/reviews?product_id=${product.inProductGroupWithID ?? ""}&from=0&to=${REVIEWS_PAGE_SIZE}&status=true`,
+			).catch((error) => {
+				console.error(
+					"[Reviews] Failed for product",
+					product.inProductGroupWithID,
+					error instanceof Error ? error.message : error,
+				);
+				return {};
+			}),
 		);
 
 		const ratingPromises = products.map((product) =>
 			vtexFetch<any>(
 				`https://${myHost}/reviews-and-ratings/api/rating/${product.inProductGroupWithID ?? ""}`,
-			).catch(() => ({})),
+			).catch((error) => {
+				console.error(
+					"[Ratings] Failed for product",
+					product.inProductGroupWithID,
+					error instanceof Error ? error.message : error,
+				);
+				return {};
+			}),
 		);
 
 		const [reviews, ratings] = await Promise.all([
@@ -508,9 +523,14 @@ export function withInventory(): ProductEnricher {
 		const inventories = await Promise.all(
 			products.map((product) => {
 				if (!product.sku) return Promise.resolve({});
-				return vtexFetch<any>(
-					`/api/logistics/pvt/inventory/skus/${product.sku}`,
-				).catch(() => ({}));
+				return vtexFetch<any>(`/api/logistics/pvt/inventory/skus/${product.sku}`).catch((error) => {
+					console.error(
+						"[Inventory] Failed for SKU",
+						product.sku,
+						error instanceof Error ? error.message : error,
+					);
+					return {};
+				});
 			}),
 		);
 

package/vtex/utils/fetchCache.ts

@@ -36,9 +36,7 @@ const inflight = new Map<string, Promise<CacheEntry>>();
 
 function evictIfNeeded() {
 	if (store.size <= DEFAULT_MAX_ENTRIES) return;
-	const sorted = [...store.entries()].sort(
-		(a, b) => a[1].createdAt - b[1].createdAt,
-	);
+	const sorted = [...store.entries()].sort((a, b) => a[1].createdAt - b[1].createdAt);
 	const toRemove = sorted.slice(0, store.size - DEFAULT_MAX_ENTRIES);
 	for (const [key] of toRemove) store.delete(key);
 }
@@ -92,7 +90,6 @@ async function executeFetch(
 					`[vtex-fetch] attempt ${attempt + 1}/${attempts} failed — ${url}: ${lastError.message}`,
 				);
 				await sleep(RETRY_DELAYS[attempt] ?? 400);
-				continue;
 			}
 		}
 	}

package/vtex/utils/index.ts

@@ -1,17 +1,17 @@
 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 "./proxy";
 export * from "./vtexId";
-export * from "./sitemap";
-export * from "./enrichment";
-export * from "./resourceRange";
-export * from "./fetchCache";
-export * from "./slugCache";

package/vtex/utils/intelligentSearch.ts

@@ -1,84 +1,75 @@
 import { vtexFetch } from "../client";
-import type {
-  PageType,
-  SelectedFacet,
-  SimulationBehavior,
-  Sort,
-} from "./types";
+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 withDefaultFacets = (allFacets: readonly SelectedFacet[]) => {
+	return [...allFacets];
 };
 
 export const toPath = (facets: SelectedFacet[]) =>
-  facets.map(({ key, value }) => key ? `${key}/${value}` : value).join("/");
+	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;
+	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",
+	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,
+	page: page + 1,
+	count,
+	query,
+	sort,
+	...(fuzzy ? { fuzzy } : {}),
+	locale,
+	hideUnavailableItems: hideUnavailableItems ?? false,
+	simulationBehavior,
 });
 
-export const isFilterParam = (keyFilter: string): boolean =>
-  keyFilter.startsWith("filter.");
+export const isFilterParam = (keyFilter: string): boolean => keyFilter.startsWith("filter.");
 
 const segmentsFromTerm = (term: string) => term.split("/").filter(Boolean);
 
 const segmentsFromSearchParams = (url: string) => {
-  const searchParams = new URLSearchParams(url).entries();
+	const searchParams = new URLSearchParams(url).entries();
 
-  const categories = Array.from(searchParams).sort()
-    .reduce((acc, [key, value]) => {
-      if (key.includes("filter.category")) {
-        acc.push(value);
-      }
+	const categories = Array.from(searchParams)
+		.sort()
+		.reduce((acc, [key, value]) => {
+			if (key.includes("filter.category")) {
+				acc.push(value);
+			}
 
-      return acc;
-    }, [] as string[]);
+			return acc;
+		}, [] as string[]);
 
-  return categories.length ? categories : segmentsFromTerm(url);
+	return categories.length ? categories : segmentsFromTerm(url);
 };
 
-export const pageTypesFromUrl = async (
-  url: string,
-): Promise<PageType[]> => {
-  const segments = segmentsFromSearchParams(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("/")}`,
-      )
-    ),
-  );
+	return await Promise.all(
+		segments.map((_, index) =>
+			vtexFetch<PageType>(
+				`/api/catalog_system/pub/portal/pagetype/${segments.slice(0, index + 1).join("/")}`,
+			),
+		),
+	);
 };

package/vtex/utils/legacy.ts

@@ -1,155 +1,139 @@
 import type { Seo } from "../../commerce/types/commerce";
 import { vtexFetch } from "../client";
+import type { WrappedSegment } from "./segment";
 import { slugify } from "./slugify";
 import type { PageType } from "./types";
-import { WrappedSegment } from "./segment";
 
 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),
-));
+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,
+	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]);
+	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 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 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 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,
+	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,
-    ),
-  };
+	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}`);
-  }
+	if (typeof page === "number") {
+		url.searchParams.set("page", `${page}`);
+	}
 
-  return url.href;
+	return url.href;
 }
 
 export { isFilterParam } from "./intelligentSearch";