@decocms/apps-vtex 8.1.0-next.0 → 8.1.0-next.2

package/src/loaders/workflow.ts

@@ -1,316 +0,0 @@
-/**
- * VTEX Workflow loaders (internal/back-office use).
- * These transform raw VTEX Catalog data into schema.org-compatible Product types.
- * NOT intended for storefront rendering — used in data pipelines and workflows.
- *
- * Pure async functions — require configureVtex() to have been called.
- *
- * Ported from deco-cx/apps:
- *   vtex/loaders/workflow/product.ts
- *   vtex/loaders/workflow/products.ts
- *
- * @see https://developers.vtex.com/docs/api-reference/catalog-api
- */
-import type {
-	Offer,
-	Product,
-	PropertyValue,
-	UnitPriceSpecification,
-} from "@decocms/apps-commerce/types";
-import { vtexFetch } from "../client";
-import {
-	aggregateOffers,
-	toAdditionalPropertyCategory,
-	toAdditionalPropertyCluster,
-	toAdditionalPropertyReferenceId,
-	toAdditionalPropertySpecification,
-} from "../utils/transform";
-
-/** VTEX prices come in cents — divide by this to get the currency value. */
-const CENTS_DIVISOR = 100;
-
-// ---------------------------------------------------------------------------
-// Types for pvt Catalog APIs
-// ---------------------------------------------------------------------------
-
-interface SkuImage {
-	ImageUrl: string;
-	ImageName?: string;
-	FileId?: string;
-}
-
-interface SkuSpecification {
-	FieldName: string;
-	FieldValues: string[];
-	FieldValueIds: number[];
-}
-
-interface SkuSeller {
-	SellerId: string;
-}
-
-interface SkuAlternateIds {
-	RefId?: string;
-	Ean?: string;
-}
-
-interface PvtSku {
-	Id: number;
-	ProductId: number;
-	IsActive: boolean;
-	SkuName: string;
-	ProductName: string;
-	ProductDescription: string;
-	DetailUrl: string;
-	BrandId: string;
-	BrandName: string;
-	ReleaseDate?: string;
-	Images: SkuImage[];
-	SkuSpecifications: SkuSpecification[];
-	ProductSpecifications: SkuSpecification[];
-	ProductCategories: Record<string, string>;
-	ProductClusterNames: Record<string, string>;
-	SalesChannels: number[];
-	AlternateIds: SkuAlternateIds;
-	SkuSellers: SkuSeller[];
-}
-
-interface PvtSkuListItem {
-	Id: number;
-	IsActive: boolean;
-}
-
-interface SalesChannel {
-	Id: number;
-	CurrencyCode: string;
-}
-
-interface SimulationItem {
-	sellingPrice: number;
-	listPrice: number;
-	price: number;
-	seller: string;
-	priceValidUntil: string;
-	availability: string;
-}
-
-interface SimulationPaymentOption {
-	paymentName: string;
-	installments: Array<{ count: number; value: number; total: number }>;
-}
-
-interface SimulationResponse {
-	items?: SimulationItem[];
-	paymentData?: { installmentOptions?: SimulationPaymentOption[] };
-}
-
-// ---------------------------------------------------------------------------
-// workflowProduct
-// ---------------------------------------------------------------------------
-
-export interface WorkflowProductOptions {
-	/** The SKU ID (stockKeepingUnitId) to load */
-	productID: string;
-	/** Sales channel for simulation. Defaults to 1. */
-	salesChannel?: number;
-}
-
-/**
- * Transform a single VTEX SKU (via private Catalog API) into a commerce Product.
- *
- * Fetches the SKU details, all sibling SKUs for the same product, sales channels,
- * and runs checkout simulation for each seller to build offer data.
- *
- * Ported from: vtex/loaders/workflow/product.ts
- */
-export async function workflowProduct(opts: WorkflowProductOptions): Promise<Product | null> {
-	const sc = opts.salesChannel ?? 1;
-
-	const sku = await vtexFetch<PvtSku>(
-		`/api/catalog_system/pvt/sku/stockkeepingunitbyid/${opts.productID}`,
-	);
-
-	if (!sku.IsActive) return null;
-
-	const [skus, salesChannels, ...simulations] = await Promise.all([
-		vtexFetch<PvtSkuListItem[]>(
-			`/api/catalog_system/pvt/sku/stockkeepingunitByProductId/${sku.ProductId}`,
-		),
-		vtexFetch<SalesChannel[]>("/api/catalog_system/pvt/saleschannel/list"),
-		...sku.SkuSellers.map(({ SellerId }) =>
-			vtexFetch<SimulationResponse>(
-				`/api/checkout/pub/orderForms/simulation?RnbBehavior=1&sc=${sc}`,
-				{
-					method: "POST",
-					body: JSON.stringify({
-						items: [{ id: `${sku.Id}`, seller: SellerId, quantity: 1 }],
-					}),
-				},
-			),
-		),
-	]);
-
-	const channel = salesChannels.find((c) => c.Id === sc);
-	const productGroupID = `${sku.ProductId}`;
-	const productID = `${sku.Id}`;
-
-	const additionalProperty = [
-		sku.AlternateIds.RefId
-			? toAdditionalPropertyReferenceId({
-					name: "RefId",
-					value: sku.AlternateIds.RefId,
-				})
-			: null,
-		...Object.entries(sku.ProductCategories ?? {}).map(([propertyID, value]) =>
-			toAdditionalPropertyCategory({ propertyID, value }),
-		),
-		...Object.entries(sku.ProductClusterNames ?? {}).map(([propertyID, value]) =>
-			toAdditionalPropertyCluster({ propertyID, value }),
-		),
-		...sku.SkuSpecifications.flatMap((spec) =>
-			spec.FieldValues.map((value, it) =>
-				toAdditionalPropertySpecification({
-					propertyID: spec.FieldValueIds[it]?.toString(),
-					name: spec.FieldName,
-					value,
-				}),
-			),
-		),
-		...sku.SalesChannels.map(
-			(ch): PropertyValue => ({
-				"@type": "PropertyValue",
-				name: "salesChannel",
-				propertyID: ch.toString(),
-			}),
-		),
-	].filter((p): p is PropertyValue => Boolean(p));
-
-	const groupAdditionalProperty = sku.ProductSpecifications.flatMap((spec) =>
-		spec.FieldValues.map((value, it) =>
-			toAdditionalPropertySpecification({
-				propertyID: spec.FieldValueIds[it]?.toString(),
-				name: spec.FieldName,
-				value,
-			}),
-		),
-	);
-
-	const offers = simulations
-		.flatMap(({ items, paymentData }) =>
-			items?.map((item): Offer | null => {
-				const { sellingPrice, listPrice, price, seller, priceValidUntil, availability } = item;
-				const spotPrice = sellingPrice || price;
-				if (!spotPrice || !listPrice) return null;
-
-				return {
-					"@type": "Offer",
-					price: spotPrice / CENTS_DIVISOR,
-					seller,
-					priceValidUntil,
-					inventoryLevel: {},
-					availability:
-						availability === "available"
-							? "https://schema.org/InStock"
-							: "https://schema.org/OutOfStock",
-					priceSpecification: [
-						{
-							"@type": "UnitPriceSpecification",
-							priceType: "https://schema.org/ListPrice",
-							price: listPrice / CENTS_DIVISOR,
-						},
-						{
-							"@type": "UnitPriceSpecification",
-							priceType: "https://schema.org/SalePrice",
-							price: spotPrice / CENTS_DIVISOR,
-						},
-						...(paymentData?.installmentOptions?.flatMap((option): UnitPriceSpecification[] =>
-							option.installments.map((i) => ({
-								"@type": "UnitPriceSpecification",
-								priceType: "https://schema.org/SalePrice",
-								priceComponentType: "https://schema.org/Installment",
-								name: option.paymentName,
-								billingDuration: i.count,
-								billingIncrement: i.value / CENTS_DIVISOR,
-								price: i.total / CENTS_DIVISOR,
-							})),
-						) ?? []),
-					],
-				};
-			}),
-		)
-		.filter((o): o is Offer => Boolean(o));
-
-	return {
-		"@type": "Product",
-		productID,
-		sku: productID,
-		inProductGroupWithID: productGroupID,
-		category: Object.values(sku.ProductCategories ?? {}).join(" > "),
-		url: `${sku.DetailUrl}?skuId=${productID}`,
-		name: sku.SkuName,
-		gtin: sku.AlternateIds.Ean,
-		image: sku.Images.map((img) => ({
-			"@type": "ImageObject",
-			encodingFormat: "image",
-			alternateName: img.ImageName ?? img.FileId,
-			url: img.ImageUrl,
-		})),
-		isVariantOf: {
-			"@type": "ProductGroup",
-			url: sku.DetailUrl,
-			hasVariant:
-				skus
-					?.filter((x) => x.IsActive)
-					.map(({ Id }) => ({
-						"@type": "Product",
-						productID: `${Id}`,
-						sku: `${Id}`,
-					})) ?? [],
-			additionalProperty: groupAdditionalProperty,
-			productGroupID,
-			name: sku.ProductName,
-			description: sku.ProductDescription,
-		},
-		additionalProperty,
-		releaseDate: sku.ReleaseDate ? new Date(sku.ReleaseDate).toISOString() : undefined,
-		brand: {
-			"@type": "Brand",
-			"@id": sku.BrandId,
-			name: sku.BrandName,
-		},
-		offers: aggregateOffers(offers, channel?.CurrencyCode),
-	};
-}
-
-// ---------------------------------------------------------------------------
-// workflowProducts
-// ---------------------------------------------------------------------------
-
-export interface WorkflowProductsOptions {
-	page: number;
-	pagesize: number;
-}
-
-/**
- * Fetch a page of SKU IDs and return minimal Product stubs.
- * Use in batch workflows to enumerate the catalog; call workflowProduct
- * for each ID if full details are needed.
- *
- * Ported from: vtex/loaders/workflow/products.ts
- */
-export async function workflowProducts(opts: WorkflowProductsOptions): Promise<Product[]> {
-	const params = new URLSearchParams({
-		page: String(opts.page),
-		pagesize: String(opts.pagesize),
-	});
-
-	const ids = await vtexFetch<number[]>(
-		`/api/catalog_system/pvt/sku/stockkeepingunitids?${params}`,
-	);
-
-	return ids.map((productID) => ({
-		"@type": "Product",
-		productID: `${productID}`,
-		sku: `${productID}`,
-	}));
-}

package/src/manifest.gen.ts

@@ -1,89 +0,0 @@
-// AUTO-GENERATED by scripts/generate-manifests.ts — DO NOT EDIT
-// This file is checked into source control and updated via: npm run generate:manifests
-
-import * as actions_address from "./actions/address";
-import * as actions_analytics_sendEvent from "./actions/analytics/sendEvent";
-import * as actions_auth from "./actions/auth";
-import * as actions_checkout from "./actions/checkout";
-import * as actions_masterData from "./actions/masterData";
-import * as actions_misc from "./actions/misc";
-import * as actions_newsletter from "./actions/newsletter";
-import * as actions_orders from "./actions/orders";
-import * as actions_profile from "./actions/profile";
-import * as actions_session from "./actions/session";
-import * as actions_trigger from "./actions/trigger";
-import * as actions_wishlist from "./actions/wishlist";
-import * as loaders_address from "./loaders/address";
-import * as loaders_autocomplete from "./loaders/autocomplete";
-import * as loaders_brands from "./loaders/brands";
-import * as loaders_cart from "./loaders/cart";
-import * as loaders_cart_attachments from "./loaders/cart/attachments";
-import * as loaders_cart_full from "./loaders/cart/full";
-import * as loaders_cart_gifts from "./loaders/cart/gifts";
-import * as loaders_cart_shipping from "./loaders/cart/shipping";
-import * as loaders_cart_summary from "./loaders/cart/summary";
-import * as loaders_catalog from "./loaders/catalog";
-import * as loaders_collections from "./loaders/collections";
-import * as loaders_legacy from "./loaders/legacy";
-import * as loaders_logistics from "./loaders/logistics";
-import * as loaders_navbar from "./loaders/navbar";
-import * as loaders_orders from "./loaders/orders";
-import * as loaders_pageType from "./loaders/pageType";
-import * as loaders_payment from "./loaders/payment";
-import * as loaders_profile from "./loaders/profile";
-import * as loaders_promotion from "./loaders/promotion";
-import * as loaders_search from "./loaders/search";
-import * as loaders_session from "./loaders/session";
-import * as loaders_user from "./loaders/user";
-import * as loaders_wishlist from "./loaders/wishlist";
-import * as loaders_wishlistProducts from "./loaders/wishlistProducts";
-import * as loaders_workflow from "./loaders/workflow";
-
-const manifest = {
-  name: "vtex",
-  loaders: {
-    "vtex/loaders/address": loaders_address,
-    "vtex/loaders/autocomplete": loaders_autocomplete,
-    "vtex/loaders/brands": loaders_brands,
-    "vtex/loaders/cart": loaders_cart,
-    "vtex/loaders/cart/summary": loaders_cart_summary,
-    "vtex/loaders/cart/full": loaders_cart_full,
-    "vtex/loaders/cart/shipping": loaders_cart_shipping,
-    "vtex/loaders/cart/gifts": loaders_cart_gifts,
-    "vtex/loaders/cart/attachments": loaders_cart_attachments,
-    "vtex/loaders/catalog": loaders_catalog,
-    "vtex/loaders/collections": loaders_collections,
-    "vtex/loaders/legacy": loaders_legacy,
-    "vtex/loaders/logistics": loaders_logistics,
-    "vtex/loaders/navbar": loaders_navbar,
-    "vtex/loaders/orders": loaders_orders,
-    "vtex/loaders/pageType": loaders_pageType,
-    "vtex/loaders/payment": loaders_payment,
-    "vtex/loaders/profile": loaders_profile,
-    "vtex/loaders/promotion": loaders_promotion,
-    "vtex/loaders/search": loaders_search,
-    "vtex/loaders/session": loaders_session,
-    "vtex/loaders/user": loaders_user,
-    "vtex/loaders/wishlist": loaders_wishlist,
-    "vtex/loaders/wishlistProducts": loaders_wishlistProducts,
-    "vtex/loaders/workflow": loaders_workflow,
-  },
-  actions: {
-    "vtex/actions/address": actions_address,
-    "vtex/actions/analytics/sendEvent": actions_analytics_sendEvent,
-    "vtex/actions/auth": actions_auth,
-    "vtex/actions/checkout": actions_checkout,
-    "vtex/actions/masterData": actions_masterData,
-    "vtex/actions/misc": actions_misc,
-    "vtex/actions/newsletter": actions_newsletter,
-    "vtex/actions/orders": actions_orders,
-    "vtex/actions/profile": actions_profile,
-    "vtex/actions/session": actions_session,
-    "vtex/actions/trigger": actions_trigger,
-    "vtex/actions/wishlist": actions_wishlist,
-  },
-  sections: {},
-} as const;
-
-export type Manifest = typeof manifest;
-export default manifest;

package/src/middleware.cacheHeaders.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { vtexMiddleware } from "./mod";
-
-/**
- * The VTEX app middleware wraps the framework's entire edge-cache layer, so it
- * is the last writer of Cache-Control on every response — including cache HITs.
- * These tests pin the two things that made that dangerous.
- */
-
-// A response as the framework's cache layer would hand it over: public headers
-// resolved from the page's cache profile, plus the CDN header.
-function cachedResponse(): Response {
-  return new Response("page", {
-    headers: {
-      "Cache-Control": "public, max-age=120, s-maxage=900, stale-while-revalidate=1800",
-      "CDN-Cache-Control": "public, max-age=900",
-    },
-  });
-}
-
-const next = async () => cachedResponse();
-
-describe("vtexMiddleware cache headers", () => {
-  it("leaves the cache layer's headers alone for an anonymous request", async () => {
-    const res = await vtexMiddleware(new Request("https://store.com/"), next);
-    // Used to be downgraded to vtexCacheControl's generic `s-maxage=60`,
-    // throwing away the profile the cache layer had resolved.
-    expect(res.headers.get("Cache-Control")).toContain("s-maxage=900");
-  });
-
-  it("forces private headers and clears the CDN header when logged in", async () => {
-    const req = new Request("https://store.com/", {
-      // extractVtexContext treats any VtexIdclientAutCookie* as authenticated.
-      headers: { cookie: "VtexIdclientAutCookie_store=abc123" },
-    });
-    const res = await vtexMiddleware(req, next);
-
-    expect(res.headers.get("Cache-Control")).toContain("no-store");
-    // Cloudflare gives CDN-Cache-Control precedence, so leaving the public
-    // value behind would cache a personalized page at the CDN regardless of
-    // the private Cache-Control next to it.
-    expect(res.headers.get("CDN-Cache-Control")).toBeNull();
-  });
-});

package/src/middleware.ts

@@ -1,240 +0,0 @@
-/**
- * VTEX Middleware utilities for TanStack Start.
- *
- * Extracts segment information from cookies/URL params, detects login state,
- * propagates Intelligent Search cookies, and provides cache-control decisions.
- *
- * Use with TanStack Start's createMiddleware() in the storefront:
- *
- * @example
- * ```ts
- * import { createMiddleware } from "@tanstack/react-start";
- * import {
- *   extractVtexContext,
- *   vtexCacheControl,
- * } from "@decocms/apps/vtex/middleware";
- *
- * const vtexMiddleware = createMiddleware().server(async ({ next, request }) => {
- *   const vtexCtx = extractVtexContext(request);
- *   const response = await next();
- *   response.headers.set("Cache-Control", vtexCacheControl(vtexCtx));
- *   propagateISCookies(request, response);
- *   return response;
- * });
- * ```
- */
-
-import { ANONYMOUS_COOKIE, SESSION_COOKIE } from "./utils/intelligentSearch";
-import {
-	buildSegmentFromParams,
-	DEFAULT_SEGMENT,
-	parseSegment,
-	SALES_CHANNEL_COOKIE,
-	SEGMENT_COOKIE_NAME,
-	serializeSegment,
-} from "./utils/segment";
-import type { Segment } from "./utils/types";
-import { extractVtexAuthCookie, parseVtexAuthToken } from "./utils/vtexId";
-
-// -------------------------------------------------------------------------
-// Types
-// -------------------------------------------------------------------------
-
-export interface VtexRequestContext {
-	/** Decoded segment from cookie or URL params. */
-	segment: Partial<Segment>;
-	/** Serialized segment token for cache key use. */
-	segmentToken: string;
-	/** Whether the user has a valid (non-expired) VTEX auth cookie. */
-	isLoggedIn: boolean;
-	/** Extracted email from the auth JWT, if available. */
-	email?: string;
-	/** Sales channel derived from segment. */
-	salesChannel: string;
-	/**
-	 * VTEX region ID from the segment cookie.
-	 * Present when the user has set a postal code (CEP) for regionalization.
-	 * Null when no region is set (anonymous default segment).
-	 */
-	regionId: string | null;
-	/** Whether this request carries price tables (B2B). */
-	hasCustomPricing: boolean;
-	/** Intelligent Search session cookie. */
-	isSessionId: string;
-	/** Intelligent Search anonymous cookie. */
-	isAnonymousId: string;
-	/** Whether IS cookies were freshly generated (browser didn't send them). */
-	needsISCookies: boolean;
-}
-
-// -------------------------------------------------------------------------
-// Cookie helpers
-// -------------------------------------------------------------------------
-
-const _IS_COOKIE_PREFIX = "vtex_is_";
-
-/** Seconds in one day (86 400). Used for cookie Max-Age and stale-if-error. */
-const ONE_DAY_SECONDS = 86_400;
-
-/** Seconds in one year (~365 days). Used for long-lived IS cookie Max-Age. */
-const ONE_YEAR_SECONDS = 365 * 24 * 60 * 60;
-
-function getCookieValue(cookieHeader: string, name: string): string | null {
-	const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${name}=([^;]+)`));
-	return match?.[1] ?? null;
-}
-
-// -------------------------------------------------------------------------
-// Core extraction
-// -------------------------------------------------------------------------
-
-/**
- * Extract VTEX context from an incoming request.
- *
- * Reads the segment cookie, URL params (utm_*, sc), and auth cookie
- * to build a complete picture of the user's VTEX session state.
- */
-function generateUUID(): string {
-	if (typeof crypto !== "undefined" && crypto.randomUUID) {
-		return crypto.randomUUID();
-	}
-	return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-		const r = (Math.random() * 16) | 0;
-		return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
-	});
-}
-
-export function extractVtexContext(request: Request): VtexRequestContext {
-	const cookies = request.headers.get("cookie") ?? "";
-	const url = new URL(request.url);
-
-	const segmentCookie = getCookieValue(cookies, SEGMENT_COOKIE_NAME);
-	const cookieSegment = segmentCookie ? parseSegment(segmentCookie) : null;
-
-	const paramSegment = buildSegmentFromParams(url.searchParams);
-
-	const vtexsc = getCookieValue(cookies, SALES_CHANNEL_COOKIE);
-
-	const segment: Partial<Segment> = {
-		...DEFAULT_SEGMENT,
-		...cookieSegment,
-		...paramSegment,
-	};
-	if (vtexsc) segment.channel = vtexsc;
-
-	const segmentToken = serializeSegment(segment);
-
-	const authToken = extractVtexAuthCookie(cookies);
-	const authInfo = authToken ? parseVtexAuthToken(authToken) : null;
-
-	const existingSessionId = getCookieValue(cookies, SESSION_COOKIE);
-	const existingAnonymousId = getCookieValue(cookies, ANONYMOUS_COOKIE);
-	const needsISCookies = !existingSessionId || !existingAnonymousId;
-
-	return {
-		segment,
-		segmentToken,
-		isLoggedIn: authInfo?.isLoggedIn ?? false,
-		email: authInfo?.email,
-		salesChannel: segment.channel ?? "1",
-		regionId: segment.regionId ?? null,
-		hasCustomPricing: Boolean(segment.priceTables && segment.priceTables.length > 0),
-		isSessionId: existingSessionId ?? generateUUID(),
-		isAnonymousId: existingAnonymousId ?? generateUUID(),
-		needsISCookies,
-	};
-}
-
-// -------------------------------------------------------------------------
-// Cache control
-// -------------------------------------------------------------------------
-
-/**
- * Determine the appropriate Cache-Control header based on VTEX context.
- *
- * Rules:
- * - Logged-in users: private (personalized prices, wishlists, etc.)
- * - Custom pricing (B2B): private (price table specific)
- * - Anonymous default segment: public with CDN caching
- */
-export function vtexCacheControl(
-	ctx: VtexRequestContext,
-	options?: {
-		/** Max age for public (anonymous) responses in seconds. @default 60 */
-		publicMaxAge?: number;
-		/** Stale-while-revalidate for public responses in seconds. @default 3600 */
-		publicSWR?: number;
-	},
-): string {
-	if (ctx.isLoggedIn || ctx.hasCustomPricing) {
-		return "private, no-cache, no-store, must-revalidate";
-	}
-
-	const maxAge = options?.publicMaxAge ?? 60;
-	const swr = options?.publicSWR ?? 3600;
-
-	return `public, s-maxage=${maxAge}, stale-while-revalidate=${swr}, stale-if-error=${ONE_DAY_SECONDS}`;
-}
-
-// -------------------------------------------------------------------------
-// Cookie propagation
-// -------------------------------------------------------------------------
-
-/**
- * Set Intelligent Search cookies on the response only when the browser
- * doesn't already have them. On subsequent requests where the cookies
- * exist, this is a no-op — keeping the response free of Set-Cookie
- * headers so it remains cacheable at the CDN edge.
- */
-export function propagateISCookies(ctx: VtexRequestContext, response: Response): void {
-	if (!ctx.needsISCookies) return;
-
-	const maxAge = ONE_YEAR_SECONDS;
-	response.headers.append(
-		"Set-Cookie",
-		`${SESSION_COOKIE}=${ctx.isSessionId}; Path=/; SameSite=Lax; Max-Age=${maxAge}`,
-	);
-	response.headers.append(
-		"Set-Cookie",
-		`${ANONYMOUS_COOKIE}=${ctx.isAnonymousId}; Path=/; SameSite=Lax; Max-Age=${maxAge}`,
-	);
-}
-
-/**
- * Build a segment cookie Set-Cookie header for the response.
- *
- * Use this when URL params change the segment (e.g., ?sc=2) so the
- * browser persists the new segment for subsequent requests.
- */
-export function buildSegmentSetCookie(segment: Partial<Segment>, domain?: string): string {
-	const token = serializeSegment(segment);
-	let cookie = `${SEGMENT_COOKIE_NAME}=${token}; Path=/; SameSite=Lax; Max-Age=${ONE_DAY_SECONDS}`;
-	if (domain) cookie += `; Domain=${domain}`;
-	return cookie;
-}
-
-// -------------------------------------------------------------------------
-// Cache key helpers
-// -------------------------------------------------------------------------
-
-/**
- * Build a cache key suffix from the VTEX context.
- *
- * This is used in the Cloudflare Worker entry to differentiate cached
- * responses by segment. Two anonymous users on the same sales channel
- * get the same cache key; a logged-in user gets a unique (uncached) key.
- */
-export function vtexCacheKeySuffix(ctx: VtexRequestContext): string {
-	if (ctx.isLoggedIn) return "__vtex_auth";
-	const parts = [`sc=${ctx.salesChannel}`];
-	if (ctx.regionId) parts.push(`r=${ctx.regionId}`);
-	return `__vtex_${parts.join("_")}`;
-}
-
-// -------------------------------------------------------------------------
-// Re-exports for convenience
-// -------------------------------------------------------------------------
-
-export type { Segment } from "./utils/types";
-export type { VtexAuthInfo } from "./utils/vtexId";
-export { isVtexLoggedIn } from "./utils/vtexId";