@decocms/apps 0.23.2 → 0.24.0

package/vtex/utils/pickAndOmit.ts

@@ -1,30 +1,25 @@
-export function pick<
-  T extends object,
-  K extends keyof T = keyof T,
->(
-  keys: K[],
-  obj: T | null | undefined,
+export function pick<T extends object, K extends keyof T = keyof T>(
+	keys: K[],
+	obj: T | null | undefined,
 ): Pick<T, K> | null {
-  if (!keys.length || !obj) {
-    return null;
-  }
+	if (!keys.length || !obj) {
+		return null;
+	}
 
-  const entries = keys.map((key) => [key, obj[key]]);
+	const entries = keys.map((key) => [key, obj[key]]);
 
-  return Object.fromEntries(entries);
+	return Object.fromEntries(entries);
 }
 
 export function omit<T extends object, K extends keyof T>(
-  keys: K[],
-  obj: T | null | undefined,
+	keys: K[],
+	obj: T | null | undefined,
 ): Omit<T, K> | null {
-  if (!keys.length || !obj) {
-    return null;
-  }
+	if (!keys.length || !obj) {
+		return null;
+	}
 
-  const pickedKeys = (Object.keys(obj) as K[]).filter(
-    (key) => !keys.includes(key),
-  );
+	const pickedKeys = (Object.keys(obj) as K[]).filter((key) => !keys.includes(key));
 
-  return pick(pickedKeys, obj) as unknown as Omit<T, K>;
+	return pick(pickedKeys, obj) as unknown as Omit<T, K>;
 }

package/vtex/utils/proxy.ts

@@ -8,100 +8,93 @@
  * fetch handlers.
  */
 
-import { getVtexConfig, vtexHost, type VtexConfig } from "../client";
+import { getVtexConfig, type VtexConfig, vtexHost } from "../client";
 import { proxySetCookie } from "./cookies";
 
 export interface VtexProxyOptions {
-  /**
-   * VTEX environment suffix.
-   * @default "vtexcommercestable"
-   */
-  environment?: "vtexcommercestable" | "vtexcommercebeta";
-
-  /**
-   * Additional path prefixes to proxy beyond the defaults.
-   * Example: ["/custom-api/"]
-   */
-  extraPaths?: string[];
-
-  /**
-   * Paths that should NOT be proxied even if they match a prefix.
-   */
-  excludePaths?: string[];
-
-  /**
-   * Whether to rewrite Set-Cookie domains to the storefront's domain.
-   * @default true
-   */
-  rewriteCookieDomain?: boolean;
-
-  /**
-   * Custom headers to inject into every proxied request.
-   */
-  extraHeaders?: Record<string, string>;
+	/**
+	 * VTEX environment suffix.
+	 * @default "vtexcommercestable"
+	 */
+	environment?: "vtexcommercestable" | "vtexcommercebeta";
+
+	/**
+	 * Additional path prefixes to proxy beyond the defaults.
+	 * Example: ["/custom-api/"]
+	 */
+	extraPaths?: string[];
+
+	/**
+	 * Paths that should NOT be proxied even if they match a prefix.
+	 */
+	excludePaths?: string[];
+
+	/**
+	 * Whether to rewrite Set-Cookie domains to the storefront's domain.
+	 * @default true
+	 */
+	rewriteCookieDomain?: boolean;
+
+	/**
+	 * Custom headers to inject into every proxied request.
+	 */
+	extraHeaders?: Record<string, string>;
 }
 
 const DEFAULT_PROXY_PATHS = [
-  "/checkout",
-  "/checkout/",
-  "/account",
-  "/account/",
-  "/api/",
-  "/files/",
-  "/arquivos/",
-  "/checkout/changeToAnonymousUser/",
-  "/_v/",
-  "/no-cache/",
-  "/graphql/",
-  "/login",
-  "/login/",
-  "/logout",
-  "/logout/",
-  "/assets/",
-  "/_secure/account",
-  "/XMLData/",
+	"/checkout",
+	"/checkout/",
+	"/account",
+	"/account/",
+	"/api/",
+	"/files/",
+	"/arquivos/",
+	"/checkout/changeToAnonymousUser/",
+	"/_v/",
+	"/no-cache/",
+	"/graphql/",
+	"/login",
+	"/login/",
+	"/logout",
+	"/logout/",
+	"/assets/vtex",
+	"/_secure/account",
+	"/XMLData/",
 ] as const;
 
 const HOP_BY_HOP_HEADERS = new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailers",
-  "transfer-encoding",
-  "upgrade",
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"te",
+	"trailers",
+	"transfer-encoding",
+	"upgrade",
 ]);
 
 /**
  * Returns all path prefixes that should be proxied to VTEX.
  */
 export function getVtexProxyPaths(options?: VtexProxyOptions): string[] {
-  return [...DEFAULT_PROXY_PATHS, ...(options?.extraPaths ?? [])];
+	return [...DEFAULT_PROXY_PATHS, ...(options?.extraPaths ?? [])];
 }
 
 /**
  * Check if a request path should be proxied to VTEX.
  */
-export function shouldProxyToVtex(
-  pathname: string,
-  options?: VtexProxyOptions,
-): boolean {
-  const paths = getVtexProxyPaths(options);
-  const excluded = options?.excludePaths ?? [];
-
-  if (excluded.some((ex) => pathname.startsWith(ex))) return false;
-  return paths.some((prefix) => pathname.startsWith(prefix));
+export function shouldProxyToVtex(pathname: string, options?: VtexProxyOptions): boolean {
+	const paths = getVtexProxyPaths(options);
+	const excluded = options?.excludePaths ?? [];
+
+	if (excluded.some((ex) => pathname.startsWith(ex))) return false;
+	return paths.some((prefix) => pathname.startsWith(prefix));
 }
 
-function buildOriginUrl(
-  request: Request,
-  config: VtexConfig,
-  environment: string,
-): URL {
-  const url = new URL(request.url);
-  const originHost = vtexHost(environment, config);
-  return new URL(`https://${originHost}${url.pathname}${url.search}`);
+function buildOriginUrl(request: Request, config: VtexConfig, environment: string): URL {
+	const url = new URL(request.url);
+	const originHost = vtexHost(environment, config);
+	return new URL(`https://${originHost}${url.pathname}${url.search}`);
 }
 
 /**
@@ -113,15 +106,15 @@ function buildOriginUrl(
  * separately using Headers.getSetCookie() for correct multi-cookie support.
  */
 function filterHeaders(headers: Headers): Headers {
-  const filtered = new Headers();
-  headers.forEach((value, key) => {
-    const lower = key.toLowerCase();
-    if (lower === "set-cookie") return;
-    if (!HOP_BY_HOP_HEADERS.has(lower)) {
-      filtered.set(key, value);
-    }
-  });
-  return filtered;
+	const filtered = new Headers();
+	headers.forEach((value, key) => {
+		const lower = key.toLowerCase();
+		if (lower === "set-cookie") return;
+		if (!HOP_BY_HOP_HEADERS.has(lower)) {
+			filtered.set(key, value);
+		}
+	});
+	return filtered;
 }
 
 /**
@@ -138,69 +131,66 @@ function filterHeaders(headers: Headers): Headers {
  * }
  * ```
  */
-export async function proxyToVtex(
-  request: Request,
-  options?: VtexProxyOptions,
-): Promise<Response> {
-  const config = getVtexConfig();
-  const environment = options?.environment ?? "vtexcommercestable";
-
-  const originUrl = buildOriginUrl(request, config, environment);
-  const forwardHeaders = filterHeaders(new Headers(request.headers));
-
-  forwardHeaders.set("Host", originUrl.hostname);
-  forwardHeaders.set("X-Forwarded-Host", new URL(request.url).hostname);
-  forwardHeaders.set("X-Forwarded-Proto", "https");
-
-  if (options?.extraHeaders) {
-    for (const [k, v] of Object.entries(options.extraHeaders)) {
-      forwardHeaders.set(k, v);
-    }
-  }
-
-  if (typeof config.appKey === "string" && typeof config.appToken === "string") {
-    forwardHeaders.set("X-VTEX-API-AppKey", config.appKey);
-    forwardHeaders.set("X-VTEX-API-AppToken", config.appToken);
-  }
-
-  const init: RequestInit = {
-    method: request.method,
-    headers: forwardHeaders,
-    redirect: "manual",
-  };
-
-  if (request.method !== "GET" && request.method !== "HEAD") {
-    init.body = request.body;
-    // @ts-expect-error -- needed for streaming body in Workers
-    init.duplex = "half";
-  }
-
-  const originResponse = await fetch(originUrl.toString(), init);
-
-  const responseHeaders = filterHeaders(new Headers(originResponse.headers));
-
-  proxySetCookie(
-    originResponse.headers,
-    responseHeaders,
-    options?.rewriteCookieDomain !== false
-      ? new URL(request.url).origin
-      : undefined,
-  );
-
-  if (originResponse.status >= 300 && originResponse.status < 400) {
-    const location = originResponse.headers.get("location");
-    if (location) {
-      const originVtexHost = vtexHost(environment, config);
-      const storefrontOrigin = new URL(request.url).origin;
-      const vtexOrigin = `https://${originVtexHost}`;
-      const rewritten = location.replace(vtexOrigin, storefrontOrigin);
-      responseHeaders.set("location", rewritten);
-    }
-  }
-
-  return new Response(originResponse.body, {
-    status: originResponse.status,
-    statusText: originResponse.statusText,
-    headers: responseHeaders,
-  });
+export async function proxyToVtex(request: Request, options?: VtexProxyOptions): Promise<Response> {
+	const config = getVtexConfig();
+	const environment = options?.environment ?? "vtexcommercestable";
+
+	const originUrl = buildOriginUrl(request, config, environment);
+	const forwardHeaders = filterHeaders(new Headers(request.headers));
+
+	const requestUrl = new URL(request.url);
+	forwardHeaders.set("origin", request.headers.get("origin") ?? requestUrl.origin);
+	forwardHeaders.set("Host", originUrl.hostname);
+	forwardHeaders.set("X-Forwarded-Host", requestUrl.host);
+	forwardHeaders.set("X-Forwarded-Proto", "https");
+
+	if (options?.extraHeaders) {
+		for (const [k, v] of Object.entries(options.extraHeaders)) {
+			forwardHeaders.set(k, v);
+		}
+	}
+
+	if (typeof config.appKey === "string" && typeof config.appToken === "string") {
+		forwardHeaders.set("X-VTEX-API-AppKey", config.appKey);
+		forwardHeaders.set("X-VTEX-API-AppToken", config.appToken);
+	}
+
+	const init: RequestInit = {
+		method: request.method,
+		headers: forwardHeaders,
+		redirect: "manual",
+	};
+
+	if (request.method !== "GET" && request.method !== "HEAD") {
+		init.body = request.body;
+		// @ts-expect-error -- needed for streaming body in Workers
+		init.duplex = "half";
+	}
+
+	const originResponse = await fetch(originUrl.toString(), init);
+
+	const responseHeaders = filterHeaders(new Headers(originResponse.headers));
+
+	proxySetCookie(
+		originResponse.headers,
+		responseHeaders,
+		options?.rewriteCookieDomain !== false ? requestUrl.origin : undefined,
+	);
+
+	if (originResponse.status >= 300 && originResponse.status < 400) {
+		const location = originResponse.headers.get("location");
+		if (location) {
+			const originVtexHost = vtexHost(environment, config);
+			const storefrontOrigin = requestUrl.origin;
+			const vtexOrigin = `https://${originVtexHost}`;
+			const rewritten = location.replace(vtexOrigin, storefrontOrigin);
+			responseHeaders.set("location", rewritten);
+		}
+	}
+
+	return new Response(originResponse.body, {
+		status: originResponse.status,
+		statusText: originResponse.statusText,
+		headers: responseHeaders,
+	});
 }

package/vtex/utils/resourceRange.ts

@@ -3,8 +3,8 @@
  * Ported from deco-cx/apps vtex/utils/resourceRange.ts
  */
 export function resourceRange(skip: number, take: number) {
-  const from = Math.max(skip, 0);
-  const to = from + Math.min(100, take);
+	const from = Math.max(skip, 0);
+	const to = from + Math.min(100, take);
 
-  return { from, to };
+	return { from, to };
 }

package/vtex/utils/segment.ts

@@ -1,28 +1,27 @@
 import type { Segment } from "./types";
 
-const removeNonLatin1Chars = (str: string) =>
-  str.replace(/[^\x00-\xFF]/g, "");
+const removeNonLatin1Chars = (str: string) => str.replace(/[^\x00-\xFF]/g, "");
 
 export const SEGMENT_COOKIE_NAME = "vtex_segment";
 export const SALES_CHANNEL_COOKIE = "VTEXSC";
 
 export interface WrappedSegment {
-  payload: Partial<Segment>;
-  token: string;
+	payload: Partial<Segment>;
+	token: string;
 }
 
 export const DEFAULT_SEGMENT: Partial<Segment> = {
-  utmi_campaign: null,
-  utmi_page: null,
-  utmi_part: null,
-  utm_campaign: null,
-  utm_source: null,
-  utm_medium: null,
-  channel: "1",
-  cultureInfo: "pt-BR",
-  currencyCode: "BRL",
-  currencySymbol: "R$",
-  countryCode: "BRA",
+	utmi_campaign: null,
+	utmi_page: null,
+	utmi_part: null,
+	utm_campaign: null,
+	utm_source: null,
+	utm_medium: null,
+	channel: "1",
+	cultureInfo: "pt-BR",
+	currencyCode: "BRL",
+	currencySymbol: "R$",
+	countryCode: "BRA",
 };
 
 /**
@@ -32,95 +31,87 @@ export const DEFAULT_SEGMENT: Partial<Segment> = {
  * value will be the same. This improves cache hits.
  */
 export const serializeSegment = ({
-  campaigns,
-  channel,
-  priceTables,
-  regionId,
-  utm_campaign,
-  utm_source,
-  utm_medium,
-  utmi_campaign,
-  utmi_page,
-  utmi_part,
-  currencyCode,
-  currencySymbol,
-  countryCode,
-  cultureInfo,
-  channelPrivacy,
+	campaigns,
+	channel,
+	priceTables,
+	regionId,
+	utm_campaign,
+	utm_source,
+	utm_medium,
+	utmi_campaign,
+	utmi_page,
+	utmi_part,
+	currencyCode,
+	currencySymbol,
+	countryCode,
+	cultureInfo,
+	channelPrivacy,
 }: Partial<Segment>): string => {
-  const seg = {
-    campaigns,
-    channel,
-    priceTables,
-    regionId,
-    utm_campaign: utm_campaign &&
-      removeNonLatin1Chars(utm_campaign).replace(/[\/\[\]{}()<>.]/g, ""),
-    utm_source: utm_source &&
-      removeNonLatin1Chars(utm_source).replace(/[\/\[\]{}()<>.]/g, ""),
-    utm_medium: utm_medium &&
-      removeNonLatin1Chars(utm_medium).replace(/[\/\[\]{}()<>.]/g, ""),
-    utmi_campaign: utmi_campaign && removeNonLatin1Chars(utmi_campaign),
-    utmi_page: utmi_page && removeNonLatin1Chars(utmi_page),
-    utmi_part: utmi_part && removeNonLatin1Chars(utmi_part),
-    currencyCode,
-    currencySymbol,
-    countryCode,
-    cultureInfo,
-    channelPrivacy,
-  };
-  return btoa(JSON.stringify(seg));
+	const seg = {
+		campaigns,
+		channel,
+		priceTables,
+		regionId,
+		utm_campaign: utm_campaign && removeNonLatin1Chars(utm_campaign).replace(/[/[\]{}()<>.]/g, ""),
+		utm_source: utm_source && removeNonLatin1Chars(utm_source).replace(/[/[\]{}()<>.]/g, ""),
+		utm_medium: utm_medium && removeNonLatin1Chars(utm_medium).replace(/[/[\]{}()<>.]/g, ""),
+		utmi_campaign: utmi_campaign && removeNonLatin1Chars(utmi_campaign),
+		utmi_page: utmi_page && removeNonLatin1Chars(utmi_page),
+		utmi_part: utmi_part && removeNonLatin1Chars(utmi_part),
+		currencyCode,
+		currencySymbol,
+		countryCode,
+		cultureInfo,
+		channelPrivacy,
+	};
+	return btoa(JSON.stringify(seg));
 };
 
 export const parseSegment = (cookie: string): Partial<Segment> | null => {
-  try {
-    return JSON.parse(atob(cookie));
-  } catch {
-    return null;
-  }
+	try {
+		return JSON.parse(atob(cookie));
+	} catch {
+		return null;
+	}
 };
 
 const SEGMENT_QUERY_PARAMS = [
-  "utmi_campaign",
-  "utmi_page",
-  "utmi_part",
-  "utm_campaign",
-  "utm_source",
-  "utm_medium",
+	"utmi_campaign",
+	"utmi_page",
+	"utmi_part",
+	"utm_campaign",
+	"utm_source",
+	"utm_medium",
 ] as const;
 
-export const buildSegmentFromParams = (
-  searchParams: URLSearchParams,
-): Partial<Segment> => {
-  const partialSegment: Partial<Segment> = {};
-  for (const qs of SEGMENT_QUERY_PARAMS) {
-    const param = searchParams.get(qs);
-    if (param) {
-      partialSegment[qs] = param;
-    }
-  }
-
-  const sc = searchParams.get("sc");
-  if (sc) {
-    partialSegment.channel = sc;
-  }
-
-  return partialSegment;
+export const buildSegmentFromParams = (searchParams: URLSearchParams): Partial<Segment> => {
+	const partialSegment: Partial<Segment> = {};
+	for (const qs of SEGMENT_QUERY_PARAMS) {
+		const param = searchParams.get(qs);
+		if (param) {
+			partialSegment[qs] = param;
+		}
+	}
+
+	const sc = searchParams.get("sc");
+	if (sc) {
+		partialSegment.channel = sc;
+	}
+
+	return partialSegment;
 };
 
-export const withSegmentCookie = (
-  segment: WrappedSegment,
-  headers?: Headers,
-): Headers => {
-  const h = new Headers(headers);
-  if (!segment) return h;
+export const withSegmentCookie = (segment: WrappedSegment, headers?: Headers): Headers => {
+	const h = new Headers(headers);
+	if (!segment) return h;
 
-  h.set("cookie", `${SEGMENT_COOKIE_NAME}=${segment.token}`);
-  return h;
+	h.set("cookie", `${SEGMENT_COOKIE_NAME}=${segment.token}`);
+	return h;
 };
 
 function getCookieValue(cookieHeader: string, name: string): string | null {
-  const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${name}=([^;]+)`));
-  return match?.[1] ?? null;
+	const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${name}=([^;]+)`));
+	return match?.[1] ?? null;
 }
 
 /**
@@ -128,20 +119,18 @@ function getCookieValue(cookieHeader: string, name: string): string | null {
  * Reads both vtex_segment and VTEXSC cookies.
  * VTEXSC contains the sales channel and overrides the segment channel.
  */
-export const buildSegmentFromCookies = (
-  cookieHeader: string,
-): Partial<Segment> => {
-  const segmentCookie = getCookieValue(cookieHeader, SEGMENT_COOKIE_NAME);
-  const vtexsc = getCookieValue(cookieHeader, SALES_CHANNEL_COOKIE);
+export const buildSegmentFromCookies = (cookieHeader: string): Partial<Segment> => {
+	const segmentCookie = getCookieValue(cookieHeader, SEGMENT_COOKIE_NAME);
+	const vtexsc = getCookieValue(cookieHeader, SALES_CHANNEL_COOKIE);
 
-  const base = segmentCookie ? parseSegment(segmentCookie) : null;
-  const segment: Partial<Segment> = { ...DEFAULT_SEGMENT, ...base };
+	const base = segmentCookie ? parseSegment(segmentCookie) : null;
+	const segment: Partial<Segment> = { ...DEFAULT_SEGMENT, ...base };
 
-  if (vtexsc) {
-    segment.channel = vtexsc;
-  }
+	if (vtexsc) {
+		segment.channel = vtexsc;
+	}
 
-  return segment;
+	return segment;
 };
 
 /**
@@ -149,15 +138,15 @@ export const buildSegmentFromCookies = (
  * (no campaigns, no UTMs, no regionId, no custom priceTables).
  */
 export const isAnonymous = (segment: Partial<Segment>): boolean => {
-  return (
-    !segment.campaigns &&
-    !segment.utm_campaign &&
-    !segment.utm_source &&
-    !segment.utm_medium &&
-    !segment.utmi_campaign &&
-    !segment.utmi_page &&
-    !segment.utmi_part &&
-    !segment.regionId &&
-    !segment.priceTables
-  );
+	return (
+		!segment.campaigns &&
+		!segment.utm_campaign &&
+		!segment.utm_source &&
+		!segment.utm_medium &&
+		!segment.utmi_campaign &&
+		!segment.utmi_page &&
+		!segment.utmi_part &&
+		!segment.regionId &&
+		!segment.priceTables
+	);
 };

package/vtex/utils/similars.ts

@@ -4,8 +4,7 @@ import { pickSku, toProduct } from "./transform";
 import type { LegacyProduct } from "./types";
 
 export const withIsSimilarTo = async (product: Product): Promise<Product> => {
-	const id =
-		product.isVariantOf?.productGroupID ?? product.inProductGroupWithID;
+	const id = product.isVariantOf?.productGroupID ?? product.inProductGroupWithID;
 
 	if (!id) {
 		return product;