@decocms/apps-vtex 7.23.0 → 7.25.0

package/src/manifest.gen.ts

@@ -17,6 +17,11 @@ 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";
@@ -35,44 +40,49 @@ 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/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: {},
+  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;

package/src/utils/__tests__/cartProjection.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Tests for `projectOrderForm` — the server-side fragmentation of a VTEX
+ * OrderForm into the requested `CartProjection`. Pure function, no I/O.
+ */
+
+import type { Minicart } from "@decocms/apps-commerce/types";
+import { describe, expect, it } from "vitest";
+import type { OrderForm } from "../../types";
+import { projectOrderForm } from "../cartProjection";
+
+function makeOrderForm(overrides: Partial<OrderForm> = {}): OrderForm {
+  return {
+    orderFormId: "of-123",
+    salesChannel: "1",
+    loggedIn: false,
+    isCheckedIn: false,
+    allowManualPrice: false,
+    canEditData: true,
+    ignoreProfileData: false,
+    value: 15000, // R$150.00 in cents
+    messages: [],
+    items: [
+      {
+        id: "sku-1",
+        productId: "prod-1",
+        name: "Camiseta",
+        skuName: "Camiseta P Azul",
+        imageUrl: "http://img.example/x.jpg",
+        detailUrl: "/camiseta/p",
+        price: 10000,
+        listPrice: 12000,
+        sellingPrice: 10000,
+        quantity: 1,
+        seller: "1",
+        uniqueId: "u1",
+      },
+      {
+        id: "sku-2",
+        productId: "prod-2",
+        name: "Boné",
+        skuName: "Boné U Preto",
+        imageUrl: "https://img.example/y.jpg",
+        detailUrl: "/bone/u",
+        price: 5000,
+        listPrice: 5000,
+        sellingPrice: 5000,
+        quantity: 2,
+        seller: "1",
+        uniqueId: "u2",
+      },
+    ],
+    totalizers: [
+      { id: "Items", name: "Items", value: 20000 },
+      { id: "Discounts", name: "Discounts", value: -5000 },
+    ],
+    shippingData: null,
+    clientProfileData: null,
+    paymentData: null,
+    marketingData: null,
+    ...overrides,
+  } as OrderForm;
+}
+
+describe("projectOrderForm", () => {
+  it("none → { ok: true } and discards the payload", () => {
+    expect(projectOrderForm(makeOrderForm(), "none")).toEqual({ ok: true });
+  });
+
+  it("summary → orderFormId, summed quantities, total in major units", () => {
+    const r = projectOrderForm(makeOrderForm(), "summary") as {
+      orderFormId: string;
+      totalItems: number;
+      total: number;
+    };
+    expect(r.orderFormId).toBe("of-123");
+    expect(r.totalItems).toBe(3); // 1 + 2
+    expect(r.total).toBe(150); // 15000 cents → 150
+  });
+
+  it("summary+items → summary plus slim, https-normalized items", () => {
+    const r = projectOrderForm(makeOrderForm(), "summary+items") as {
+      totalItems: number;
+      items: Array<{ item_name: string; image: string; price: number; quantity: number }>;
+    };
+    expect(r.totalItems).toBe(3);
+    expect(r.items).toHaveLength(2);
+    expect(r.items[0]).toMatchObject({
+      item_name: "Camiseta",
+      item_variant: "Camiseta P Azul",
+      image: "https://img.example/x.jpg", // http → https
+      price: 100, // 10000 cents
+      quantity: 1,
+    });
+    // slim projection must NOT leak the full VTEX item fields
+    expect(r.items[0]).not.toHaveProperty("uniqueId");
+  });
+
+  it("minicart → canonical Minicart with major-unit totals", () => {
+    const r = projectOrderForm(makeOrderForm(), "minicart") as Minicart<OrderForm>;
+    expect(r.storefront.items).toHaveLength(2);
+    expect(r.storefront.total).toBe(150);
+    expect(r.original.orderFormId).toBe("of-123");
+  });
+
+  it("raw → the untouched OrderForm", () => {
+    const of = makeOrderForm();
+    expect(projectOrderForm(of, "raw")).toBe(of);
+  });
+
+  it("summary handles an empty cart without NaN", () => {
+    const r = projectOrderForm(
+      makeOrderForm({ items: [], value: 0, totalizers: [] }),
+      "summary",
+    ) as { totalItems: number; total: number };
+    expect(r.totalItems).toBe(0);
+    expect(r.total).toBe(0);
+  });
+});

package/src/utils/__tests__/fetchCache.test.ts

@@ -1,112 +1,155 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { clearFetchCache, fetchWithCache, getFetchCacheStats } from "../fetchCache";
+import { VtexCircuitOpenError } from "../resilience";
 
 function mockResponse(body: unknown, status = 200): Response {
-	return {
-		ok: status >= 200 && status < 300,
-		status,
-		statusText: status === 200 ? "OK" : "Error",
-		json: () => Promise.resolve(body),
-	} as Response;
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status === 200 ? "OK" : "Error",
+    json: () => Promise.resolve(body),
+  } as Response;
 }
 
 describe("fetchWithCache", () => {
-	beforeEach(() => {
-		clearFetchCache();
-	});
-
-	it("returns fetched data on cache miss", async () => {
-		const data = { id: 1, name: "product" };
-		const doFetch = vi.fn(() => Promise.resolve(mockResponse(data)));
-
-		const result = await fetchWithCache("key1", doFetch);
-		expect(result).toEqual(data);
-		expect(doFetch).toHaveBeenCalledOnce();
-	});
-
-	it("returns cached data on subsequent calls", async () => {
-		const data = { id: 1 };
-		const doFetch = vi.fn(() => Promise.resolve(mockResponse(data)));
-
-		await fetchWithCache("key2", doFetch);
-		const result = await fetchWithCache("key2", doFetch);
-
-		expect(result).toEqual(data);
-		expect(doFetch).toHaveBeenCalledOnce();
-	});
-
-	it("deduplicates in-flight requests", async () => {
-		const data = { id: 1 };
-		const doFetch = vi.fn(
-			() => new Promise<Response>((resolve) => setTimeout(() => resolve(mockResponse(data)), 10)),
-		);
-
-		const [r1, r2] = await Promise.all([
-			fetchWithCache("key3", doFetch),
-			fetchWithCache("key3", doFetch),
-		]);
-
-		expect(r1).toEqual(data);
-		expect(r2).toEqual(data);
-		expect(doFetch).toHaveBeenCalledOnce();
-	});
-
-	it("throws on 5xx responses", async () => {
-		const doFetch = vi.fn(() => Promise.resolve(mockResponse(null, 500)));
-
-		await expect(fetchWithCache("key4", doFetch)).rejects.toThrow("500");
-	});
-
-	it("returns null for 404 responses", async () => {
-		const doFetch = vi.fn(() => Promise.resolve(mockResponse(null, 404)));
-
-		const result = await fetchWithCache("key5", doFetch);
-		expect(result).toBeNull();
-	});
-
-	it("tracks cache stats", async () => {
-		const doFetch = () => Promise.resolve(mockResponse({ ok: true }));
-
-		expect(getFetchCacheStats()).toEqual({ entries: 0, inflight: 0 });
-
-		await fetchWithCache("stats1", doFetch);
-		await fetchWithCache("stats2", doFetch);
-
-		expect(getFetchCacheStats()).toEqual({ entries: 2, inflight: 0 });
-	});
-
-	it("clears cache", async () => {
-		const doFetch = () => Promise.resolve(mockResponse({ ok: true }));
-		await fetchWithCache("clear1", doFetch);
-
-		clearFetchCache();
-		expect(getFetchCacheStats()).toEqual({ entries: 0, inflight: 0 });
-	});
-
-	it("evicts the inflight slot when the fetch never settles", async () => {
-		vi.useFakeTimers();
-		try {
-			// `doFetch` returns a Promise that never resolves — simulates a hung
-			// VTEX subrequest (TCP open, no FIN, no response). Without the
-			// timeout guard, the inflight Map entry would leak forever and
-			// subsequent callers would `await` a zombie Promise — the prod
-			// memory-leak this fix addresses.
-			const doFetch = vi.fn(() => new Promise<Response>(() => {}));
-
-			const pending = fetchWithCache("hung-key", doFetch);
-			// Swallow the eventual rejection so the unhandled rejection doesn't
-			// fail the test runner.
-			pending.catch(() => {});
-
-			expect(getFetchCacheStats().inflight).toBe(1);
-
-			// Fast-forward past the 10s fetch timeout.
-			await vi.advanceTimersByTimeAsync(11_000);
-
-			await expect(pending).rejects.toThrow(/timed out/);
-			expect(getFetchCacheStats().inflight).toBe(0);
-		} finally {
-			vi.useRealTimers();
-		}
-	});
+  beforeEach(() => {
+    clearFetchCache();
+  });
+
+  it("returns fetched data on cache miss", async () => {
+    const data = { id: 1, name: "product" };
+    const doFetch = vi.fn(() => Promise.resolve(mockResponse(data)));
+
+    const result = await fetchWithCache("key1", doFetch);
+    expect(result).toEqual(data);
+    expect(doFetch).toHaveBeenCalledOnce();
+  });
+
+  it("returns cached data on subsequent calls", async () => {
+    const data = { id: 1 };
+    const doFetch = vi.fn(() => Promise.resolve(mockResponse(data)));
+
+    await fetchWithCache("key2", doFetch);
+    const result = await fetchWithCache("key2", doFetch);
+
+    expect(result).toEqual(data);
+    expect(doFetch).toHaveBeenCalledOnce();
+  });
+
+  it("deduplicates in-flight requests", async () => {
+    const data = { id: 1 };
+    const doFetch = vi.fn(
+      () => new Promise<Response>((resolve) => setTimeout(() => resolve(mockResponse(data)), 10)),
+    );
+
+    const [r1, r2] = await Promise.all([
+      fetchWithCache("key3", doFetch),
+      fetchWithCache("key3", doFetch),
+    ]);
+
+    expect(r1).toEqual(data);
+    expect(r2).toEqual(data);
+    expect(doFetch).toHaveBeenCalledOnce();
+  });
+
+  it("throws on 5xx responses", async () => {
+    const doFetch = vi.fn(() => Promise.resolve(mockResponse(null, 500)));
+
+    await expect(fetchWithCache("key4", doFetch)).rejects.toThrow("500");
+  });
+
+  it("does not retry a circuit-open error (fast-fail)", async () => {
+    const doFetch = vi.fn(() => Promise.reject(new VtexCircuitOpenError("host")));
+
+    await expect(fetchWithCache("circuit-key", doFetch)).rejects.toBeInstanceOf(
+      VtexCircuitOpenError,
+    );
+    // The breaker already decided to shed load — must not hammer with retries.
+    expect(doFetch).toHaveBeenCalledOnce();
+  });
+
+  it("serves last-good stale data when a background refresh fails", async () => {
+    vi.useFakeTimers();
+    try {
+      let call = 0;
+      const doFetch = vi.fn(() => {
+        call++;
+        if (call === 1) return Promise.resolve(mockResponse({ v: "good" }));
+        return Promise.reject(new VtexCircuitOpenError("host"));
+      });
+      // Prime a good entry.
+      const first = await fetchWithCache<{ v: string }>("sie-key", doFetch);
+      expect(first).toEqual({ v: "good" });
+
+      // Advance past the 2xx freshness TTL (180s) but within the 24h SIE window.
+      await vi.advanceTimersByTimeAsync(200_000);
+
+      // Stale read: serves last-good immediately, refresh happens in background.
+      const second = await fetchWithCache<{ v: string }>("sie-key", doFetch);
+      expect(second).toEqual({ v: "good" });
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("does not retry — retries are owned by the resilience layer", async () => {
+    // A 5xx used to be retried 3× here, which also re-entered the circuit
+    // breaker 3× per request. fetchCache now makes a single attempt.
+    const doFetch = vi.fn(() => Promise.resolve(mockResponse(null, 500)));
+    await expect(fetchWithCache("single-attempt", doFetch)).rejects.toThrow("500");
+    expect(doFetch).toHaveBeenCalledOnce();
+  });
+
+  it("returns null for 404 responses", async () => {
+    const doFetch = vi.fn(() => Promise.resolve(mockResponse(null, 404)));
+
+    const result = await fetchWithCache("key5", doFetch);
+    expect(result).toBeNull();
+  });
+
+  it("tracks cache stats", async () => {
+    const doFetch = () => Promise.resolve(mockResponse({ ok: true }));
+
+    expect(getFetchCacheStats()).toEqual({ entries: 0, inflight: 0 });
+
+    await fetchWithCache("stats1", doFetch);
+    await fetchWithCache("stats2", doFetch);
+
+    expect(getFetchCacheStats()).toEqual({ entries: 2, inflight: 0 });
+  });
+
+  it("clears cache", async () => {
+    const doFetch = () => Promise.resolve(mockResponse({ ok: true }));
+    await fetchWithCache("clear1", doFetch);
+
+    clearFetchCache();
+    expect(getFetchCacheStats()).toEqual({ entries: 0, inflight: 0 });
+  });
+
+  it("evicts the inflight slot when the fetch never settles", async () => {
+    vi.useFakeTimers();
+    try {
+      // `doFetch` returns a Promise that never resolves — simulates a hung
+      // VTEX subrequest (TCP open, no FIN, no response). Without the
+      // timeout guard, the inflight Map entry would leak forever and
+      // subsequent callers would `await` a zombie Promise — the prod
+      // memory-leak this fix addresses.
+      const doFetch = vi.fn(() => new Promise<Response>(() => {}));
+
+      const pending = fetchWithCache("hung-key", doFetch);
+      // Swallow the eventual rejection so the unhandled rejection doesn't
+      // fail the test runner.
+      pending.catch(() => {});
+
+      expect(getFetchCacheStats().inflight).toBe(1);
+
+      // Fast-forward past the 15s inflight backstop timeout.
+      await vi.advanceTimersByTimeAsync(16_000);
+
+      await expect(pending).rejects.toThrow(/timed out/);
+      expect(getFetchCacheStats().inflight).toBe(0);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });