@labdigital/commercetools-mock 2.50.1 → 2.52.0

package/src/repositories/extension.test.ts

@@ -0,0 +1,306 @@
+import type {
+	Extension,
+	ExtensionChangeDestinationAction,
+	ExtensionChangeTriggersAction,
+	ExtensionDraft,
+	ExtensionSetKeyAction,
+	ExtensionSetTimeoutInMsAction,
+} from "@commercetools/platform-sdk";
+import { describe, expect, test } from "vitest";
+import type { Config } from "~src/config";
+import { InMemoryStorage } from "~src/storage";
+import { ExtensionRepository } from "./extension";
+
+describe("Extension Repository", () => {
+	const storage = new InMemoryStorage();
+	const config: Config = { storage, strict: false };
+	const repository = new ExtensionRepository(config);
+
+	test("create extension with HTTP destination", () => {
+		const draft: ExtensionDraft = {
+			key: "test-extension",
+			timeoutInMs: 2000,
+			destination: {
+				type: "HTTP",
+				url: "https://example.com/webhook",
+				authentication: {
+					type: "AuthorizationHeader",
+					headerValue: "Bearer secret-token",
+				},
+			},
+			triggers: [
+				{
+					resourceTypeId: "cart",
+					actions: ["Create", "Update"],
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.create(ctx, draft);
+
+		expect(result.id).toBeDefined();
+		expect(result.key).toBe(draft.key);
+		expect(result.timeoutInMs).toBe(draft.timeoutInMs);
+		expect(result.destination.type).toBe("HTTP");
+		expect(result.triggers).toEqual(draft.triggers);
+
+		// Test that the extension is stored
+		const items = repository.query(ctx);
+		expect(items.count).toBe(1);
+	});
+
+	test("create extension with AWSLambda destination", () => {
+		const draft: ExtensionDraft = {
+			key: "aws-extension",
+			destination: {
+				type: "AWSLambda",
+				arn: "arn:aws:lambda:us-east-1:123456789012:function:MyFunction",
+				accessKey: "AKIAIOSFODNN7EXAMPLE",
+				accessSecret: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+			},
+			triggers: [
+				{
+					resourceTypeId: "order",
+					actions: ["Create"],
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.create(ctx, draft);
+
+		expect(result.id).toBeDefined();
+		expect(result.key).toBe(draft.key);
+		expect(result.destination.type).toBe("AWSLambda");
+		expect(result.triggers).toEqual(draft.triggers);
+	});
+
+	test("postProcessResource masks HTTP authentication header", () => {
+		const extension: Extension = {
+			id: "test-id",
+			version: 1,
+			createdAt: "2023-01-01T00:00:00Z",
+			lastModifiedAt: "2023-01-01T00:00:00Z",
+			key: "test-extension",
+			destination: {
+				type: "HTTP",
+				url: "https://example.com/webhook",
+				authentication: {
+					type: "AuthorizationHeader",
+					headerValue: "Bearer secret-token",
+				},
+			},
+			triggers: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.postProcessResource(ctx, extension);
+
+		expect(result.destination.type).toBe("HTTP");
+		if (
+			result.destination.type === "HTTP" &&
+			result.destination.authentication?.type === "AuthorizationHeader"
+		) {
+			expect(result.destination.authentication.headerValue).toBe("****");
+		}
+	});
+
+	test("postProcessResource masks AWSLambda access secret", () => {
+		const extension: Extension = {
+			id: "test-id",
+			version: 1,
+			createdAt: "2023-01-01T00:00:00Z",
+			lastModifiedAt: "2023-01-01T00:00:00Z",
+			key: "aws-extension",
+			destination: {
+				type: "AWSLambda",
+				arn: "arn:aws:lambda:us-east-1:123456789012:function:MyFunction",
+				accessKey: "AKIAIOSFODNN7EXAMPLE",
+				accessSecret: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
+			},
+			triggers: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const result = repository.postProcessResource(ctx, extension);
+
+		expect(result.destination.type).toBe("AWSLambda");
+		if (result.destination.type === "AWSLambda") {
+			expect(result.destination.accessSecret).toBe("****");
+		}
+	});
+
+	test("update extension - changeDestination", () => {
+		const draft: ExtensionDraft = {
+			key: "test-extension",
+			destination: {
+				type: "HTTP",
+				url: "https://example.com/webhook",
+			},
+			triggers: [
+				{
+					resourceTypeId: "cart",
+					actions: ["Create"],
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const extension = repository.create(ctx, draft);
+
+		const newDestination = {
+			type: "HTTP" as const,
+			url: "https://new-example.com/webhook",
+		};
+
+		const result = repository.processUpdateActions(
+			ctx,
+			extension,
+			extension.version,
+			[
+				{
+					action: "changeDestination",
+					destination: newDestination,
+				} as ExtensionChangeDestinationAction,
+			],
+		);
+
+		expect((result.destination as any).url).toBe(
+			"https://new-example.com/webhook",
+		);
+		expect(result.version).toBe(extension.version + 1);
+	});
+
+	test("update extension - changeTriggers", () => {
+		const draft: ExtensionDraft = {
+			key: "test-extension",
+			destination: {
+				type: "HTTP",
+				url: "https://example.com/webhook",
+			},
+			triggers: [
+				{
+					resourceTypeId: "cart",
+					actions: ["Create"],
+				},
+			],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const extension = repository.create(ctx, draft);
+
+		const newTriggers = [
+			{
+				resourceTypeId: "order" as const,
+				actions: ["Create" as const, "Update" as const],
+			},
+		];
+
+		const result = repository.processUpdateActions(
+			ctx,
+			extension,
+			extension.version,
+			[
+				{
+					action: "changeTriggers",
+					triggers: newTriggers,
+				} as ExtensionChangeTriggersAction,
+			],
+		);
+
+		expect(result.triggers).toEqual(newTriggers);
+		expect(result.version).toBe(extension.version + 1);
+	});
+
+	test("update extension - setKey", () => {
+		const draft: ExtensionDraft = {
+			key: "test-extension",
+			destination: {
+				type: "HTTP",
+				url: "https://example.com/webhook",
+			},
+			triggers: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const extension = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			extension,
+			extension.version,
+			[
+				{
+					action: "setKey",
+					key: "new-extension-key",
+				} as ExtensionSetKeyAction,
+			],
+		);
+
+		expect(result.key).toBe("new-extension-key");
+		expect(result.version).toBe(extension.version + 1);
+	});
+
+	test("update extension - setTimeoutInMs", () => {
+		const draft: ExtensionDraft = {
+			key: "test-extension",
+			destination: {
+				type: "HTTP",
+				url: "https://example.com/webhook",
+			},
+			triggers: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const extension = repository.create(ctx, draft);
+
+		const result = repository.processUpdateActions(
+			ctx,
+			extension,
+			extension.version,
+			[
+				{
+					action: "setTimeoutInMs",
+					timeoutInMs: 5000,
+				} as ExtensionSetTimeoutInMsAction,
+			],
+		);
+
+		expect(result.timeoutInMs).toBe(5000);
+		expect(result.version).toBe(extension.version + 1);
+	});
+
+	test("get and delete extension", () => {
+		const draft: ExtensionDraft = {
+			key: "test-extension",
+			destination: {
+				type: "HTTP",
+				url: "https://example.com/webhook",
+			},
+			triggers: [],
+		};
+
+		const ctx = { projectKey: "dummy" };
+		const extension = repository.create(ctx, draft);
+
+		// Test get
+		const retrieved = repository.get(ctx, extension.id);
+		expect(retrieved).toBeDefined();
+		expect(retrieved?.id).toBe(extension.id);
+
+		// Test getByKey
+		const retrievedByKey = repository.getByKey(ctx, extension.key!);
+		expect(retrievedByKey).toBeDefined();
+		expect(retrievedByKey?.key).toBe(extension.key);
+
+		// Test delete
+		const deleted = repository.delete(ctx, extension.id);
+		expect(deleted).toBeDefined();
+		expect(deleted?.id).toBe(extension.id);
+
+		// Verify it's deleted
+		const notFound = repository.get(ctx, extension.id);
+		expect(notFound).toBeNull();
+	});
+});

package/src/repositories/index.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "vitest";
+import type { Config } from "~src/config";
+import { InMemoryStorage } from "~src/storage";
+import { createRepositories } from "./index";
+
+describe("Repository Index", () => {
+	const storage = new InMemoryStorage();
+	const config: Config = { storage, strict: false };
+
+	test("createRepositories succeeds", () => {
+		const repositories = createRepositories(config);
+
+		// Test that createRepositories succeeded
+		expect(repositories).toBeDefined();
+		expect(typeof repositories).toBe("object");
+	});
+});

package/src/repositories/product/index.ts

@@ -13,8 +13,9 @@ import type {
 import type { Config } from "~src/config";
 import { CommercetoolsError } from "~src/exceptions";
 import { getBaseResourceProperties } from "~src/helpers";
+import { ReviewStatisticsService } from "~src/lib/review-statistics";
 import { ProductSearch } from "~src/product-search";
-import type { RepositoryContext } from "../abstract";
+import type { GetParams, RepositoryContext } from "../abstract";
 import { AbstractResourceRepository } from "../abstract";
 import { getReferenceFromResourceIdentifier } from "../helpers";
 import { ProductUpdateHandler } from "./actions";
@@ -22,11 +23,13 @@ import { variantFromDraft } from "./helpers";
 
 export class ProductRepository extends AbstractResourceRepository<"product"> {
 	protected _searchService: ProductSearch;
+	protected _reviewStatisticsService: ReviewStatisticsService;
 
 	constructor(config: Config) {
 		super("product", config);
 		this.actions = new ProductUpdateHandler(config.storage);
 		this._searchService = new ProductSearch(config);
+		this._reviewStatisticsService = new ReviewStatisticsService(config.storage);
 	}
 
 	create(context: RepositoryContext, draft: ProductDraft): Product {
@@ -139,6 +142,24 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 		return this.saveNew(context, resource);
 	}
 
+	postProcessResource(
+		context: RepositoryContext,
+		resource: Product,
+		params?: GetParams,
+	): Product {
+		// Add review statistics to the product
+		const reviewStatistics =
+			this._reviewStatisticsService.calculateProductReviewStatistics(
+				context.projectKey,
+				resource.id,
+			);
+
+		return {
+			...resource,
+			reviewRatingStatistics: reviewStatistics,
+		};
+	}
+
 	search(
 		context: RepositoryContext,
 		searchRequest: ProductSearchRequest,

package/src/repositories/product-projection.ts

@@ -53,7 +53,7 @@ export class ProductProjectionRepository extends AbstractResourceRepository<"pro
 			params,
 		);
 		if (resource) {
-			return this._searchService.transform(resource, false);
+			return this._searchService.transform(resource, false, context.projectKey);
 		}
 		return null;
 	}
@@ -61,7 +61,13 @@ export class ProductProjectionRepository extends AbstractResourceRepository<"pro
 	query(context: RepositoryContext, params: ProductProjectionQueryParams = {}) {
 		let resources = this._storage
 			.all(context.projectKey, "product")
-			.map((r) => this._searchService.transform(r, params.staged ?? false))
+			.map((r) =>
+				this._searchService.transform(
+					r,
+					params.staged ?? false,
+					context.projectKey,
+				),
+			)
 			.filter((p) => {
 				if (!(params.staged ?? false)) {
 					return p.published;