@decocms/apps-vtex 7.24.0 → 7.25.0

package/src/invoke.ts

@@ -24,23 +24,30 @@
  *   1. Add an entry below with the input/output types and the action call,
  *   2. From a site repo: `npm run generate:invoke`.
  */
+
+import type { CartProjection, CartSection } from "@decocms/apps-commerce/types";
 import { createInvokeFn } from "@decocms/tanstack/sdk/createInvoke";
 import {
-	addCouponToCart,
-	addItemsToCart,
-	getOrCreateCart,
-	getSellersByRegion,
-	type RegionResult,
-	type SimulationItem,
-	setShippingPostalCode,
-	simulateCart,
-	updateCartItems,
-	updateOrderFormAttachment,
+  addCouponToCart,
+  addCouponToCartV2,
+  addItemsToCart,
+  addItemsToCartV2,
+  getOrCreateCart,
+  getOrCreateCartV2,
+  getSellersByRegion,
+  type RegionResult,
+  type SimulationItem,
+  setShippingPostalCode,
+  simulateCart,
+  updateCartItems,
+  updateCartItemsV2,
+  updateOrderFormAttachment,
 } from "./actions/checkout";
 import { type NotifyMeProps, notifyMe } from "./actions/misc";
 import { type SubscribeProps, subscribe } from "./actions/newsletter";
 import { createSession, editSession, type SessionData } from "./actions/session";
 import type { OrderForm } from "./types";
+import type { VtexCartProjectionResult } from "./utils/cartProjection";
 
 // ---------------------------------------------------------------------------
 // invoke.vtex.actions — typed server functions callable from client
@@ -53,81 +60,138 @@ import type { OrderForm } from "./types";
 // ---------------------------------------------------------------------------
 
 export const invoke = {
-	vtex: {
-		actions: {
-			// -- Cart (OrderForm CRUD) --------------------------------------------
-
-			getOrCreateCart: createInvokeFn((data: { orderFormId?: string }) =>
-				getOrCreateCart(data),
-			) as unknown as (ctx: { data: { orderFormId?: string } }) => Promise<OrderForm>,
-
-			addItemsToCart: createInvokeFn(
-				(data: {
-					orderFormId: string;
-					orderItems: Array<{
-						id: string;
-						seller: string;
-						quantity: number;
-					}>;
-				}) => addItemsToCart(data),
-			) as unknown as (ctx: {
-				data: {
-					orderFormId: string;
-					orderItems: Array<{
-						id: string;
-						seller: string;
-						quantity: number;
-					}>;
-				};
-			}) => Promise<OrderForm>,
-
-			updateCartItems: createInvokeFn(
-				(data: { orderFormId: string; orderItems: Array<{ index: number; quantity: number }> }) =>
-					updateCartItems(data),
-			) as unknown as (ctx: {
-				data: { orderFormId: string; orderItems: Array<{ index: number; quantity: number }> };
-			}) => Promise<OrderForm>,
-
-			addCouponToCart: createInvokeFn((data: { orderFormId: string; text: string }) =>
-				addCouponToCart(data),
-			) as unknown as (ctx: { data: { orderFormId: string; text: string } }) => Promise<OrderForm>,
-
-			simulateCart: createInvokeFn(
-				(data: { items: SimulationItem[]; postalCode: string; country?: string }) =>
-					simulateCart(data),
-			),
-
-			// -- Shipping / Region ------------------------------------------------
-
-			getSellersByRegion: createInvokeFn((data: { postalCode: string; salesChannel?: string }) =>
-				getSellersByRegion(data),
-			) as unknown as (ctx: {
-				data: { postalCode: string; salesChannel?: string };
-			}) => Promise<RegionResult | null>,
-
-			setShippingPostalCode: createInvokeFn(
-				(data: { orderFormId: string; postalCode: string; country?: string }) =>
-					setShippingPostalCode(data),
-			) as unknown as (ctx: {
-				data: { orderFormId: string; postalCode: string; country?: string };
-			}) => Promise<boolean>,
-
-			updateOrderFormAttachment: createInvokeFn(
-				(data: { orderFormId: string; attachment: string; body: Record<string, unknown> }) =>
-					updateOrderFormAttachment(data),
-			) as unknown as (ctx: {
-				data: { orderFormId: string; attachment: string; body: Record<string, unknown> };
-			}) => Promise<OrderForm>,
-
-			// -- Session ----------------------------------------------------------
-
-			createSession: createInvokeFn((data: Record<string, any>) => createSession({ data })),
-
-			editSession: createInvokeFn((data: { public: Record<string, { value: string }> }) =>
-				editSession(data),
-			) as unknown as (ctx: {
-				data: { public: Record<string, { value: string }> };
-			}) => Promise<SessionData>,
+  vtex: {
+    actions: {
+      // -- Cart (OrderForm CRUD) --------------------------------------------
+
+      getOrCreateCart: createInvokeFn((data: { orderFormId?: string }) =>
+        getOrCreateCart(data),
+      ) as unknown as (ctx: { data: { orderFormId?: string } }) => Promise<OrderForm>,
+
+      addItemsToCart: createInvokeFn(
+        (data: {
+          orderFormId: string;
+          orderItems: Array<{
+            id: string;
+            seller: string;
+            quantity: number;
+          }>;
+        }) => addItemsToCart(data),
+      ) as unknown as (ctx: {
+        data: {
+          orderFormId: string;
+          orderItems: Array<{
+            id: string;
+            seller: string;
+            quantity: number;
+          }>;
+        };
+      }) => Promise<OrderForm>,
+
+      updateCartItems: createInvokeFn(
+        (data: { orderFormId: string; orderItems: Array<{ index: number; quantity: number }> }) =>
+          updateCartItems(data),
+      ) as unknown as (ctx: {
+        data: { orderFormId: string; orderItems: Array<{ index: number; quantity: number }> };
+      }) => Promise<OrderForm>,
+
+      addCouponToCart: createInvokeFn((data: { orderFormId: string; text: string }) =>
+        addCouponToCart(data),
+      ) as unknown as (ctx: { data: { orderFormId: string; text: string } }) => Promise<OrderForm>,
+
+      // -- Cart v2 (fragmented sections + projected response) ----------------
+
+      getOrCreateCartV2: createInvokeFn(
+        (data: { orderFormId?: string; projection?: CartProjection; sections?: CartSection[] }) =>
+          getOrCreateCartV2(data),
+      ) as unknown as (ctx: {
+        data: { orderFormId?: string; projection?: CartProjection; sections?: CartSection[] };
+      }) => Promise<VtexCartProjectionResult>,
+
+      addItemsToCartV2: createInvokeFn(
+        (data: {
+          orderFormId: string;
+          orderItems: Array<{ id: string; seller: string; quantity: number }>;
+          projection?: CartProjection;
+          sections?: CartSection[];
+        }) => addItemsToCartV2(data),
+      ) as unknown as (ctx: {
+        data: {
+          orderFormId: string;
+          orderItems: Array<{ id: string; seller: string; quantity: number }>;
+          projection?: CartProjection;
+          sections?: CartSection[];
+        };
+      }) => Promise<VtexCartProjectionResult>,
+
+      updateCartItemsV2: createInvokeFn(
+        (data: {
+          orderFormId: string;
+          orderItems: Array<{ index: number; quantity: number }>;
+          projection?: CartProjection;
+          sections?: CartSection[];
+        }) => updateCartItemsV2(data),
+      ) as unknown as (ctx: {
+        data: {
+          orderFormId: string;
+          orderItems: Array<{ index: number; quantity: number }>;
+          projection?: CartProjection;
+          sections?: CartSection[];
+        };
+      }) => Promise<VtexCartProjectionResult>,
+
+      addCouponToCartV2: createInvokeFn(
+        (data: {
+          orderFormId: string;
+          text: string;
+          projection?: CartProjection;
+          sections?: CartSection[];
+        }) => addCouponToCartV2(data),
+      ) as unknown as (ctx: {
+        data: {
+          orderFormId: string;
+          text: string;
+          projection?: CartProjection;
+          sections?: CartSection[];
+        };
+      }) => Promise<VtexCartProjectionResult>,
+
+      simulateCart: createInvokeFn(
+        (data: { items: SimulationItem[]; postalCode: string; country?: string }) =>
+          simulateCart(data),
+      ),
+
+      // -- Shipping / Region ------------------------------------------------
+
+      getSellersByRegion: createInvokeFn((data: { postalCode: string; salesChannel?: string }) =>
+        getSellersByRegion(data),
+      ) as unknown as (ctx: {
+        data: { postalCode: string; salesChannel?: string };
+      }) => Promise<RegionResult | null>,
+
+      setShippingPostalCode: createInvokeFn(
+        (data: { orderFormId: string; postalCode: string; country?: string }) =>
+          setShippingPostalCode(data),
+      ) as unknown as (ctx: {
+        data: { orderFormId: string; postalCode: string; country?: string };
+      }) => Promise<boolean>,
+
+      updateOrderFormAttachment: createInvokeFn(
+        (data: { orderFormId: string; attachment: string; body: Record<string, unknown> }) =>
+          updateOrderFormAttachment(data),
+      ) as unknown as (ctx: {
+        data: { orderFormId: string; attachment: string; body: Record<string, unknown> };
+      }) => Promise<OrderForm>,
+
+      // -- Session ----------------------------------------------------------
+
+      createSession: createInvokeFn((data: Record<string, any>) => createSession({ data })),
+
+      editSession: createInvokeFn((data: { public: Record<string, { value: string }> }) =>
+        editSession(data),
+      ) as unknown as (ctx: {
+        data: { public: Record<string, { value: string }> };
+      }) => Promise<SessionData>,
 
 			// -- MasterData -------------------------------------------------------
 			//
@@ -155,17 +219,17 @@ export const invoke = {
 			// generate-invoke.ts also carries a PRIVILEGED_ACTIONS guard that refuses
 			// to emit these names even if re-added here, so this stays enforced.
 
-			// -- Newsletter -------------------------------------------------------
+      // -- Newsletter -------------------------------------------------------
 
-			subscribe: createInvokeFn((data: SubscribeProps) => subscribe(data)) as unknown as (ctx: {
-				data: SubscribeProps;
-			}) => Promise<void>,
+      subscribe: createInvokeFn((data: SubscribeProps) => subscribe(data)) as unknown as (ctx: {
+        data: SubscribeProps;
+      }) => Promise<void>,
 
-			// -- Misc -------------------------------------------------------------
+      // -- Misc -------------------------------------------------------------
 
-			notifyMe: createInvokeFn((data: NotifyMeProps) => notifyMe(data)) as unknown as (ctx: {
-				data: NotifyMeProps;
-			}) => Promise<void>,
-		},
-	},
+      notifyMe: createInvokeFn((data: NotifyMeProps) => notifyMe(data)) as unknown as (ctx: {
+        data: NotifyMeProps;
+      }) => Promise<void>,
+    },
+  },
 } as const;

package/src/loaders/cart/attachments.ts

@@ -0,0 +1,53 @@
+/**
+ * `vtex/loaders/cart/attachments` — one item's attachments + offered slots.
+ *
+ * For a customization UI (engraving, gift wrap, ...) that only needs a single
+ * line's attachment state. Fetches just `items` and returns that item's
+ * `attachments` (applied) and `attachmentOfferings` (available slots).
+ */
+
+import { getOrCreateCartV2 } from "../../actions/checkout";
+import type { OrderForm, OrderFormItem } from "../../types";
+import { resolveOrderFormId } from "./orderFormId";
+
+export interface CartItemAttachmentsProps {
+  orderFormId?: string;
+  /** Index of the line whose attachments to read. */
+  itemIndex: number;
+}
+
+export interface CartItemAttachments {
+  orderFormId: string | null;
+  itemIndex: number;
+  attachments: NonNullable<OrderFormItem["attachments"]>;
+  attachmentOfferings: NonNullable<OrderFormItem["attachmentOfferings"]>;
+}
+
+export default async function cartItemAttachments(
+  props: CartItemAttachmentsProps,
+): Promise<CartItemAttachments> {
+  const orderFormId = resolveOrderFormId(props.orderFormId);
+  const empty: CartItemAttachments = {
+    orderFormId: null,
+    itemIndex: props.itemIndex,
+    attachments: [],
+    attachmentOfferings: [],
+  };
+  if (!orderFormId) return empty;
+
+  const orderForm = (await getOrCreateCartV2({
+    orderFormId,
+    projection: "raw",
+    sections: ["items"],
+  })) as OrderForm;
+
+  const item = orderForm.items?.[props.itemIndex];
+  if (!item) return { ...empty, orderFormId: orderForm.orderFormId ?? null };
+
+  return {
+    orderFormId: orderForm.orderFormId ?? null,
+    itemIndex: props.itemIndex,
+    attachments: item.attachments ?? [],
+    attachmentOfferings: item.attachmentOfferings ?? [],
+  };
+}

package/src/loaders/cart/full.ts

@@ -0,0 +1,67 @@
+/**
+ * `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

@@ -0,0 +1,43 @@
+/**
+ * `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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -10,7 +10,7 @@ vi.mock("../../actions/checkout", () => ({
 	simulateCart: (props: any) => simulateCartMock(props),
 }));
 
-import { getShippingSimulation } from "./shipping";
+import cartShipping, { getShippingSimulation } from "./shipping";
 import { __resetSimulationCacheForTests } from "../../utils/simulationCache";
 
 describe("getShippingSimulation (#373)", () => {
@@ -86,3 +86,40 @@ describe("getShippingSimulation (#373)", () => {
 		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

@@ -46,7 +46,7 @@ function buildCacheKey(props: ShippingSimulationProps): string {
  * 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<unknown> {
+export async function getShippingSimulation(props: ShippingSimulationProps): Promise<any> {
 	const cache = getSimulationCache();
 	const key = buildCacheKey(props);
 
@@ -68,3 +68,69 @@ export async function getShippingSimulation(props: ShippingSimulationProps): Pro
 	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

@@ -0,0 +1,36 @@
+/**
+ * `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;
+}