@decocms/apps-magento 7.2.0

package/src/__tests__/graphql.test.ts

@@ -0,0 +1,183 @@
+/**
+ * Tests for the GraphQL helpers used by product loaders.
+ *
+ * Parity with deco-cx/apps/magento/utils/graphql.ts — pure functions,
+ * so behavior is exhaustively pinnable. Each test mirrors a real call
+ * site in the (still-unported) product loaders.
+ */
+import { describe, expect, it } from "vitest";
+import {
+	filtersFromLoaderGraphQL,
+	filtersFromUrlGraphQL,
+	formatUrlSuffix,
+	getCustomFields,
+	transformFilterGraphQL,
+	transformFilterValueGraphQL,
+	transformSortGraphQL,
+} from "../utils/graphql";
+
+describe("transformSortGraphQL", () => {
+	it("returns undefined when sortBy is absent", () => {
+		expect(transformSortGraphQL({})).toBeUndefined();
+		expect(transformSortGraphQL({ order: "DESC" })).toBeUndefined();
+	});
+
+	it("defaults order to ASC when not provided", () => {
+		expect(transformSortGraphQL({ sortBy: { value: "price" } })).toEqual({
+			price: "ASC",
+		});
+	});
+
+	it("respects DESC order", () => {
+		expect(transformSortGraphQL({ sortBy: { value: "name" }, order: "DESC" })).toEqual({
+			name: "DESC",
+		});
+	});
+
+	it("supports custom sort options (any string value)", () => {
+		expect(transformSortGraphQL({ sortBy: { value: "best_seller_rank" } as any })).toEqual({
+			best_seller_rank: "ASC",
+		});
+	});
+});
+
+describe("transformFilterValueGraphQL", () => {
+	it("EQUAL → { eq: value }", () => {
+		expect(transformFilterValueGraphQL("ABC", "EQUAL")).toEqual({ eq: "ABC" });
+	});
+
+	it("MATCH → { match: value }", () => {
+		expect(transformFilterValueGraphQL("foo bar", "MATCH")).toEqual({
+			match: "foo bar",
+		});
+	});
+
+	it("RANGE → { from, to } split on the FIRST underscore", () => {
+		expect(transformFilterValueGraphQL("10_50", "RANGE")).toEqual({
+			from: "10",
+			to: "50",
+		});
+	});
+
+	it("RANGE with multi-underscore value: only first underscore splits", () => {
+		// Magento's URL param `price=10_50_extra` is unusual but pinned
+		// to substring(0, idx) + substring(idx+1) which keeps the trailing
+		// underscore on the `to` side.
+		expect(transformFilterValueGraphQL("10_50_extra", "RANGE")).toEqual({
+			from: "10",
+			to: "50_extra",
+		});
+	});
+});
+
+describe("filtersFromUrlGraphQL", () => {
+	it("picks up known filter keys from URL searchParams", () => {
+		const url = new URL("https://x.test/?sku=ABC&color=red&unknown=zzz");
+		expect(filtersFromUrlGraphQL(url)).toEqual({
+			sku: { eq: "ABC" },
+			color: { eq: "red" },
+		});
+	});
+
+	it("handles RANGE filters (price)", () => {
+		const url = new URL("https://x.test/?price=10_50");
+		expect(filtersFromUrlGraphQL(url)).toEqual({
+			price: { from: "10", to: "50" },
+		});
+	});
+
+	it("handles MATCH filters (name, description)", () => {
+		const url = new URL("https://x.test/?name=foo+bar");
+		expect(filtersFromUrlGraphQL(url)).toEqual({
+			name: { match: "foo bar" },
+		});
+	});
+
+	it("layers customFilters on top of defaults", () => {
+		const url = new URL("https://x.test/?tag__phebo=fragrancia&sku=X");
+		expect(filtersFromUrlGraphQL(url, [{ value: "tag__phebo", type: "EQUAL" }])).toEqual({
+			tag__phebo: { eq: "fragrancia" },
+			sku: { eq: "X" },
+		});
+	});
+
+	it("returns empty object when no filterable param is set", () => {
+		expect(filtersFromUrlGraphQL(new URL("https://x.test/?totally=other"))).toEqual({});
+	});
+});
+
+describe("filtersFromLoaderGraphQL", () => {
+	it("returns empty object when undefined", () => {
+		expect(filtersFromLoaderGraphQL(undefined)).toEqual({});
+	});
+
+	it("collapses array of FilterProps into a keyed object", () => {
+		expect(
+			filtersFromLoaderGraphQL([
+				{ name: "sku", type: { eq: "A" } },
+				{ name: "color", type: { in: ["red", "blue"] } },
+			]),
+		).toEqual({
+			sku: { eq: "A" },
+			color: { in: ["red", "blue"] },
+		});
+	});
+});
+
+describe("transformFilterGraphQL — merge order", () => {
+	it("loader-derived filters override URL-derived ones on key collisions", () => {
+		// A section hard-coding `sale=true` should ignore any conflicting URL hint.
+		const url = new URL("https://x.test/?sale=false");
+		expect(
+			transformFilterGraphQL(url, undefined, [{ name: "sale", type: { eq: "true" } }]),
+		).toEqual({
+			sale: { eq: "true" },
+		});
+	});
+
+	it("non-colliding sources merge cleanly", () => {
+		const url = new URL("https://x.test/?sku=ABC");
+		expect(
+			transformFilterGraphQL(url, undefined, [{ name: "category_id", type: { eq: "42" } }]),
+		).toEqual({
+			sku: { eq: "ABC" },
+			category_id: { eq: "42" },
+		});
+	});
+});
+
+describe("formatUrlSuffix", () => {
+	it("strips a single leading slash", () => {
+		expect(formatUrlSuffix("/granado/")).toBe("granado/");
+	});
+
+	it("appends trailing slash when missing", () => {
+		expect(formatUrlSuffix("granado")).toBe("granado/");
+	});
+
+	it("leaves trailing slash alone", () => {
+		expect(formatUrlSuffix("granado/")).toBe("granado/");
+	});
+});
+
+describe("getCustomFields", () => {
+	it("returns undefined when active=false", () => {
+		expect(getCustomFields({ active: false }, ["a", "b"])).toBeUndefined();
+	});
+
+	it("returns overrideList when present (ignores fallback)", () => {
+		expect(getCustomFields({ active: true, overrideList: ["x", "y"] }, ["a", "b"])).toEqual([
+			"x",
+			"y",
+		]);
+	});
+
+	it("falls back to provided customFields when overrideList is empty/absent", () => {
+		expect(getCustomFields({ active: true, overrideList: [] }, ["a", "b"])).toEqual(["a", "b"]);
+		expect(getCustomFields({ active: true }, ["a", "b"])).toEqual(["a", "b"]);
+	});
+
+	it("defaults config to {active:false} when omitted", () => {
+		expect(getCustomFields(undefined, ["a"])).toBeUndefined();
+	});
+});

package/src/__tests__/newsletter-subscribe.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Tests for the newsletter/subscribe action.
+ *
+ * Parity with deco-cx/apps/magento/actions/newsletter/subscribe.ts:
+ *   - POSTs to /rest/:site/V1/newsletter/subscribed
+ *   - Body shape: { email, store_id: number }
+ *   - storeId is coerced to number even if the CMS block holds it as string
+ *   - Returns null on non-2xx or when `success === false`, the payload otherwise
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import subscribe from "../actions/newsletter/subscribe";
+import { configureMagento } from "../client";
+
+function mockResponse(body: unknown, status = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" },
+	});
+}
+
+describe("newsletter/subscribe", () => {
+	let fetchSpy: ReturnType<typeof vi.spyOn>;
+
+	beforeEach(() => {
+		configureMagento({
+			baseUrl: "https://loja.example.com/",
+			apiKey: "secret",
+			storeId: 21,
+			site: "example",
+		});
+		fetchSpy = vi.spyOn(globalThis, "fetch");
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("POSTs to the correct REST path with the encoded site", async () => {
+		fetchSpy.mockResolvedValue(mockResponse({ success: true, message: "ok" }));
+		await subscribe({ email: "a@b.com" });
+		const [target, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
+		expect(target.toString()).toBe(
+			"https://loja.example.com/rest/example/V1/newsletter/subscribed",
+		);
+		expect(init.method).toBe("POST");
+	});
+
+	it("sends { email, store_id (number) } as JSON body", async () => {
+		fetchSpy.mockResolvedValue(mockResponse({ success: true, message: "ok" }));
+		await subscribe({ email: "a@b.com" });
+		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
+		expect(JSON.parse(init.body as string)).toEqual({ email: "a@b.com", store_id: 21 });
+	});
+
+	it("coerces storeId to number even if config holds a string-shaped value", async () => {
+		// Some CMS blocks store storeId as a string. The prod loader did
+		// `Number(storeId)` defensively; we keep that behavior so the
+		// Magento backend never receives a string for an int field.
+		configureMagento({
+			baseUrl: "https://loja.example.com/",
+			apiKey: "secret",
+			storeId: "42" as unknown as number,
+			site: "example",
+		});
+		fetchSpy.mockResolvedValue(mockResponse({ success: true, message: "ok" }));
+		await subscribe({ email: "a@b.com" });
+		const [, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
+		expect(JSON.parse(init.body as string).store_id).toBe(42);
+	});
+
+	it("returns the payload on success", async () => {
+		const payload = { success: true, message: "ok" };
+		fetchSpy.mockResolvedValue(mockResponse(payload));
+		expect(await subscribe({ email: "a@b.com" })).toEqual(payload);
+	});
+
+	it("returns null on success:false (Magento failure shape)", async () => {
+		fetchSpy.mockResolvedValue(mockResponse({ success: false, message: "no" }));
+		expect(await subscribe({ email: "a@b.com" })).toBeNull();
+	});
+
+	it("returns null on non-2xx HTTP status", async () => {
+		fetchSpy.mockResolvedValue(mockResponse(null, 500));
+		expect(await subscribe({ email: "a@b.com" })).toBeNull();
+	});
+});

package/src/__tests__/product-stockAlert.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Tests for the product/stockAlert action.
+ *
+ * Parity with deco-cx/apps/magento/actions/product/stockAlert.ts:
+ *   - Calls Magento's GraphQL endpoint at <baseUrl>/graphql.
+ *   - Sends operationName ProductStockAlert + variables {product_id, name, email}.
+ *   - Returns { data: { productStockAlert } } on success.
+ *   - Returns { error } on thrown exceptions / missing payload.
+ *
+ * The legacy code passed a STALE cache hint to clientGraphql.query but
+ * mutations are never cached server-side, so the TanStack port omits it
+ * — behavior is observationally identical from a consumer perspective.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import stockAlert from "../actions/product/stockAlert";
+import { configureMagento } from "../client";
+
+function mockResponse(body: unknown, status = 200): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" },
+	});
+}
+
+describe("product/stockAlert", () => {
+	let fetchSpy: ReturnType<typeof vi.spyOn>;
+
+	beforeEach(() => {
+		configureMagento({
+			baseUrl: "https://loja.example.com/",
+			apiKey: "secret",
+			storeId: 1,
+			site: "example",
+		});
+		fetchSpy = vi.spyOn(globalThis, "fetch");
+	});
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
+
+	it("POSTs to <baseUrl>/graphql with the ProductStockAlert mutation", async () => {
+		fetchSpy.mockResolvedValue(
+			mockResponse({
+				data: { productStockAlert: { message: "ok", status: true } },
+			}),
+		);
+		await stockAlert({ product_id: 42, name: "Alice", email: "a@b.com" });
+		const [target, init] = fetchSpy.mock.calls[0] as [URL, RequestInit];
+		expect(target.toString()).toBe("https://loja.example.com/graphql");
+		expect(init.method).toBe("POST");
+
+		const body = JSON.parse(init.body as string);
+		expect(body.operationName).toBe("ProductStockAlert");
+		expect(body.variables).toEqual({ product_id: 42, name: "Alice", email: "a@b.com" });
+		expect(body.query).toMatch(/mutation ProductStockAlert/);
+	});
+
+	it("returns { data: { productStockAlert } } on success", async () => {
+		fetchSpy.mockResolvedValue(
+			mockResponse({
+				data: { productStockAlert: { message: "added", status: true } },
+			}),
+		);
+		const out = await stockAlert({ product_id: 1, name: "n", email: "e@e.com" });
+		expect(out).toEqual({ data: { productStockAlert: { message: "added", status: true } } });
+	});
+
+	it("returns { error } when the GraphQL response lacks productStockAlert", async () => {
+		fetchSpy.mockResolvedValue(mockResponse({ data: {} }));
+		const out = await stockAlert({ product_id: 1, name: "n", email: "e@e.com" });
+		expect(out).toHaveProperty("error");
+	});
+
+	it("returns { error } when fetch throws (network error)", async () => {
+		fetchSpy.mockRejectedValue(new Error("ECONNREFUSED"));
+		const out = await stockAlert({ product_id: 1, name: "n", email: "e@e.com" });
+		expect(out).toEqual({ error: "ECONNREFUSED" });
+	});
+});

package/src/__tests__/stringifySearchCriteria.test.ts

@@ -0,0 +1,56 @@
+/**
+ * Tests for stringifySearchCriteria.
+ *
+ * Parity goal with deco-cx/apps/magento/utils/stringifySearchCriteria.ts
+ * — the Fresh implementation produces query-string keys that Magento's
+ * REST API depends on byte-for-byte. These tests pin the exact bracket
+ * layout so the port can't silently drift from prod.
+ */
+import { describe, expect, it } from "vitest";
+import stringifySearchCriteria from "../utils/stringifySearchCriteria";
+
+describe("stringifySearchCriteria", () => {
+	it("flattens a top-level scalar field into a bracketed key", () => {
+		expect(
+			stringifySearchCriteria({
+				pageSize: 20,
+			}),
+		).toEqual({
+			"searchCriteria[pageSize]": 20,
+		});
+	});
+
+	it("flattens nested objects with the [key] path style", () => {
+		expect(
+			stringifySearchCriteria({
+				filterGroups: [
+					{
+						filters: [{ field: "sku", value: "ABC" }],
+					},
+				],
+			}),
+		).toEqual({
+			"searchCriteria[filterGroups][0][filters][0][field]": "sku",
+			"searchCriteria[filterGroups][0][filters][0][value]": "ABC",
+		});
+	});
+
+	it("handles multiple filterGroups (OR semantics in Magento)", () => {
+		const out = stringifySearchCriteria({
+			filterGroups: [
+				{ filters: [{ field: "sku", value: "A" }] },
+				{ filters: [{ field: "sku", value: "B" }] },
+			],
+		});
+		expect(out).toEqual({
+			"searchCriteria[filterGroups][0][filters][0][field]": "sku",
+			"searchCriteria[filterGroups][0][filters][0][value]": "A",
+			"searchCriteria[filterGroups][1][filters][0][field]": "sku",
+			"searchCriteria[filterGroups][1][filters][0][value]": "B",
+		});
+	});
+
+	it("returns an empty object for empty input", () => {
+		expect(stringifySearchCriteria({})).toEqual({});
+	});
+});