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

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

@@ -1,155 +0,0 @@
-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;
-}
-
-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("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();
-    }
-  });
-});

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

@@ -1,158 +0,0 @@
-/**
- * Smoke tests for the pre-wired VTEX fetch factory.
- *
- * The deep coverage of `createInstrumentedFetch` lives in @decocms/start;
- * here we only verify the apps-start wiring decisions:
- *
- *   - The URL router is plumbed through so unannotated callsites get
- *     semantic span operations + histogram labels.
- *   - The canonical `http.client.request.duration` histogram is recorded
- *     with the right labels on every call (via the framework's
- *     `recordCommerceMetric` helper).
- *   - `disableHistogram: true` opts out cleanly.
- *   - A caller's explicit `init.operation` wins over the URL router
- *     (delegating to the framework, but worth asserting at this seam).
- */
-
-import { configureMeter, type MeterAdapter } from "@decocms/blocks/sdk/observability";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createVtexFetch } from "../instrumentedFetch";
-
-type Labels = Record<string, string | number | boolean>;
-type HistogramCall = {
-	name: string;
-	value: number;
-	attrs: Labels;
-};
-
-function captureHistogram(): { calls: HistogramCall[]; meter: MeterAdapter } {
-	const calls: HistogramCall[] = [];
-	const meter: MeterAdapter = {
-		counterInc: vi.fn(),
-		gaugeSet: vi.fn(),
-		histogramRecord: (name, value, attrs) => {
-			calls.push({ name, value, attrs: attrs ?? {} });
-		},
-	};
-	return { calls, meter };
-}
-
-function mockOkResponse(status = 200): Response {
-	return new Response(JSON.stringify({}), { status });
-}
-
-describe("createVtexFetch", () => {
-	afterEach(() => {
-		vi.restoreAllMocks();
-		configureMeter({
-			counterInc: () => {},
-			gaugeSet: () => {},
-			histogramRecord: () => {},
-		});
-	});
-
-	it("records http.client.request.duration with provider/operation/status labels on success", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async () => mockOkResponse(200));
-		const fetchFn = createVtexFetch({ baseFetch: baseFetch as typeof fetch });
-
-		await fetchFn("https://store.vtexcommercestable.com.br/api/sessions");
-
-		expect(calls).toHaveLength(1);
-		expect(calls[0].name).toBe("http.client.request.duration");
-		expect(calls[0].attrs).toMatchObject({
-			provider: "vtex",
-			operation: "sessions.get",
-			status_class: "2xx",
-			cached: false,
-		});
-		expect(calls[0].value).toBeGreaterThanOrEqual(0);
-	});
-
-	it("uses the URL router for unannotated calls", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async () => mockOkResponse(200));
-		const fetchFn = createVtexFetch({ baseFetch: baseFetch as typeof fetch });
-
-		await fetchFn(
-			"https://store.vtexcommercestable.com.br/api/io/_v/api/intelligent-search/product_search/foo",
-		);
-
-		expect(calls[0].attrs.operation).toBe("intelligent-search.product_search");
-	});
-
-	it("honors init.operation over the URL router", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async () => mockOkResponse(200));
-		const fetchFn = createVtexFetch({ baseFetch: baseFetch as typeof fetch });
-
-		await fetchFn("https://store.vtexcommercestable.com.br/api/sessions", {
-			operation: "explicit.custom_op",
-		});
-
-		expect(calls[0].attrs.operation).toBe("explicit.custom_op");
-	});
-
-	it("records cached=true when the response carries x-cache: HIT", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(
-			async () => new Response("{}", { status: 200, headers: { "x-cache": "HIT" } }),
-		);
-		const fetchFn = createVtexFetch({ baseFetch: baseFetch as typeof fetch });
-
-		await fetchFn("https://store.vtexcommercestable.com.br/api/sessions");
-
-		expect(calls[0].attrs.cached).toBe(true);
-	});
-
-	it("emits status_class derived from the actual response status", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async () => mockOkResponse(503));
-		const fetchFn = createVtexFetch({ baseFetch: baseFetch as typeof fetch });
-
-		await fetchFn("https://store.vtexcommercestable.com.br/api/sessions");
-
-		expect(calls[0].attrs.status_class).toBe("5xx");
-	});
-
-	it("skips histogram emission when disableHistogram is true", async () => {
-		const { calls, meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async () => mockOkResponse(200));
-		const fetchFn = createVtexFetch({
-			baseFetch: baseFetch as typeof fetch,
-			disableHistogram: true,
-		});
-
-		await fetchFn("https://store.vtexcommercestable.com.br/api/sessions");
-
-		expect(calls).toHaveLength(0);
-	});
-
-	it("does not surface the operation field to the underlying fetch", async () => {
-		const { meter } = captureHistogram();
-		configureMeter(meter);
-
-		const baseFetch = vi.fn(async (_input: unknown, _init?: RequestInit) => mockOkResponse(200));
-		const fetchFn = createVtexFetch({ baseFetch: baseFetch as unknown as typeof fetch });
-
-		await fetchFn("https://store.vtexcommercestable.com.br/api/sessions", {
-			operation: "explicit.op",
-		});
-
-		expect(baseFetch).toHaveBeenCalledOnce();
-		const init = baseFetch.mock.calls[0]?.[1] as Record<string, unknown> | undefined;
-		expect(init?.operation).toBeUndefined();
-	});
-});

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

@@ -1,88 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isFilterParam, toPath, withDefaultFacets, withDefaultParams } from "../intelligentSearch";
-
-describe("withDefaultFacets", () => {
-	it("returns a copy of the facets array", () => {
-		const facets = [{ key: "category", value: "shoes" }];
-		const result = withDefaultFacets(facets);
-		expect(result).toEqual(facets);
-		expect(result).not.toBe(facets);
-	});
-
-	it("returns empty array for empty input", () => {
-		expect(withDefaultFacets([])).toEqual([]);
-	});
-});
-
-describe("toPath", () => {
-	it("builds path from facets", () => {
-		const facets = [
-			{ key: "category", value: "shoes" },
-			{ key: "brand", value: "nike" },
-		];
-		expect(toPath(facets)).toBe("category/shoes/brand/nike");
-	});
-
-	it("handles facets with empty key", () => {
-		const facets = [{ key: "", value: "shoes" }];
-		expect(toPath(facets)).toBe("shoes");
-	});
-
-	it("returns empty string for empty facets", () => {
-		expect(toPath([])).toBe("");
-	});
-});
-
-describe("withDefaultParams", () => {
-	it("fills in defaults", () => {
-		const result = withDefaultParams({});
-		expect(result).toEqual({
-			page: 1,
-			count: 12,
-			query: "",
-			sort: "",
-			fuzzy: "auto",
-			locale: "pt-BR",
-			hideUnavailableItems: false,
-			simulationBehavior: "default",
-		});
-	});
-
-	it("increments page by 1", () => {
-		expect(withDefaultParams({ page: 0 }).page).toBe(1);
-		expect(withDefaultParams({ page: 2 }).page).toBe(3);
-	});
-
-	it("preserves provided values", () => {
-		const result = withDefaultParams({
-			query: "shoes",
-			count: 24,
-			sort: "price:asc",
-			fuzzy: "0",
-			hideUnavailableItems: true,
-		});
-		expect(result.query).toBe("shoes");
-		expect(result.count).toBe(24);
-		expect(result.sort).toBe("price:asc");
-		expect(result.fuzzy).toBe("0");
-		expect(result.hideUnavailableItems).toBe(true);
-	});
-
-	it("omits fuzzy when empty string", () => {
-		const result = withDefaultParams({ fuzzy: "" });
-		expect(result).not.toHaveProperty("fuzzy");
-	});
-});
-
-describe("isFilterParam", () => {
-	it("returns true for filter params", () => {
-		expect(isFilterParam("filter.category")).toBe(true);
-		expect(isFilterParam("filter.brand")).toBe(true);
-	});
-
-	it("returns false for non-filter params", () => {
-		expect(isFilterParam("page")).toBe(false);
-		expect(isFilterParam("query")).toBe(false);
-		expect(isFilterParam("filterNot")).toBe(false);
-	});
-});

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

@@ -1,184 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { OrderForm, OrderFormItem, Totalizer } from "../../types";
-import { vtexOrderFormToMinicart } from "../minicart";
-
-const baseStorePreferences = {
-	countryCode: "BRA",
-	currencyCode: "BRL",
-	currencyLocale: 1046,
-	currencySymbol: "R$",
-	saveUserData: true,
-	timeZone: "E. South America Standard Time",
-	currencyFormatInfo: {
-		currencyDecimalDigits: 2,
-		currencyDecimalSeparator: ",",
-		currencyGroupSeparator: ".",
-		currencyGroupSize: 3,
-		startsWithCurrencySymbol: true,
-	},
-};
-
-function makeOrderForm(overrides: Partial<OrderForm> = {}): OrderForm {
-	return {
-		orderFormId: "of-1",
-		salesChannel: "1",
-		loggedIn: false,
-		isCheckedIn: false,
-		allowManualPrice: false,
-		canEditData: false,
-		ignoreProfileData: false,
-		value: 0,
-		messages: [],
-		items: [],
-		totalizers: [],
-		shippingData: null,
-		clientProfileData: null,
-		paymentData: null,
-		marketingData: null,
-		sellers: [],
-		clientPreferencesData: { locale: "pt-BR" },
-		storePreferencesData: baseStorePreferences,
-		...overrides,
-	};
-}
-
-function makeItem(overrides: Partial<OrderFormItem> = {}): OrderFormItem {
-	return {
-		uniqueId: "uid-1",
-		id: "sku-1",
-		productId: "p-1",
-		name: "T-Shirt",
-		skuName: "T-Shirt M",
-		price: 9990,
-		listPrice: 12990,
-		sellingPrice: 9990,
-		quantity: 2,
-		seller: "1",
-		imageUrl: "http://example.com/img.jpg",
-		detailUrl: "/p/t-shirt",
-		additionalInfo: { brandName: "Brand", brandId: "b-1" },
-		productCategoryIds: "/123/",
-		productCategories: { "123": "Clothing" },
-		availability: "available",
-		measurementUnit: "un",
-		unitMultiplier: 1,
-		...overrides,
-	};
-}
-
-function tot(id: string, value: number, name = id): Totalizer {
-	return { id, name, value };
-}
-
-describe("vtexOrderFormToMinicart", () => {
-	it("returns an empty cart shape for an empty OrderForm", () => {
-		const minicart = vtexOrderFormToMinicart(makeOrderForm());
-		expect(minicart.storefront.items).toEqual([]);
-		expect(minicart.storefront.subtotal).toBe(0);
-		expect(minicart.storefront.discounts).toBe(0);
-		expect(minicart.storefront.total).toBe(0);
-		expect(minicart.storefront.shipping).toBeUndefined();
-	});
-
-	it("converts cents to major units across totalizers", () => {
-		const orderForm = makeOrderForm({
-			value: 19980,
-			totalizers: [tot("Items", 25980), tot("Discounts", -6000), tot("Shipping", 1500)],
-			items: [makeItem()],
-		});
-		const minicart = vtexOrderFormToMinicart(orderForm);
-		expect(minicart.storefront.subtotal).toBeCloseTo(259.8, 2);
-		expect(minicart.storefront.discounts).toBeCloseTo(60, 2);
-		expect(minicart.storefront.shipping).toBeCloseTo(15, 2);
-		expect(minicart.storefront.total).toBeCloseTo(199.8, 2);
-	});
-
-	it("Discounts are always non-negative even when VTEX returns a negative totalizer", () => {
-		const orderForm = makeOrderForm({
-			value: 9990,
-			totalizers: [tot("Items", 9990), tot("Discounts", -1000)],
-			items: [makeItem()],
-		});
-		const minicart = vtexOrderFormToMinicart(orderForm);
-		expect(minicart.storefront.discounts).toBe(10);
-	});
-
-	it("omits shipping when no Shipping totalizer is present", () => {
-		const orderForm = makeOrderForm({
-			value: 9990,
-			totalizers: [tot("Items", 9990)],
-			items: [makeItem()],
-		});
-		const minicart = vtexOrderFormToMinicart(orderForm);
-		expect(minicart.storefront.shipping).toBeUndefined();
-	});
-
-	it("maps OrderFormItem to MinicartItem with major-unit prices and analytics fields", () => {
-		const orderForm = makeOrderForm({
-			value: 19980,
-			totalizers: [tot("Items", 19980)],
-			items: [makeItem()],
-		});
-		const minicart = vtexOrderFormToMinicart(orderForm);
-		const item = minicart.storefront.items[0];
-		expect(item.item_id).toBe("sku-1");
-		expect(item.item_group_id).toBe("p-1");
-		expect(item.item_name).toBe("T-Shirt");
-		expect(item.item_brand).toBe("Brand");
-		expect(item.item_url).toBe("/p/t-shirt");
-		expect(item.price).toBeCloseTo(99.9, 2);
-		expect(item.listPrice).toBeCloseTo(129.9, 2);
-		expect(item.discount).toBeCloseTo(30, 2);
-		expect(item.quantity).toBe(2);
-		expect(item.seller).toBe("1");
-		expect(item.affiliation).toBe("1");
-	});
-
-	it("forces https on item images", () => {
-		const orderForm = makeOrderForm({
-			items: [makeItem({ imageUrl: "http://cdn.example.com/img.jpg" })],
-		});
-		const minicart = vtexOrderFormToMinicart(orderForm);
-		expect(minicart.storefront.items[0].image).toBe("https://cdn.example.com/img.jpg");
-	});
-
-	it("propagates the marketing coupon onto every item and the storefront root", () => {
-		const orderForm = makeOrderForm({
-			items: [makeItem(), makeItem({ uniqueId: "uid-2", id: "sku-2" })],
-			marketingData: { coupon: "SAVE10" },
-		});
-		const minicart = vtexOrderFormToMinicart(orderForm);
-		expect(minicart.storefront.coupon).toBe("SAVE10");
-		expect(minicart.storefront.items[0].coupon).toBe("SAVE10");
-		expect(minicart.storefront.items[1].coupon).toBe("SAVE10");
-	});
-
-	it("uses opts overrides for free-shipping target, locale, checkout href and coupon toggle", () => {
-		const minicart = vtexOrderFormToMinicart(makeOrderForm(), {
-			freeShippingTarget: 250,
-			locale: "en-US",
-			checkoutHref: "/cart/go",
-			enableCoupon: false,
-		});
-		expect(minicart.storefront.freeShippingTarget).toBe(250);
-		expect(minicart.storefront.locale).toBe("en-US");
-		expect(minicart.storefront.checkoutHref).toBe("/cart/go");
-		expect(minicart.storefront.enableCoupon).toBe(false);
-	});
-
-	it("infers pt-BR locale from BRA countryCode when no override is given", () => {
-		const orderForm = makeOrderForm({
-			clientPreferencesData: { locale: "" },
-			storePreferencesData: { ...baseStorePreferences, countryCode: "BRA" },
-		});
-		const minicart = vtexOrderFormToMinicart(orderForm);
-		expect(minicart.storefront.locale).toBe("pt-BR");
-	});
-
-	it("preserves the raw OrderForm under .original for site escape hatches", () => {
-		const orderForm = makeOrderForm({ orderFormId: "of-original" });
-		const minicart = vtexOrderFormToMinicart(orderForm);
-		expect(minicart.original).toBe(orderForm);
-		expect(minicart.original.orderFormId).toBe("of-original");
-	});
-});