@labdigital/commercetools-mock 2.52.0 → 2.53.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labdigital/commercetools-mock",
-  "version": "2.52.0",
+  "version": "2.53.1",
   "license": "MIT",
   "author": "Michael van Tellingen",
   "type": "module",

package/src/lib/predicateParser.ts

@@ -88,6 +88,15 @@ const resolveValue = (obj: any, val: TypeSymbol): any => {
 		throw new PredicateError("Internal error");
 	}
 
+	// variants() includes both masterVariant and variants for predicates
+	if (
+		val.value === "variants" &&
+		obj.masterVariant &&
+		obj.variants !== undefined
+	) {
+		return [obj.masterVariant, ...(obj.variants ?? [])];
+	}
+
 	if (!(val.value in obj)) {
 		if (Array.isArray(obj)) {
 			return Object.values(obj)
@@ -230,7 +239,7 @@ const generateMatchFunc = (predicate: string): MatchFunc => {
 
 		.led("AND", 5, ({ left, bp }) => {
 			const expr = parser.parse({ terminals: [bp - 1] });
-			return (obj: any) => left(obj) && expr(obj);
+			return (obj: any, vars: object) => left(obj, vars) && expr(obj, vars);
 		})
 		.led("OR", 5, ({ left, token, bp }) => {
 			const expr = parser.parse({ terminals: [bp - 1] });

package/src/lib/productSearchFilter.test.ts

@@ -346,4 +346,81 @@ describe("Product search filter", () => {
 			}).isMatch,
 		).toBeTruthy();
 	});
+
+	test("by availability.isOnStock", async () => {
+		const productWithAvailability: ProductProjection = {
+			...exampleProduct,
+			masterVariant: {
+				...exampleProduct.masterVariant,
+				availability: {
+					isOnStock: true,
+					availableQuantity: 10,
+					isOnStockForChannel: "test-channel",
+				} as any, // Cast to any since isOnStockForChannel is not in SDK type
+			},
+		};
+
+		// This should pass - current behavior
+		const result1 = match(
+			{
+				exact: {
+					field: "variants.availability.isOnStock",
+					value: true,
+				},
+			},
+			productWithAvailability,
+		);
+
+		expect(result1.isMatch).toBeTruthy();
+
+		const result2 = match(
+			{
+				exact: {
+					field: "variants.availability.isOnStock",
+					value: false,
+				},
+			},
+			productWithAvailability,
+		);
+
+		expect(result2.isMatch).toBeFalsy();
+	});
+
+	test("by availability.isOnStockForChannel", async () => {
+		const productWithAvailability: ProductProjection = {
+			...exampleProduct,
+			masterVariant: {
+				...exampleProduct.masterVariant,
+				availability: {
+					isOnStock: true,
+					availableQuantity: 10,
+					isOnStockForChannel: "test-channel",
+				} as any, // Cast to any since isOnStockForChannel is not in SDK type
+			},
+		};
+
+		expect(
+			match(
+				{
+					exact: {
+						field: "variants.availability.isOnStockForChannel",
+						value: "test-channel",
+					},
+				},
+				productWithAvailability,
+			).isMatch,
+		).toBeTruthy();
+
+		expect(
+			match(
+				{
+					exact: {
+						field: "variants.availability.isOnStockForChannel",
+						value: "other-channel",
+					},
+				},
+				productWithAvailability,
+			).isMatch,
+		).toBeFalsy();
+	});
 });

package/src/product-search-availability.test.ts

@@ -0,0 +1,242 @@
+import type {
+	InventoryEntryDraft,
+	ProductDraft,
+	ProductPagedSearchResponse,
+	ProductSearchRequest,
+} from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "./index";
+
+describe("Product Search - Availability Filtering", () => {
+	const ctMock = new CommercetoolsMock();
+	let productId: string;
+
+	beforeEach(async () => {
+		// Create a product type first
+		const productTypeDraft = {
+			name: "Test Product Type",
+			key: "test-type",
+			description: "Test Product Type",
+		};
+
+		await supertest(ctMock.app)
+			.post("/dummy/product-types")
+			.send(productTypeDraft);
+
+		// Create a test product
+		const productDraft: ProductDraft = {
+			name: { "en-US": "Test Product" },
+			productType: {
+				typeId: "product-type",
+				key: "test-type",
+			},
+			slug: { "en-US": "test-product" },
+			masterVariant: {
+				sku: "TEST-SKU-001",
+			},
+			variants: [
+				{
+					sku: "TEST-SKU-002",
+				},
+			],
+		};
+
+		const productResponse = await supertest(ctMock.app)
+			.post("/dummy/products")
+			.send(productDraft);
+
+		productId = productResponse.body.id;
+
+		// Publish the product
+		await supertest(ctMock.app)
+			.post(`/dummy/products/${productId}`)
+			.send({
+				version: productResponse.body.version,
+				actions: [{ action: "publish" }],
+			});
+	});
+
+	afterEach(() => {
+		ctMock.clear();
+	});
+
+	async function createInventoryEntry(
+		sku: string,
+		quantityOnStock: number,
+		channelId?: string,
+	) {
+		const inventoryEntry: InventoryEntryDraft = {
+			sku,
+			quantityOnStock,
+			...(channelId && {
+				supplyChannel: {
+					typeId: "channel",
+					id: channelId,
+				},
+			}),
+		};
+
+		await supertest(ctMock.app).post("/dummy/inventory").send(inventoryEntry);
+	}
+
+	async function searchProducts(
+		query?: any,
+	): Promise<ProductPagedSearchResponse> {
+		const searchRequest: ProductSearchRequest = {
+			...(query && { query }),
+			productProjectionParameters: {
+				staged: false,
+			},
+		};
+
+		const response = await supertest(ctMock.app)
+			.post("/dummy/products/search")
+			.send(searchRequest);
+
+		return response.body;
+	}
+
+	test("should filter products by variants.availability.isOnStock = true", async () => {
+		// Create inventory with stock for one variant
+		await createInventoryEntry("TEST-SKU-001", 10);
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStock",
+				value: true,
+			},
+		});
+
+		expect(result.results).toHaveLength(1);
+		expect(
+			result.results[0].productProjection?.masterVariant?.availability
+				?.isOnStock,
+		).toBe(true);
+	});
+
+	test("should filter products by variants.availability.isOnStock = false", async () => {
+		// Create inventory with zero stock
+		await createInventoryEntry("TEST-SKU-001", 0);
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStock",
+				value: false,
+			},
+		});
+
+		// Should find the product because it's not on stock
+		expect(result.results).toHaveLength(1);
+		expect(
+			result.results[0].productProjection?.masterVariant?.availability
+				?.isOnStock,
+		).toBe(false);
+	});
+
+	test("should filter products by variants.availability.isOnStockForChannel", async () => {
+		const channelId = "test-channel-1";
+
+		// Create inventory for specific channel
+		await createInventoryEntry("TEST-SKU-001", 5, channelId);
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStockForChannel",
+				value: channelId,
+			},
+		});
+
+		expect(result.results).toHaveLength(1);
+		expect(
+			(result.results[0].productProjection?.masterVariant?.availability as any)
+				?.isOnStockForChannel,
+		).toBe(channelId);
+	});
+
+	test("should not find products when filtering by non-matching channel", async () => {
+		const channelId = "test-channel-1";
+		const otherChannelId = "test-channel-2";
+
+		// Create inventory for specific channel
+		await createInventoryEntry("TEST-SKU-001", 5, channelId);
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStockForChannel",
+				value: otherChannelId,
+			},
+		});
+
+		expect(result.results).toHaveLength(0);
+	});
+
+	test("should handle products without inventory entries", async () => {
+		// Don't create any inventory entries
+
+		const result = await searchProducts({
+			exact: {
+				field: "variants.availability.isOnStock",
+				value: false,
+			},
+		});
+
+		// Should find the product because it has no stock
+		expect(result.results).toHaveLength(1);
+		expect(
+			result.results[0].productProjection?.masterVariant?.availability
+				?.isOnStock,
+		).toBe(false);
+	});
+
+	test("should work with OR queries for availability", async () => {
+		// Create inventory with stock
+		await createInventoryEntry("TEST-SKU-001", 10);
+
+		const result = await searchProducts({
+			or: [
+				{
+					exact: {
+						field: "variants.availability.isOnStock",
+						value: true,
+					},
+				},
+				{
+					exact: {
+						field: "variants.availability.isOnStock",
+						value: false,
+					},
+				},
+			],
+		});
+
+		// Should find the product regardless of stock status
+		expect(result.results).toHaveLength(1);
+	});
+
+	test("should work with AND queries combining availability and other fields", async () => {
+		await createInventoryEntry("TEST-SKU-001", 10);
+
+		const result = await searchProducts({
+			and: [
+				{
+					exact: {
+						field: "variants.availability.isOnStock",
+						value: true,
+					},
+				},
+				{
+					exact: {
+						field: "variants.sku",
+						value: "TEST-SKU-001",
+					},
+				},
+			],
+		});
+
+		expect(result.results).toHaveLength(1);
+		expect(result.results[0].productProjection?.masterVariant?.sku).toBe(
+			"TEST-SKU-001",
+		);
+	});
+});

package/src/product-search.ts

@@ -148,6 +148,23 @@ export class ProductSearch {
 			? product.masterData.current
 			: product.masterData.staged;
 
+		const getVariantAvailability = (sku?: string) => {
+			if (!sku) {
+				return {
+					isOnStock: false,
+					availableQuantity: 0,
+					isOnStockForChannel: undefined,
+				};
+			}
+			return (
+				availabilityBySku.get(sku) || {
+					isOnStock: false,
+					availableQuantity: 0,
+					isOnStockForChannel: undefined,
+				}
+			);
+		};
+
 		return {
 			id: product.id,
 			createdAt: product.createdAt,
@@ -159,12 +176,13 @@ export class ProductSearch {
 			metaDescription: obj.metaDescription,
 			slug: obj.slug,
 			categories: obj.categories,
-			masterVariant: obj.masterVariant,
+			masterVariant: {
+				...obj.masterVariant,
+				availability: getVariantAvailability(obj.masterVariant.sku),
+			},
 			variants: obj.variants.map((variant) => ({
 				...variant,
-				availability: variant.sku
-					? availabilityBySku.get(variant.sku)
-					: { isOnStock: false, availableQuantity: 0, isOnStockForChannel: [] },
+				availability: getVariantAvailability(variant.sku),
 			})),
 			productType: product.productType,
 			hasStagedChanges: product.masterData.hasStagedChanges,

package/src/repositories/business-unit.test.ts

@@ -1,7 +1,10 @@
 import type {
+	BusinessUnitAddShippingAddressIdAction,
 	BusinessUnitChangeNameAction,
 	BusinessUnitChangeStatusAction,
+	BusinessUnitRemoveAddressAction,
 	BusinessUnitSetContactEmailAction,
+	BusinessUnitSetDefaultShippingAddressAction,
 	CompanyDraft,
 	DivisionDraft,
 } from "@commercetools/platform-sdk";
@@ -250,6 +253,146 @@ describe("BusinessUnit Repository", () => {
 		expect(result.version).toBe(businessUnit.version + 1);
 	});
 
+	test("update business unit - setDefaultShippingAddress", () => {
+		const draft: CompanyDraft = {
+			key: "default-shipping-company",
+			unitType: "Company",
+			name: "Default Shipping Company",
+			addresses: [
+				{
+					country: "US",
+					city: "New York",
+					streetName: "5th Avenue",
+					streetNumber: "123",
+					postalCode: "10001",
+				},
+				{
+					country: "US",
+					city: "Boston",
+					streetName: "Boylston",
+					streetNumber: "456",
+					postalCode: "02116",
+				},
+			],
+			shippingAddresses: [0, 1],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const businessUnit = repository.create(ctx, draft);
+		const addressId = businessUnit.addresses[1].id;
+
+		const result = repository.processUpdateActions(
+			ctx,
+			businessUnit,
+			businessUnit.version,
+			[
+				{
+					action: "setDefaultShippingAddress",
+					addressId,
+				} as BusinessUnitSetDefaultShippingAddressAction,
+			],
+		);
+
+		expect(result.defaultShippingAddressId).toBe(addressId);
+		expect(result.version).toBe(businessUnit.version + 1);
+	});
+
+	test("update business unit - addShippingAddressId", () => {
+		const draft: CompanyDraft = {
+			key: "add-shipping-address-company",
+			unitType: "Company",
+			name: "Add Shipping Address Company",
+			addresses: [
+				{
+					country: "US",
+					city: "New York",
+					streetName: "5th Avenue",
+					streetNumber: "123",
+					postalCode: "10001",
+				},
+				{
+					country: "US",
+					city: "Boston",
+					streetName: "Boylston",
+					streetNumber: "456",
+					postalCode: "02116",
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const businessUnit = repository.create(ctx, draft);
+		const addressId = businessUnit.addresses[1].id;
+
+		const result = repository.processUpdateActions(
+			ctx,
+			businessUnit,
+			businessUnit.version,
+			[
+				{
+					action: "addShippingAddressId",
+					addressId,
+				} as BusinessUnitAddShippingAddressIdAction,
+			],
+		);
+
+		expect(result.shippingAddressIds).toContain(addressId);
+		expect(result.version).toBe(businessUnit.version + 1);
+	});
+
+	test("update business unit - removeAddress", () => {
+		const draft: CompanyDraft = {
+			key: "remove-address-company",
+			unitType: "Company",
+			name: "Remove Address Company",
+			addresses: [
+				{
+					country: "US",
+					city: "New York",
+					streetName: "5th Avenue",
+					streetNumber: "123",
+					postalCode: "10001",
+				},
+				{
+					country: "US",
+					city: "Boston",
+					streetName: "Boylston",
+					streetNumber: "456",
+					postalCode: "02116",
+				},
+			],
+			billingAddresses: [0, 1],
+			shippingAddresses: [0, 1],
+			defaultBillingAddress: 0,
+			defaultShippingAddress: 1,
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const businessUnit = repository.create(ctx, draft);
+		const addressIdToRemove = businessUnit.addresses[0].id;
+		const remainingAddressId = businessUnit.addresses[1].id;
+
+		const result = repository.processUpdateActions(
+			ctx,
+			businessUnit,
+			businessUnit.version,
+			[
+				{
+					action: "removeAddress",
+					addressId: addressIdToRemove,
+				} as BusinessUnitRemoveAddressAction,
+			],
+		);
+
+		expect(result.addresses).toHaveLength(1);
+		expect(result.addresses[0].id).toBe(remainingAddressId);
+		expect(result.billingAddressIds).toEqual([remainingAddressId]);
+		expect(result.shippingAddressIds).toEqual([remainingAddressId]);
+		expect(result.defaultBillingAddressId).toBeUndefined();
+		expect(result.defaultShippingAddressId).toBe(remainingAddressId);
+		expect(result.version).toBe(businessUnit.version + 1);
+	});
+
 	test("get and delete business unit", () => {
 		const draft: CompanyDraft = {
 			key: "delete-test",

package/src/repositories/business-unit.ts

@@ -1,8 +1,10 @@
 import type {
+	BusinessUnitAddShippingAddressIdAction,
 	BusinessUnitChangeApprovalRuleModeAction,
 	BusinessUnitChangeAssociateModeAction,
 	BusinessUnitChangeStatusAction,
 	BusinessUnitSetCustomTypeAction,
+	BusinessUnitSetDefaultShippingAddressAction,
 	BusinessUnitUpdateAction,
 	CompanyDraft,
 	DivisionDraft,
@@ -17,6 +19,7 @@ import type {
 	BusinessUnitChangeNameAction,
 	BusinessUnitChangeParentUnitAction,
 	BusinessUnitDraft,
+	BusinessUnitRemoveAddressAction,
 	BusinessUnitSetAssociatesAction,
 	BusinessUnitSetContactEmailAction,
 	BusinessUnitSetStoreModeAction,
@@ -289,4 +292,53 @@ class BusinessUnitUpdateHandler
 	) {
 		resource.storeMode = storeMode;
 	}
+
+	setDefaultShippingAddress(
+		context: RepositoryContext,
+		resource: Writable<BusinessUnit>,
+		{ addressId }: BusinessUnitSetDefaultShippingAddressAction,
+	) {
+		resource.defaultShippingAddressId = addressId;
+	}
+
+	addShippingAddressId(
+		context: RepositoryContext,
+		resource: Writable<BusinessUnit>,
+		{ addressId }: BusinessUnitAddShippingAddressIdAction,
+	) {
+		if (!resource.shippingAddressIds) {
+			resource.shippingAddressIds = [];
+		}
+		if (addressId) {
+			resource.shippingAddressIds.push(addressId);
+		}
+	}
+
+	removeAddress(
+		context: RepositoryContext,
+		resource: Writable<BusinessUnit>,
+		{ addressId }: BusinessUnitRemoveAddressAction,
+	) {
+		resource.addresses = resource.addresses.filter(
+			(addr) => addr.id !== addressId,
+		);
+
+		if (resource.shippingAddressIds) {
+			resource.shippingAddressIds = resource.shippingAddressIds.filter(
+				(id) => id !== addressId,
+			);
+		}
+		if (resource.billingAddressIds) {
+			resource.billingAddressIds = resource.billingAddressIds.filter(
+				(id) => id !== addressId,
+			);
+		}
+
+		if (resource.defaultShippingAddressId === addressId) {
+			resource.defaultShippingAddressId = undefined;
+		}
+		if (resource.defaultBillingAddressId === addressId) {
+			resource.defaultBillingAddressId = undefined;
+		}
+	}
 }

package/src/services/product-projection.test.ts

@@ -97,6 +97,10 @@ beforeEach(async () => {
 						name: "number",
 						value: 4 as any,
 					},
+					{
+						name: "store",
+						value: ["test-store"],
+					},
 				],
 			},
 			variants: [
@@ -252,6 +256,30 @@ describe("Product Projection Query - Generic", () => {
 		}
 	});
 
+	test("Filter on complex query", async () => {
+		{
+			const response = await supertest(ctMock.app)
+				.get("/dummy/product-projections")
+				.query({
+					limit: 50,
+					where: [
+						'slug(nl-NL=:slug) and variants(attributes(name="store" and value="test-store"))',
+					],
+					"var.slug": "test-product",
+					"var.store": "test-store",
+				});
+
+			const result: ProductProjectionPagedSearchResponse = response.body;
+			expect(result).toEqual({
+				count: 1,
+				limit: 50,
+				offset: 0,
+				total: 1,
+				results: [productProjection],
+			});
+		}
+	});
+
 	test("Filter on invalid slug", async () => {
 		{
 			const response = await supertest(ctMock.app)