@decocms/apps-vtex 7.2.0

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

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

@@ -0,0 +1,88 @@
+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

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

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

@@ -0,0 +1,227 @@
+import { describe, expect, it } from "vitest";
+import { vtexOperationRouter } from "../operationRouter";
+
+describe("vtexOperationRouter", () => {
+	const acct = "https://store.vtexcommercestable.com.br";
+
+	describe("Intelligent Search", () => {
+		it("captures the IS endpoint as the operation suffix", () => {
+			expect(
+				vtexOperationRouter(
+					`${acct}/api/io/_v/api/intelligent-search/product_search/electronics`,
+					"GET",
+				),
+			).toBe("intelligent-search.product_search");
+			expect(
+				vtexOperationRouter(`${acct}/api/io/_v/api/intelligent-search/top_searches`, "GET"),
+			).toBe("intelligent-search.top_searches");
+			expect(vtexOperationRouter(`${acct}/api/io/_v/api/intelligent-search/facets`, "GET")).toBe(
+				"intelligent-search.facets",
+			);
+			expect(
+				vtexOperationRouter(`${acct}/api/io/_v/api/intelligent-search/search_suggestions`, "GET"),
+			).toBe("intelligent-search.search_suggestions");
+		});
+
+		it("strips query string before matching", () => {
+			expect(
+				vtexOperationRouter(
+					`${acct}/api/io/_v/api/intelligent-search/product_search?query=foo&sort=price`,
+					"GET",
+				),
+			).toBe("intelligent-search.product_search");
+		});
+	});
+
+	describe("Checkout / orderForm", () => {
+		it("differentiates create vs get on orderForm", () => {
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm`, "POST")).toBe(
+				"checkout.orderform.create",
+			);
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm`, "GET")).toBe(
+				"checkout.orderform.get",
+			);
+		});
+
+		it("differentiates items add/update/remove by HTTP method", () => {
+			const url = `${acct}/api/checkout/pub/orderForm/abc123/items`;
+			expect(vtexOperationRouter(url, "POST")).toBe("checkout.orderform.items.add");
+			expect(vtexOperationRouter(url, "PATCH")).toBe("checkout.orderform.items.update");
+			expect(vtexOperationRouter(url, "PUT")).toBe("checkout.orderform.items.update");
+			expect(vtexOperationRouter(url, "DELETE")).toBe("checkout.orderform.items.remove");
+		});
+
+		it("recognizes the /items/update legacy mass-update endpoint", () => {
+			expect(
+				vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/abc123/items/update`, "POST"),
+			).toBe("checkout.orderform.items.update");
+		});
+
+		it("handles coupons, profile, shippingData, paymentData", () => {
+			const id = "abc123";
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/${id}/coupons`, "POST")).toBe(
+				"checkout.orderform.coupons",
+			);
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/${id}/profile`, "POST")).toBe(
+				"checkout.orderform.profile",
+			);
+			expect(
+				vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/${id}/shippingData/...`, "POST"),
+			).toBe("checkout.orderform.shipping");
+			expect(
+				vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/${id}/paymentData/...`, "POST"),
+			).toBe("checkout.orderform.payment");
+		});
+
+		it("matches the singleton orderForm/{id} root with the right method", () => {
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/abc`, "GET")).toBe(
+				"checkout.orderform.get",
+			);
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForm/abc`, "PATCH")).toBe(
+				"checkout.orderform.update",
+			);
+		});
+
+		it("maps simulation, regions, postal-code", () => {
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/orderForms/simulation`, "POST")).toBe(
+				"checkout.simulation",
+			);
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/regions`, "GET")).toBe(
+				"checkout.regions",
+			);
+			expect(vtexOperationRouter(`${acct}/api/checkout/pub/postal-code/BRA/01310`, "GET")).toBe(
+				"checkout.postal-code",
+			);
+		});
+	});
+
+	describe("Sessions + segments", () => {
+		it("differentiates sessions GET vs POST", () => {
+			expect(vtexOperationRouter(`${acct}/api/sessions`, "GET")).toBe("sessions.get");
+			expect(vtexOperationRouter(`${acct}/api/sessions`, "POST")).toBe("sessions.update");
+		});
+
+		it("matches segments", () => {
+			expect(vtexOperationRouter(`${acct}/api/segments/abc-123`, "GET")).toBe("segments.get");
+		});
+	});
+
+	describe("Catalog System", () => {
+		it("captures the most-specific catalog endpoints first", () => {
+			expect(
+				vtexOperationRouter(`${acct}/api/catalog_system/pub/portal/pagetype/eletronicos`, "GET"),
+			).toBe("catalog.pagetype");
+			expect(
+				vtexOperationRouter(
+					`${acct}/api/catalog_system/pub/products/crossselling/whoboughtalsobought/123`,
+					"GET",
+				),
+			).toBe("catalog.crossselling.whoboughtalsobought");
+			expect(
+				vtexOperationRouter(`${acct}/api/catalog_system/pub/products/variations/123`, "GET"),
+			).toBe("catalog.products.variations");
+			expect(
+				vtexOperationRouter(`${acct}/api/catalog_system/pub/products/search/?fq=x`, "GET"),
+			).toBe("catalog.products.search");
+			expect(vtexOperationRouter(`${acct}/api/catalog_system/pub/facets/search/x`, "GET")).toBe(
+				"catalog.facets.search",
+			);
+			expect(vtexOperationRouter(`${acct}/api/catalog_system/pub/category/tree/3`, "GET")).toBe(
+				"catalog.category.tree",
+			);
+			expect(
+				vtexOperationRouter(`${acct}/api/catalog_system/pvt/sku/stockkeepingunitbyid/123`, "GET"),
+			).toBe("catalog.sku");
+		});
+
+		it("falls back to catalog.other for unrecognized catalog paths", () => {
+			expect(
+				vtexOperationRouter(`${acct}/api/catalog_system/pvt/specification/groupGet/123`, "GET"),
+			).toBe("catalog.specification");
+			expect(vtexOperationRouter(`${acct}/api/catalog_system/pub/brand/list`, "GET")).toBe(
+				"catalog.brand",
+			);
+		});
+	});
+
+	describe("Masterdata", () => {
+		it("encodes the entity name as the operation suffix", () => {
+			expect(vtexOperationRouter(`${acct}/api/dataentities/AD/search`, "GET")).toBe(
+				"masterdata.AD",
+			);
+			expect(vtexOperationRouter(`${acct}/api/dataentities/wishlist_lists/documents`, "POST")).toBe(
+				"masterdata.wishlist_lists",
+			);
+		});
+	});
+
+	describe("OMS", () => {
+		it("differentiates orders list vs cancel", () => {
+			expect(vtexOperationRouter(`${acct}/api/oms/user/orders`, "GET")).toBe("oms.orders");
+			expect(vtexOperationRouter(`${acct}/api/oms/user/orders/v999-01/cancel`, "POST")).toBe(
+				"oms.orders.cancel",
+			);
+			expect(vtexOperationRouter(`${acct}/api/oms/pvt/orders/v999-01`, "GET")).toBe(
+				"oms.orders.pvt",
+			);
+		});
+	});
+
+	describe("VTEX ID", () => {
+		it("maps the auth surface", () => {
+			expect(vtexOperationRouter(`${acct}/api/vtexid/pub/logout?scope=x`, "GET")).toBe(
+				"vtexid.logout",
+			);
+			expect(vtexOperationRouter(`${acct}/api/vtexid/pub/authentication/start`, "GET")).toBe(
+				"vtexid.authentication.start",
+			);
+			expect(
+				vtexOperationRouter(`${acct}/api/vtexid/pub/authentication/classic/validate`, "POST"),
+			).toBe("vtexid.authentication.validate");
+			expect(vtexOperationRouter(`${acct}/api/vtexid/pub/authenticated/user`, "GET")).toBe(
+				"vtexid.user",
+			);
+		});
+
+		it("falls back to vtexid.other for unmapped vtexid paths", () => {
+			expect(vtexOperationRouter(`${acct}/api/vtexid/pub/refreshtoken`, "POST")).toBe(
+				"vtexid.other",
+			);
+		});
+	});
+
+	describe("VTEX IO + GraphQL", () => {
+		it("matches the IO private graphql endpoint", () => {
+			expect(vtexOperationRouter(`https://store.myvtex.com/_v/private/graphql/v1`, "POST")).toBe(
+				"io.graphql",
+			);
+		});
+
+		it("matches the IO segment endpoint", () => {
+			expect(
+				vtexOperationRouter(`https://store.myvtex.com/_v/segment/admin-pvt/whatever`, "GET"),
+			).toBe("io.segment");
+		});
+	});
+
+	describe("Edge cases", () => {
+		it("returns undefined for fully unrecognized URLs", () => {
+			expect(vtexOperationRouter(`${acct}/somethingelse/random`, "GET")).toBeUndefined();
+		});
+
+		it("does not throw on unparseable URLs and still tries to match", () => {
+			expect(vtexOperationRouter("not-a-real-url", "GET")).toBeUndefined();
+			expect(vtexOperationRouter("/api/sessions?x=1", "GET")).toBe("sessions.get");
+		});
+
+		it("is case-insensitive on the method", () => {
+			expect(vtexOperationRouter(`${acct}/api/sessions`, "post")).toBe("sessions.update");
+			expect(vtexOperationRouter(`${acct}/api/sessions`, "Get")).toBe("sessions.get");
+		});
+
+		it("recognizes sitemap.xml + sitemap-products-0.xml", () => {
+			expect(vtexOperationRouter(`${acct}/sitemap.xml`, "GET")).toBe("sitemap");
+			expect(vtexOperationRouter(`${acct}/sitemap-products-0.xml`, "GET")).toBe("sitemap");
+		});
+	});
+});

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

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { resourceRange } from "../resourceRange";
+
+describe("resourceRange", () => {
+	it("returns from=0 and to=take when skip is 0", () => {
+		expect(resourceRange(0, 50)).toEqual({ from: 0, to: 50 });
+	});
+
+	it("caps take at 100", () => {
+		expect(resourceRange(0, 200)).toEqual({ from: 0, to: 100 });
+	});
+
+	it("applies skip offset", () => {
+		expect(resourceRange(10, 50)).toEqual({ from: 10, to: 60 });
+	});
+
+	it("handles skip + take > 100 by capping take", () => {
+		expect(resourceRange(50, 200)).toEqual({ from: 50, to: 150 });
+	});
+
+	it("treats negative skip as 0", () => {
+		expect(resourceRange(-5, 10)).toEqual({ from: 0, to: 10 });
+	});
+
+	it("handles zero take", () => {
+		expect(resourceRange(0, 0)).toEqual({ from: 0, to: 0 });
+	});
+
+	it("handles take of exactly 100", () => {
+		expect(resourceRange(0, 100)).toEqual({ from: 0, to: 100 });
+	});
+});