@labdigital/commercetools-mock 2.50.1 → 2.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labdigital/commercetools-mock",
-  "version": "2.50.1",
+  "version": "2.52.0",
   "license": "MIT",
   "author": "Michael van Tellingen",
   "type": "module",
@@ -60,7 +60,7 @@
     "build": "tsdown",
     "build:server": "esbuild src/server.ts --bundle --outfile=dist/server.js --platform=node",
     "check": "biome check && tsc",
-    "format": "biome format --fix",
+    "format": "biome check --fix",
     "lint": "biome check",
     "publish:ci": "pnpm build && pnpm changeset publish",
     "publish:version": "pnpm changeset version && pnpm format",

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/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,
 		};
 	}
 

package/src/repositories/as-associate.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "vitest";
+import type { Config } from "~src/config";
+import { InMemoryStorage } from "~src/storage";
+import {
+	AsAssociateCartRepository,
+	AsAssociateOrderRepository,
+	AsAssociateQuoteRequestRepository,
+} from "./as-associate";
+import { CustomerRepository } from "./customer";
+
+describe("As Associate Repositories", () => {
+	const storage = new InMemoryStorage();
+	const config: Config = { storage, strict: false };
+
+	test("AsAssociateCartRepository can create and retrieve carts", () => {
+		const repository = new AsAssociateCartRepository(config);
+		const ctx = { projectKey: "test-project" };
+
+		const cartDraft = {
+			currency: "EUR",
+			inventoryMode: "None" as const,
+			taxMode: "Platform" as const,
+			taxRoundingMode: "HalfEven" as const,
+			taxCalculationMode: "UnitPriceLevel" as const,
+		};
+
+		const cart = repository.create(ctx, cartDraft);
+		expect(cart.id).toBeDefined();
+		expect(cart.version).toBe(1);
+		expect(cart.totalPrice.currencyCode).toBe("EUR");
+
+		// Test query
+		const result = repository.query(ctx);
+		expect(result.count).toBe(1);
+		expect(result.results[0].id).toBe(cart.id);
+
+		// Test get
+		const retrieved = repository.get(ctx, cart.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(cart.id);
+	});
+
+	test("AsAssociateOrderRepository can create and retrieve orders", () => {
+		const repository = new AsAssociateOrderRepository(config);
+		const ctx = { projectKey: "test-project" };
+
+		// First create a cart to create an order from
+		const cartRepository = new AsAssociateCartRepository(config);
+		const cartDraft = {
+			currency: "EUR",
+			inventoryMode: "None" as const,
+			taxMode: "Platform" as const,
+			taxRoundingMode: "HalfEven" as const,
+			taxCalculationMode: "UnitPriceLevel" as const,
+		};
+		const cart = cartRepository.create(ctx, cartDraft);
+
+		const orderDraft = {
+			cart: {
+				id: cart.id,
+				typeId: "cart" as const,
+			},
+			version: cart.version,
+		};
+
+		const order = repository.create(ctx, orderDraft);
+		expect(order.id).toBeDefined();
+		expect(order.version).toBe(1);
+		expect(order.cart?.id).toBe(cart.id);
+
+		// Test query
+		const result = repository.query(ctx);
+		expect(result.count).toBe(1);
+		expect(result.results[0].id).toBe(order.id);
+
+		// Test get
+		const retrieved = repository.get(ctx, order.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(order.id);
+	});
+
+	test("AsAssociateQuoteRequestRepository can create and retrieve quote requests", () => {
+		const repository = new AsAssociateQuoteRequestRepository(config);
+		const ctx = { projectKey: "test-project" };
+
+		// Create a customer using the customer repository
+		const customerRepository = new CustomerRepository(config);
+		const customer = customerRepository.create(ctx, {
+			email: "test@example.com",
+			password: "password123",
+			firstName: "John",
+			lastName: "Doe",
+		});
+
+		// First create a cart to create a quote request from
+		const cartRepository = new AsAssociateCartRepository(config);
+		const cartDraft = {
+			currency: "EUR",
+			customerId: customer.id,
+		};
+		const cart = cartRepository.create(ctx, cartDraft);
+
+		const quoteRequestDraft = {
+			cart: {
+				id: cart.id,
+				typeId: "cart" as const,
+			},
+			cartVersion: cart.version,
+		};
+
+		const quoteRequest = repository.create(ctx, quoteRequestDraft);
+		expect(quoteRequest.id).toBeDefined();
+		expect(quoteRequest.version).toBe(1);
+		expect(quoteRequest.cart?.id).toBe(cart.id);
+
+		// Test query
+		const result = repository.query(ctx);
+		expect(result.count).toBe(1);
+		expect(result.results[0].id).toBe(quoteRequest.id);
+
+		// Test get
+		const retrieved = repository.get(ctx, quoteRequest.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(quoteRequest.id);
+	});
+});