@labdigital/commercetools-mock 2.65.1 → 3.0.0-beta.0

package/src/testing/quote-request.ts

@@ -0,0 +1,29 @@
+import type {
+	QuoteRequest,
+	QuoteRequestDraft,
+} from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const quoteRequestDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<QuoteRequestDraft, QuoteRequestDraft, QuoteRequest>(
+		({ onCreate }) => {
+			onCreate(async (draft) => {
+				const response = await m.app.inject({
+					method: "POST",
+					url: "/dummy/quote-requests",
+					payload: draft,
+				});
+
+				return response.json();
+			});
+
+			return {
+				cart: {
+					typeId: "cart" as const,
+					id: "placeholder-cart-id",
+				},
+				cartVersion: 1,
+			};
+		},
+	);

package/src/testing/recurrence-policy.ts

@@ -0,0 +1,33 @@
+import type {
+	RecurrencePolicy,
+	RecurrencePolicyDraft,
+} from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const recurrencePolicyDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<
+		RecurrencePolicyDraft,
+		RecurrencePolicyDraft,
+		RecurrencePolicy
+	>(({ sequence, onCreate }) => {
+		onCreate(async (draft) => {
+			const response = await m.app.inject({
+				method: "POST",
+				url: "/dummy/recurrence-policies",
+				payload: draft,
+			});
+
+			return response.json();
+		});
+
+		return {
+			key: `recurrence-policy-${sequence}`,
+			name: { en: `Recurrence Policy ${sequence}` },
+			schedule: {
+				type: "standard",
+				value: 1,
+				intervalUnit: "Months",
+			},
+		};
+	});

package/src/testing/recurring-order.ts

@@ -0,0 +1,32 @@
+import type {
+	RecurringOrder,
+	RecurringOrderDraft,
+} from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const recurringOrderDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<RecurringOrderDraft, RecurringOrderDraft, RecurringOrder>(
+		({ sequence, onCreate }) => {
+			onCreate(async (draft) => {
+				const response = await m.app.inject({
+					method: "POST",
+					url: "/dummy/recurring-orders",
+					payload: draft,
+				});
+
+				return response.json();
+			});
+
+			return {
+				key: `recurring-order-${sequence}`,
+				cart: {
+					typeId: "cart" as const,
+					id: "placeholder-cart-id",
+				},
+				cartVersion: 1,
+				startsAt: "2025-01-01T10:00:00.000Z",
+				expiresAt: "2025-12-31T23:59:59.000Z",
+			};
+		},
+	);

package/src/testing/review.ts

@@ -0,0 +1,24 @@
+import type { Review, ReviewDraft } from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const reviewDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<ReviewDraft, ReviewDraft, Review>(({ sequence, onCreate }) => {
+		onCreate(async (draft) => {
+			const response = await m.app.inject({
+				method: "POST",
+				url: "/dummy/reviews",
+				payload: draft,
+			});
+
+			return response.json();
+		});
+
+		return {
+			key: `review-${sequence}`,
+			authorName: `Author ${sequence}`,
+			title: `Review ${sequence}`,
+			text: `Review text ${sequence}`,
+			rating: 5,
+		};
+	});

package/src/testing/shipping-method.ts

@@ -0,0 +1,31 @@
+import type {
+	ShippingMethod,
+	ShippingMethodDraft,
+} from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const shippingMethodDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<ShippingMethodDraft, ShippingMethodDraft, ShippingMethod>(
+		({ sequence, onCreate }) => {
+			onCreate(async (draft) => {
+				const response = await m.app.inject({
+					method: "POST",
+					url: "/dummy/shipping-methods",
+					payload: draft,
+				});
+
+				return response.json();
+			});
+
+			return {
+				name: `Shipping Method ${sequence}`,
+				taxCategory: {
+					typeId: "tax-category",
+					key: `tax-category-${sequence}`,
+				},
+				isDefault: true,
+				zoneRates: [],
+			};
+		},
+	);

package/src/testing/shopping-list.ts

@@ -0,0 +1,25 @@
+import type {
+	ShoppingList,
+	ShoppingListDraft,
+} from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const shoppingListDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<ShoppingListDraft, ShoppingListDraft, ShoppingList>(
+		({ sequence, onCreate }) => {
+			onCreate(async (draft) => {
+				const response = await m.app.inject({
+					method: "POST",
+					url: "/dummy/shopping-lists",
+					payload: draft,
+				});
+
+				return response.json();
+			});
+
+			return {
+				name: { en: `Shopping List ${sequence}` },
+			};
+		},
+	);

package/src/testing/standalone-price.ts

@@ -0,0 +1,31 @@
+import type {
+	StandalonePrice,
+	StandalonePriceDraft,
+} from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const standalonePriceDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<StandalonePriceDraft, StandalonePriceDraft, StandalonePrice>(
+		({ sequence, onCreate }) => {
+			onCreate(async (draft) => {
+				const response = await m.app.inject({
+					method: "POST",
+					url: "/dummy/standalone-prices",
+					payload: draft,
+				});
+
+				return response.json();
+			});
+
+			return {
+				key: `standalone-price-${sequence}`,
+				sku: `sku-${sequence}`,
+				value: {
+					centAmount: 1000,
+					currencyCode: "EUR",
+				},
+				active: true,
+			};
+		},
+	);

package/src/testing/state.ts

@@ -0,0 +1,21 @@
+import type { State, StateDraft } from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const stateDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<StateDraft, StateDraft, State>(({ sequence, onCreate }) => {
+		onCreate(async (draft) => {
+			const response = await m.app.inject({
+				method: "POST",
+				url: "/dummy/states",
+				payload: draft,
+			});
+
+			return response.json();
+		});
+
+		return {
+			key: `state-${sequence}`,
+			type: "PaymentState",
+		};
+	});

package/src/testing/store.ts

@@ -0,0 +1,26 @@
+import type { Store, StoreDraft } from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const storeDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<StoreDraft, StoreDraft, Store>(({ sequence, onCreate }) => {
+		onCreate(async (draft) => {
+			const response = await m.app.inject({
+				method: "POST",
+				url: "/dummy/stores",
+				payload: draft,
+			});
+
+			return response.json();
+		});
+
+		return {
+			key: `store-${sequence}`,
+			name: { en: `Store ${sequence}` },
+			languages: [],
+			countries: [],
+			distributionChannels: [],
+			supplyChannels: [],
+			productSelections: [],
+		};
+	});

package/src/testing/subscription.ts

@@ -0,0 +1,38 @@
+import type {
+	Subscription,
+	SubscriptionDraft,
+} from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const subscriptionDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<SubscriptionDraft, SubscriptionDraft, Subscription>(
+		({ sequence, onCreate }) => {
+			onCreate(async (draft) => {
+				const response = await m.app.inject({
+					method: "POST",
+					url: "/dummy/subscriptions",
+					payload: draft,
+				});
+
+				return response.json();
+			});
+
+			return {
+				key: `subscription-${sequence}`,
+				destination: {
+					type: "SQS",
+					queueUrl: `https://sqs.us-east-1.amazonaws.com/123456789/queue-${sequence}`,
+					accessKey: "AKIAIOSFODNN7EXAMPLE",
+					accessSecret: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+					region: "us-east-1",
+				},
+				messages: [
+					{
+						resourceTypeId: "order",
+						types: ["OrderCreated"],
+					},
+				],
+			};
+		},
+	);

package/src/testing/tax-category.ts

@@ -0,0 +1,27 @@
+import type {
+	TaxCategory,
+	TaxCategoryDraft,
+} from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const taxCategoryDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<TaxCategoryDraft, TaxCategoryDraft, TaxCategory>(
+		({ sequence, onCreate }) => {
+			onCreate(async (draft) => {
+				const response = await m.app.inject({
+					method: "POST",
+					url: "/dummy/tax-categories",
+					payload: draft,
+				});
+
+				return response.json();
+			});
+
+			return {
+				key: `tax-category-${sequence}`,
+				name: `Tax Category ${sequence}`,
+				rates: [],
+			};
+		},
+	);

package/src/testing/type.ts

@@ -1,19 +1,22 @@
 import type { Type, TypeDraft } from "@commercetools/platform-sdk";
 import { Factory } from "fishery";
-import supertest from "supertest";
 import type { CommercetoolsMock } from "#src/ctMock.ts";
 
 export const typeDraftFactory = (m: CommercetoolsMock) =>
-	Factory.define<TypeDraft, TypeDraft, Type>(({ onCreate }) => {
+	Factory.define<TypeDraft, TypeDraft, Type>(({ sequence, onCreate }) => {
 		onCreate(async (draft) => {
-			const response = await supertest(m.app).post("/dummy/types").send(draft);
+			const response = await m.app.inject({
+				method: "POST",
+				url: "/dummy/types",
+				payload: draft,
+			});
 
-			return response.body;
+			return response.json();
 		});
 
 		return {
-			key: "type",
-			name: { en: "Type Name" },
+			key: `type-${sequence}`,
+			name: { en: `Type Name ${sequence}` },
 			resourceTypeIds: ["product"],
 			description: { en: "Type description" },
 		};

package/src/testing/zone.ts

@@ -0,0 +1,22 @@
+import type { Zone, ZoneDraft } from "@commercetools/platform-sdk";
+import { Factory } from "fishery";
+import type { CommercetoolsMock } from "#src/ctMock.ts";
+
+export const zoneDraftFactory = (m: CommercetoolsMock) =>
+	Factory.define<ZoneDraft, ZoneDraft, Zone>(({ sequence, onCreate }) => {
+		onCreate(async (draft) => {
+			const response = await m.app.inject({
+				method: "POST",
+				url: "/dummy/zones",
+				payload: draft,
+			});
+
+			return response.json();
+		});
+
+		return {
+			key: `zone-${sequence}`,
+			name: `Zone ${sequence}`,
+			locations: [{ country: "NL" }],
+		};
+	});

package/src/validate.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { formatDetailedErrorMessage } from "./validate.ts";
+
+describe("formatDetailedErrorMessage", () => {
+	it("formats missing required field", () => {
+		const schema = z.object({ name: z.string() });
+		const result = schema.safeParse({});
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"name: Missing required value",
+			);
+		}
+	});
+
+	it("formats wrong type (string expected, got number)", () => {
+		const schema = z.object({ name: z.string() });
+		const result = schema.safeParse({ name: 123 });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"name: JSON String expected.",
+			);
+		}
+	});
+
+	it("formats wrong type (number expected, got string)", () => {
+		const schema = z.object({ count: z.number() });
+		const result = schema.safeParse({ count: "abc" });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"count: JSON Number expected.",
+			);
+		}
+	});
+
+	it("formats wrong type (boolean expected)", () => {
+		const schema = z.object({ active: z.boolean() });
+		const result = schema.safeParse({ active: "yes" });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"active: JSON Boolean expected.",
+			);
+		}
+	});
+
+	it("formats wrong type (object expected)", () => {
+		const schema = z.object({ data: z.object({ id: z.string() }) });
+		const result = schema.safeParse({ data: "not-an-object" });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"data: JSON object expected.",
+			);
+		}
+	});
+
+	it("formats wrong type (array expected)", () => {
+		const schema = z.object({ items: z.array(z.string()) });
+		const result = schema.safeParse({ items: "not-an-array" });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"items: JSON Array expected.",
+			);
+		}
+	});
+
+	it("formats invalid enum value", () => {
+		const schema = z.object({ role: z.enum(["Admin", "User"]) });
+		const result = schema.safeParse({ role: "SuperAdmin" });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"role: Invalid enum value. Expected one of: 'Admin', 'User'",
+			);
+		}
+	});
+
+	it("formats nested field errors with dot path", () => {
+		const schema = z.object({
+			address: z.object({ country: z.string() }),
+		});
+		const result = schema.safeParse({ address: { country: 123 } });
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"address.country: JSON String expected.",
+			);
+		}
+	});
+
+	it("formats refine errors (custom code)", () => {
+		const schema = z
+			.object({ id: z.string().optional(), key: z.string().optional() })
+			.refine((data) => data.id !== undefined || data.key !== undefined, {
+				message: "Either 'id' or 'key' must be provided",
+			});
+		const result = schema.safeParse({});
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"Either 'id' or 'key' must be provided",
+			);
+		}
+	});
+
+	it("uses first issue only when multiple errors exist", () => {
+		const schema = z.object({ a: z.string(), b: z.number() });
+		const result = schema.safeParse({});
+		expect(result.success).toBe(false);
+		if (!result.success) {
+			// Should report the first missing field only
+			expect(formatDetailedErrorMessage(result.error)).toBe(
+				"a: Missing required value",
+			);
+		}
+	});
+});

package/src/validate.ts

@@ -1,18 +1,89 @@
 import type { InvalidJsonInputError } from "@commercetools/platform-sdk";
 import type { z } from "zod";
-import { fromZodError } from "zod-validation-error";
 import { CommercetoolsError } from "./exceptions.ts";
 
-export const validateData = <T>(data: any, schema: z.AnyZodObject) => {
-	try {
-		schema.parse(data);
+/**
+ * Format a Zod error into a commercetools-style detailedErrorMessage.
+ *
+ * The real API uses messages like:
+ *   "quantityOnStock: Missing required value"
+ *   "name: JSON object expected."
+ *   "roles: Invalid enum value. Expected one of: 'InventorySupply', ..."
+ *
+ * We use the first issue only, matching the real API behaviour of reporting
+ * a single detailed message.
+ */
+export function formatDetailedErrorMessage(error: z.ZodError): string {
+	const issue = error.issues[0];
+	if (!issue) return "Unknown error";
+
+	const path = issue.path.join(".");
+
+	// Missing required field: Zod reports invalid_type with "received undefined"
+	if (
+		issue.code === "invalid_type" &&
+		issue.message.includes("received undefined")
+	) {
+		return `${path}: Missing required value`;
+	}
+
+	// Wrong type (e.g. string received instead of number)
+	if (issue.code === "invalid_type") {
+		const expected = (issue as any).expected;
+		switch (expected) {
+			case "string":
+				return `${path}: JSON String expected.`;
+			case "number":
+			case "integer":
+				return `${path}: JSON Number expected.`;
+			case "boolean":
+				return `${path}: JSON Boolean expected.`;
+			case "object":
+				return `${path}: JSON object expected.`;
+			case "array":
+				return `${path}: JSON Array expected.`;
+			default:
+				return `${path}: Invalid type: expected ${expected}`;
+		}
+	}
+
+	// Invalid enum value
+	if (issue.code === "invalid_value") {
+		const values = (issue as any).values;
+		if (Array.isArray(values)) {
+			const formatted = values.map((v: string) => `'${v}'`).join(", ");
+			return `${path}: Invalid enum value. Expected one of: ${formatted}`;
+		}
+	}
+
+	// Refine errors (e.g. ResourceIdentifier id-or-key check)
+	if (issue.code === "custom") {
+		return issue.message;
+	}
+
+	// Fallback: use Zod's message with path prefix
+	return path ? `${path}: ${issue.message}` : issue.message;
+}
+
+export const validateData = <T>(data: any, schema: z.ZodType) => {
+	const result = schema.safeParse(data);
+	if (result.success) {
 		return data as T;
-	} catch (err: any) {
-		const validationError = fromZodError(err);
+	}
+	throw new CommercetoolsError<InvalidJsonInputError>({
+		code: "InvalidJsonInput",
+		message: "Request body does not contain valid JSON.",
+		detailedErrorMessage: formatDetailedErrorMessage(result.error),
+	});
+};
+
+export const validateDraft = (data: unknown, schema: z.ZodType): void => {
+	const result = schema.safeParse(data);
+	if (!result.success) {
 		throw new CommercetoolsError<InvalidJsonInputError>({
 			code: "InvalidJsonInput",
 			message: "Request body does not contain valid JSON.",
-			detailedErrorMessage: validationError.toString(),
+			detailedErrorMessage: formatDetailedErrorMessage(result.error),
 		});
 	}
 };