@labdigital/commercetools-mock 2.51.0 → 2.53.0

package/package.json

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

package/src/lib/product-review-statistics.test.ts

@@ -0,0 +1,349 @@
+import type {
+	Product,
+	ProductProjection,
+	Review,
+} from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "~src/index";
+
+describe("Product Review Statistics", () => {
+	let ctMock: CommercetoolsMock;
+	let product: Product;
+
+	beforeEach(async () => {
+		ctMock = new CommercetoolsMock();
+
+		// Create a product
+		const productResponse = await supertest(ctMock.app)
+			.post("/dummy/products")
+			.send({
+				name: { en: "Test Product" },
+				slug: { en: "test-product" },
+				productType: {
+					typeId: "product-type",
+					key: "dummy-product-type",
+				},
+				masterVariant: {
+					sku: "test-sku-1",
+					prices: [
+						{
+							value: {
+								currencyCode: "EUR",
+								centAmount: 1000,
+							},
+						},
+					],
+				},
+			});
+		expect(productResponse.status).toBe(201);
+		product = productResponse.body;
+	});
+
+	test("product has no review statistics when no reviews exist", async () => {
+		const response = await supertest(ctMock.app).get(
+			`/dummy/products/${product.id}`,
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body.reviewRatingStatistics).toBeUndefined();
+	});
+
+	test("product has review statistics when reviews exist", async () => {
+		// Create reviews for the product
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "John Doe",
+				title: "Great product!",
+				text: "I really love this product.",
+				rating: 5,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "Jane Smith",
+				title: "Good product",
+				text: "Pretty good overall.",
+				rating: 4,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "Bob Wilson",
+				title: "Excellent!",
+				text: "Amazing quality.",
+				rating: 5,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		const response = await supertest(ctMock.app).get(
+			`/dummy/products/${product.id}`,
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body.reviewRatingStatistics).toBeDefined();
+		expect(response.body.reviewRatingStatistics.count).toBe(3);
+		expect(response.body.reviewRatingStatistics.averageRating).toBe(4.66667);
+		expect(response.body.reviewRatingStatistics.highestRating).toBe(5);
+		expect(response.body.reviewRatingStatistics.lowestRating).toBe(4);
+		expect(response.body.reviewRatingStatistics.ratingsDistribution).toEqual({
+			"4": 1,
+			"5": 2,
+		});
+	});
+
+	test("product projection has review statistics", async () => {
+		// Create a review for the product
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "Test User",
+				title: "Test Review",
+				text: "Test review text.",
+				rating: 3,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		const response = await supertest(ctMock.app).get(
+			`/dummy/product-projections/${product.id}`,
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body.reviewRatingStatistics).toBeDefined();
+		expect(response.body.reviewRatingStatistics.count).toBe(1);
+		expect(response.body.reviewRatingStatistics.averageRating).toBe(3);
+		expect(response.body.reviewRatingStatistics.highestRating).toBe(3);
+		expect(response.body.reviewRatingStatistics.lowestRating).toBe(3);
+		expect(response.body.reviewRatingStatistics.ratingsDistribution).toEqual({
+			"3": 1,
+		});
+	});
+
+	test("product query includes review statistics", async () => {
+		// Create reviews for the product
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "Reviewer 1",
+				rating: 2,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "Reviewer 2",
+				rating: 4,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		const response = await supertest(ctMock.app).get("/dummy/products");
+
+		expect(response.status).toBe(200);
+		expect(response.body.results).toHaveLength(1);
+		expect(response.body.results[0].reviewRatingStatistics).toBeDefined();
+		expect(response.body.results[0].reviewRatingStatistics.count).toBe(2);
+		expect(response.body.results[0].reviewRatingStatistics.averageRating).toBe(
+			3,
+		);
+		expect(response.body.results[0].reviewRatingStatistics.highestRating).toBe(
+			4,
+		);
+		expect(response.body.results[0].reviewRatingStatistics.lowestRating).toBe(
+			2,
+		);
+	});
+
+	test("only reviews with includedInStatistics=true are counted", async () => {
+		// Create reviews - both will be included by default
+		const review1Response = await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "Reviewer 1",
+				rating: 5,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		const review2Response = await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "Reviewer 2",
+				rating: 1,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		// Check that both reviews are included by default
+		const response = await supertest(ctMock.app).get(
+			`/dummy/products/${product.id}`,
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body.reviewRatingStatistics).toBeDefined();
+		expect(response.body.reviewRatingStatistics.count).toBe(2);
+		expect(response.body.reviewRatingStatistics.averageRating).toBe(3);
+
+		// Now exclude one review from statistics by updating it
+		// (Note: In a real implementation, this would be done via state transitions,
+		// but for now we can test the filtering works with includedInStatistics directly)
+	});
+
+	test("reviews without ratings are not included in statistics", async () => {
+		// Create a review without rating
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "No Rating User",
+				title: "No rating review",
+				text: "This review has no rating.",
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		// Create a review with rating
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "Rated User",
+				title: "Rated review",
+				rating: 4,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		const response = await supertest(ctMock.app).get(
+			`/dummy/products/${product.id}`,
+		);
+
+		expect(response.status).toBe(200);
+		// Only the review with rating should be counted
+		expect(response.body.reviewRatingStatistics).toBeDefined();
+		expect(response.body.reviewRatingStatistics.count).toBe(1);
+		expect(response.body.reviewRatingStatistics.averageRating).toBe(4);
+	});
+
+	test("reviews on other products are excluded from statistics", async () => {
+		// Create another product
+		const otherProductResponse = await supertest(ctMock.app)
+			.post("/dummy/products")
+			.send({
+				name: { en: "Other Product" },
+				slug: { en: "other-product" },
+				productType: {
+					typeId: "product-type",
+					key: "dummy-product-type",
+				},
+				masterVariant: {
+					sku: "other-sku",
+					prices: [
+						{
+							value: {
+								currencyCode: "EUR",
+								centAmount: 2000,
+							},
+						},
+					],
+				},
+			});
+		expect(otherProductResponse.status).toBe(201);
+		const otherProduct = otherProductResponse.body;
+
+		// Create reviews for both products
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "User A",
+				title: "Review for first product",
+				rating: 5,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "User B",
+				title: "Review for second product",
+				rating: 1,
+				target: {
+					typeId: "product",
+					id: otherProduct.id,
+				},
+			});
+
+		await supertest(ctMock.app)
+			.post("/dummy/reviews")
+			.send({
+				authorName: "User C",
+				title: "Another review for first product",
+				rating: 3,
+				target: {
+					typeId: "product",
+					id: product.id,
+				},
+			});
+
+		// Check statistics for the first product - should only include its own reviews
+		const response1 = await supertest(ctMock.app).get(
+			`/dummy/products/${product.id}`,
+		);
+		expect(response1.status).toBe(200);
+		expect(response1.body.reviewRatingStatistics).toBeDefined();
+		expect(response1.body.reviewRatingStatistics.count).toBe(2); // Only reviews for this product
+		expect(response1.body.reviewRatingStatistics.averageRating).toBe(4); // (5 + 3) / 2 = 4
+		expect(response1.body.reviewRatingStatistics.highestRating).toBe(5);
+		expect(response1.body.reviewRatingStatistics.lowestRating).toBe(3);
+		expect(response1.body.reviewRatingStatistics.ratingsDistribution).toEqual({
+			"3": 1,
+			"5": 1,
+		});
+
+		// Check statistics for the second product - should only include its own review
+		const response2 = await supertest(ctMock.app).get(
+			`/dummy/products/${otherProduct.id}`,
+		);
+		expect(response2.status).toBe(200);
+		expect(response2.body.reviewRatingStatistics).toBeDefined();
+		expect(response2.body.reviewRatingStatistics.count).toBe(1); // Only reviews for this product
+		expect(response2.body.reviewRatingStatistics.averageRating).toBe(1);
+		expect(response2.body.reviewRatingStatistics.highestRating).toBe(1);
+		expect(response2.body.reviewRatingStatistics.lowestRating).toBe(1);
+		expect(response2.body.reviewRatingStatistics.ratingsDistribution).toEqual({
+			"1": 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/lib/review-statistics.ts

@@ -0,0 +1,58 @@
+import type {
+	Review,
+	ReviewRatingStatistics,
+} from "@commercetools/platform-sdk";
+import type { AbstractStorage } from "../storage";
+
+export class ReviewStatisticsService {
+	constructor(private _storage: AbstractStorage) {}
+
+	calculateProductReviewStatistics(
+		projectKey: string,
+		productId: string,
+	): ReviewRatingStatistics | undefined {
+		// Get all reviews for this product
+		const allReviews = this._storage.all(projectKey, "review") as Review[];
+		const productReviews = allReviews.filter(
+			(review) =>
+				review.target?.typeId === "product" &&
+				review.target?.id === productId &&
+				review.includedInStatistics &&
+				review.rating !== undefined,
+		);
+
+		if (productReviews.length === 0) {
+			return undefined;
+		}
+
+		const ratings = productReviews
+			.map((review) => review.rating!)
+			.filter((rating) => rating !== undefined);
+
+		if (ratings.length === 0) {
+			return undefined;
+		}
+
+		// Calculate statistics
+		const count = ratings.length;
+		const sum = ratings.reduce((acc, rating) => acc + rating, 0);
+		const averageRating = Math.round((sum / count) * 100000) / 100000; // Round to 5 decimals
+		const highestRating = Math.max(...ratings);
+		const lowestRating = Math.min(...ratings);
+
+		// Calculate ratings distribution
+		const ratingsDistribution: { [key: string]: number } = {};
+		for (const rating of ratings) {
+			const key = rating.toString();
+			ratingsDistribution[key] = (ratingsDistribution[key] || 0) + 1;
+		}
+
+		return {
+			averageRating,
+			highestRating,
+			lowestRating,
+			count,
+			ratingsDistribution,
+		};
+	}
+}

package/src/product-projection-search.ts

@@ -22,6 +22,7 @@ import {
 	parseFilterExpression,
 	resolveVariantValue,
 } from "./lib/projectionSearchFilter";
+import { ReviewStatisticsService } from "./lib/review-statistics";
 import { applyPriceSelector } from "./priceSelector";
 import type { AbstractStorage } from "./storage";
 import type { Writable } from "./types";
@@ -51,9 +52,11 @@ export type ProductProjectionSearchParams = {
 
 export class ProductProjectionSearch {
 	protected _storage: AbstractStorage;
+	protected _reviewStatisticsService: ReviewStatisticsService;
 
 	constructor(config: Config) {
 		this._storage = config.storage;
+		this._reviewStatisticsService = new ReviewStatisticsService(config.storage);
 	}
 
 	search(
@@ -62,7 +65,7 @@ export class ProductProjectionSearch {
 	): ProductProjectionPagedSearchResponse {
 		let resources = this._storage
 			.all(projectKey, "product")
-			.map((r) => this.transform(r, params.staged ?? false))
+			.map((r) => this.transform(r, params.staged ?? false, projectKey))
 			.filter((p) => {
 				if (!(params.staged ?? false)) {
 					return p.published;
@@ -147,11 +150,22 @@ export class ProductProjectionSearch {
 		};
 	}
 
-	transform(product: Product, staged: boolean): ProductProjection {
+	transform(
+		product: Product,
+		staged: boolean,
+		projectKey: string,
+	): ProductProjection {
 		const obj = !staged
 			? product.masterData.current
 			: product.masterData.staged;
 
+		// Calculate review statistics for this product
+		const reviewRatingStatistics =
+			this._reviewStatisticsService.calculateProductReviewStatistics(
+				projectKey,
+				product.id,
+			);
+
 		return {
 			id: product.id,
 			createdAt: product.createdAt,
@@ -168,6 +182,7 @@ export class ProductProjectionSearch {
 			productType: product.productType,
 			hasStagedChanges: product.masterData.hasStagedChanges,
 			published: product.masterData.published,
+			reviewRatingStatistics,
 		};
 	}