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

package/src/repositories/abstract.ts

@@ -1,12 +1,17 @@
 import { isDeepStrictEqual } from "node:util";
 import type {
 	BaseResource,
+	CustomFields,
+	FieldContainer,
 	InvalidInputError,
+	InvalidOperationError,
 	Project,
 	QueryParam,
 	ResourceNotFoundError,
+	TypeResourceIdentifier,
 	UpdateAction,
 } from "@commercetools/platform-sdk";
+import type { z } from "zod";
 import type { Config } from "#src/config.ts";
 import { CommercetoolsError } from "#src/exceptions.ts";
 import { cloneObject } from "../helpers.ts";
@@ -18,6 +23,7 @@ import type {
 	Writable,
 } from "./../types.ts";
 import { checkConcurrentModification } from "./errors.ts";
+import { createCustomFields } from "./helpers.ts";
 
 export type QueryParams = {
 	expand?: string[];
@@ -36,6 +42,7 @@ export type GetParams = {
 export type RepositoryContext = {
 	projectKey: string;
 	storeKey?: string;
+	clientId?: string;
 };
 
 export abstract class AbstractRepository<R extends BaseResource | Project> {
@@ -50,27 +57,36 @@ export abstract class AbstractRepository<R extends BaseResource | Project> {
 		this._storage = config.storage;
 	}
 
-	abstract saveNew({ projectKey }: RepositoryContext, resource: R): void;
+	async saveNew({ projectKey }: RepositoryContext, resource: R): Promise<R> {
+		throw new Error("Not implemented");
+	}
 
-	abstract saveUpdate(
+	async saveUpdate(
 		{ projectKey }: RepositoryContext,
 		version: number,
 		resource: R,
-	): void;
+	): Promise<R> {
+		throw new Error("Not implemented");
+	}
 
-	abstract postProcessResource(context: RepositoryContext, resource: any): any;
+	async postProcessResource(
+		context: RepositoryContext,
+		resource: any,
+	): Promise<any> {
+		throw new Error("Not implemented");
+	}
 
-	processUpdateActions(
+	async processUpdateActions(
 		context: RepositoryContext,
 		resource: R,
 		version: number,
 		actions: UpdateAction[],
-	): R {
+	): Promise<R> {
 		if (!this.actions) {
 			throw new Error("No actions defined");
 		}
 
-		const updatedResource = this.actions.apply(
+		const updatedResource = await this.actions.apply(
 			context,
 			resource,
 			version,
@@ -80,10 +96,10 @@ export abstract class AbstractRepository<R extends BaseResource | Project> {
 		// If all actions succeeded we write the new version
 		// to the storage.
 		if (resource.version !== updatedResource.version) {
-			this.saveUpdate(context, version, updatedResource);
+			await this.saveUpdate(context, version, updatedResource);
 		}
 
-		const result = this.postProcessResource(context, updatedResource);
+		const result = await this.postProcessResource(context, updatedResource);
 		if (!result) {
 			throw new Error("invalid post process action");
 		}
@@ -96,82 +112,120 @@ export abstract class AbstractResourceRepository<
 > extends AbstractRepository<ResourceMap[T]> {
 	protected _typeId: T;
 
+	/**
+	 * Optional Zod schema for validating creation drafts.
+	 * When set and strict mode is enabled, the service layer will
+	 * validate incoming request bodies against this schema before
+	 * passing them to create().
+	 */
+	draftSchema?: z.ZodType;
+
 	constructor(typeId: T, config: Config) {
 		super(config);
 		this._typeId = typeId;
 	}
 
-	abstract create(context: RepositoryContext, draft: any): ResourceMap[T];
+	/**
+	 * Whether strict validation is enabled.
+	 */
+	get strict(): boolean {
+		return this.config.strict;
+	}
+
+	abstract create(
+		context: RepositoryContext,
+		draft: any,
+	): Promise<ResourceMap[T]>;
 
 	protected getTypeId(): T {
 		return this._typeId;
 	}
 
-	delete(
+	/**
+	 * Apply expand clauses to a resource without re-fetching from storage.
+	 */
+	async expand(
+		context: RepositoryContext,
+		resource: ResourceMap[T],
+		expand: string[] | undefined,
+	): Promise<ResourceMap[T]> {
+		if (!expand || expand.length === 0) {
+			return resource;
+		}
+		return this._storage.expand(context.projectKey, resource, expand);
+	}
+
+	async delete(
 		context: RepositoryContext,
 		id: string,
 		params: GetParams = {},
-	): ResourceMap[T] | null {
-		const resource = this._storage.delete(
+	): Promise<ResourceMap[T] | null> {
+		const resource = await this._storage.delete(
 			context.projectKey,
 			this.getTypeId(),
 			id,
 			params,
 		);
 		return resource
-			? this.postProcessResource(context, resource, params)
+			? await this.postProcessResource(context, resource, params)
 			: null;
 	}
 
-	get(
+	async get(
 		context: RepositoryContext,
 		id: string,
 		params: GetParams = {},
-	): ResourceMap[T] | null {
-		const resource = this._storage.get(
+	): Promise<ResourceMap[T] | null> {
+		const resource = await this._storage.get(
 			context.projectKey,
 			this.getTypeId(),
 			id,
 			params,
 		);
 		return resource
-			? this.postProcessResource(context, resource, params)
+			? await this.postProcessResource(context, resource, params)
 			: null;
 	}
 
-	getByKey(
+	async getByKey(
 		context: RepositoryContext,
 		key: string,
 		params: GetParams = {},
-	): ResourceMap[T] | null {
-		const resource = this._storage.getByKey(
+	): Promise<ResourceMap[T] | null> {
+		const resource = await this._storage.getByKey(
 			context.projectKey,
 			this.getTypeId(),
 			key,
 			params,
 		);
 		return resource
-			? this.postProcessResource(context, resource, params)
+			? await this.postProcessResource(context, resource, params)
 			: null;
 	}
 
-	postProcessResource(
+	async postProcessResource(
 		context: RepositoryContext,
 		resource: ResourceMap[T],
 		params?: GetParams,
-	): ResourceMap[T] {
+	): Promise<ResourceMap[T]> {
 		return resource;
 	}
 
-	query(context: RepositoryContext, params: QueryParams = {}) {
-		const result = this._storage.query(context.projectKey, this.getTypeId(), {
-			...params,
-		});
+	async query(context: RepositoryContext, params: QueryParams = {}) {
+		const result = await this._storage.query(
+			context.projectKey,
+			this.getTypeId(),
+			{
+				...params,
+			},
+		);
 
-		const data = result.results.map((r) =>
-			this.postProcessResource(context, r as ResourceMap[T], {
-				expand: params.expand,
-			}),
+		const data = await Promise.all(
+			result.results.map((r) =>
+				this.postProcessResource(context, r as ResourceMap[T], {
+					expand: params.expand,
+				}),
+			),
 		);
 		return {
 			...result,
@@ -179,25 +233,25 @@ export abstract class AbstractResourceRepository<
 		};
 	}
 
-	saveNew(
+	async saveNew(
 		context: RepositoryContext,
 		resource: ShallowWritable<ResourceMap[T]>,
-	): ResourceMap[T] {
+	): Promise<ResourceMap[T]> {
 		resource.version = 1;
-		return this._storage.add(
+		return await this._storage.add(
 			context.projectKey,
 			this.getTypeId(),
 			resource as any,
 		);
 	}
 
-	saveUpdate(
+	async saveUpdate(
 		context: RepositoryContext,
 		version: number,
 		resource: ShallowWritable<ResourceMap[T]>,
-	) {
+	): Promise<ResourceMap[T]> {
 		// Check if the resource still exists.
-		const current = this._storage.get(
+		const current = await this._storage.get(
 			context.projectKey,
 			this.getTypeId(),
 			resource.id,
@@ -218,10 +272,18 @@ export abstract class AbstractResourceRepository<
 			throw new Error("Internal error: no changes to save");
 		}
 		resource.lastModifiedAt = new Date().toISOString();
+		(resource as any).lastModifiedBy = {
+			clientId: context.clientId ?? "",
+			isPlatformClient: false,
+		};
 
-		this._storage.add(context.projectKey, this.getTypeId(), resource as any);
+		await this._storage.add(
+			context.projectKey,
+			this.getTypeId(),
+			resource as any,
+		);
 
-		return resource;
+		return resource as ResourceMap[T];
 	}
 }
 
@@ -229,7 +291,7 @@ type UpdateActionHandlerMethod<A, T> = (
 	context: RepositoryContext,
 	resource: Writable<A>,
 	action: T,
-) => void;
+) => void | Promise<void>;
 
 export type UpdateHandlerInterface<
 	A extends BaseResource | Project,
@@ -239,19 +301,85 @@ export type UpdateHandlerInterface<
 };
 
 export class AbstractUpdateHandler {
-	constructor(protected _storage: AbstractStorage) {
+	_storage: AbstractStorage;
+	constructor(_storage: AbstractStorage) {
 		if (!_storage) {
 			throw new Error("No storage provided");
 		}
 		this._storage = _storage;
 	}
 
-	apply<R extends BaseResource | Project>(
+	/**
+	 * Shared implementation for setCustomField update actions.
+	 *
+	 * Throws InvalidOperation if the resource has no custom type set.
+	 * When `value` is `null`, the field is removed; otherwise it is set.
+	 */
+	protected _setCustomFieldValues(
+		resource: { custom?: CustomFields },
+		{ name, value }: { name: string; value?: unknown },
+	): void {
+		if (!resource.custom) {
+			throw new CommercetoolsError<InvalidOperationError>(
+				{
+					code: "InvalidOperation",
+					message: "Resource has no custom type",
+				},
+				400,
+			);
+		}
+		if (value === null) {
+			if (!(name in resource.custom.fields)) {
+				throw new CommercetoolsError<InvalidOperationError>(
+					{
+						code: "InvalidOperation",
+						message: `Cannot remove custom field ${name} because it does not exist.`,
+					},
+					400,
+				);
+			}
+			delete resource.custom.fields[name];
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
+
+	/**
+	 * Shared implementation for setCustomType update actions.
+	 *
+	 * When `type` is provided, resolves the type reference and sets the
+	 * custom fields on the resource. When `type` is not provided, removes
+	 * the custom fields entirely.
+	 */
+	protected async _setCustomType(
+		context: RepositoryContext,
+		resource: { custom?: CustomFields },
+		{
+			type,
+			fields,
+		}: { type?: TypeResourceIdentifier; fields?: FieldContainer },
+	): Promise<void> {
+		if (type) {
+			resource.custom = await createCustomFields(
+				{ type, fields },
+				context.projectKey,
+				this._storage,
+			);
+		} else {
+			resource.custom = undefined;
+		}
+	}
+
+	async apply<R extends BaseResource | Project>(
 		context: RepositoryContext,
 		resource: R,
 		version: number,
 		actions: UpdateAction[],
-	): R {
+	): Promise<R> {
+		// We need a separate working copy because the caller (processUpdateActions)
+		// compares resource.version with updatedResource.version to detect changes.
+		// The resource parameter is already a clone from storage, but we still need
+		// two distinct references.
 		const updatedResource = cloneObject(resource) as ShallowWritable<R>;
 		const identifier = (resource as BaseResource).id
 			? (resource as BaseResource).id
@@ -277,13 +405,19 @@ export class AbstractUpdateHandler {
 			const updateFunc = this[action.action].bind(this);
 
 			if (!updateFunc) {
-				throw new Error(
-					`No mock implemented for update action ${action.action}`,
+				throw new CommercetoolsError<InvalidInputError>(
+					{
+						code: "InvalidInput",
+						message: `No mock implemented for update action ${action.action}`,
+					},
+					400,
 				);
 			}
 
-			const beforeUpdate = cloneObject(resource);
-			updateFunc(context, updatedResource, action);
+			// Snapshot the current state before applying the action so we can
+			// detect whether it actually changed anything.
+			const beforeUpdate = cloneObject(updatedResource);
+			await updateFunc(context, updatedResource, action);
 
 			// Check if the object is updated. We need to increase the version of
 			// an object per action which does an actual modification.

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

@@ -14,7 +14,7 @@ describe("As Associate Repositories", () => {
 	const storage = new InMemoryStorage();
 	const config: Config = { storage, strict: false };
 
-	test("AsAssociateCartRepository can create and retrieve carts", () => {
+	test("AsAssociateCartRepository can create and retrieve carts", async () => {
 		const repository = new AsAssociateCartRepository(config);
 		const ctx = { projectKey: "test-project" };
 
@@ -26,23 +26,23 @@ describe("As Associate Repositories", () => {
 			taxCalculationMode: "UnitPriceLevel" as const,
 		};
 
-		const cart = repository.create(ctx, cartDraft);
+		const cart = await 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);
+		const result = await 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);
+		const retrieved = await repository.get(ctx, cart.id);
 		expect(retrieved).toBeDefined();
 		expect(retrieved?.id).toBe(cart.id);
 	});
 
-	test("AsAssociateOrderRepository can create and retrieve orders", () => {
+	test("AsAssociateOrderRepository can create and retrieve orders", async () => {
 		const repository = new AsAssociateOrderRepository(config);
 		const ctx = { projectKey: "test-project" };
 
@@ -55,7 +55,7 @@ describe("As Associate Repositories", () => {
 			taxRoundingMode: "HalfEven" as const,
 			taxCalculationMode: "UnitPriceLevel" as const,
 		};
-		const cart = cartRepository.create(ctx, cartDraft);
+		const cart = await cartRepository.create(ctx, cartDraft);
 
 		const orderDraft = {
 			cart: {
@@ -65,29 +65,29 @@ describe("As Associate Repositories", () => {
 			version: cart.version,
 		};
 
-		const order = repository.create(ctx, orderDraft);
+		const order = await 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);
+		const result = await 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);
+		const retrieved = await repository.get(ctx, order.id);
 		expect(retrieved).toBeDefined();
 		expect(retrieved?.id).toBe(order.id);
 	});
 
-	test("AsAssociateQuoteRequestRepository can create and retrieve quote requests", () => {
+	test("AsAssociateQuoteRequestRepository can create and retrieve quote requests", async () => {
 		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, {
+		const customer = await customerRepository.create(ctx, {
 			email: "test@example.com",
 			password: "password123",
 			firstName: "John",
@@ -100,7 +100,7 @@ describe("As Associate Repositories", () => {
 			currency: "EUR",
 			customerId: customer.id,
 		};
-		const cart = cartRepository.create(ctx, cartDraft);
+		const cart = await cartRepository.create(ctx, cartDraft);
 
 		const quoteRequestDraft = {
 			cart: {
@@ -110,23 +110,23 @@ describe("As Associate Repositories", () => {
 			cartVersion: cart.version,
 		};
 
-		const quoteRequest = repository.create(ctx, quoteRequestDraft);
+		const quoteRequest = await 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);
+		const result = await 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);
+		const retrieved = await repository.get(ctx, quoteRequest.id);
 		expect(retrieved).toBeDefined();
 		expect(retrieved?.id).toBe(quoteRequest.id);
 	});
 
-	test("AsAssociateShoppingListRepository can create and retrieve shopping lists", () => {
+	test("AsAssociateShoppingListRepository can create and retrieve shopping lists", async () => {
 		const repository = new AsAssociateShoppingListRepository(config);
 		const ctx = { projectKey: "test-project" };
 
@@ -134,17 +134,17 @@ describe("As Associate Repositories", () => {
 			name: { "en-US": "My Shopping List" },
 		};
 
-		const shoppingList = repository.create(ctx, shoppingListDraft);
+		const shoppingList = await repository.create(ctx, shoppingListDraft);
 		expect(shoppingList.id).toBeDefined();
 		expect(shoppingList.version).toBe(1);
 
 		// Test query
-		const result = repository.query(ctx);
+		const result = await repository.query(ctx);
 		expect(result.count).toBe(1);
 		expect(result.results[0].id).toBe(shoppingList.id);
 
 		// Test get
-		const retrieved = repository.get(ctx, shoppingList.id);
+		const retrieved = await repository.get(ctx, shoppingList.id);
 		expect(retrieved).toBeDefined();
 		expect(retrieved?.id).toBe(shoppingList.id);
 	});

package/src/repositories/associate-role.ts

@@ -11,6 +11,7 @@ import type {
 	AssociateRoleUpdateAction,
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
+import { AssociateRoleDraftSchema } from "#src/schemas/generated/associate-role.ts";
 import { getBaseResourceProperties } from "../helpers.ts";
 import type { Writable } from "../types.ts";
 import type { UpdateHandlerInterface } from "./abstract.ts";
@@ -25,23 +26,27 @@ export class AssociateRoleRepository extends AbstractResourceRepository<"associa
 	constructor(config: Config) {
 		super("associate-role", config);
 		this.actions = new AssociateRoleUpdateHandler(this._storage);
+		this.draftSchema = AssociateRoleDraftSchema;
 	}
 
-	create(context: RepositoryContext, draft: AssociateRoleDraft): AssociateRole {
+	async create(
+		context: RepositoryContext,
+		draft: AssociateRoleDraft,
+	): Promise<AssociateRole> {
 		const resource: AssociateRole = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			key: draft.key,
 			name: draft.name,
 			buyerAssignable: draft.buyerAssignable || false,
 			permissions: draft.permissions || [],
-			custom: createCustomFields(
+			custom: await createCustomFields(
 				draft.custom,
 				context.projectKey,
 				this._storage,
 			),
 		};
 
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }
 
@@ -95,31 +100,15 @@ class AssociateRoleUpdateHandler
 		resource: Writable<AssociateRole>,
 		{ name, value }: AssociateRoleSetCustomFieldAction,
 	) {
-		if (!resource.custom) {
-			return;
-		}
-
-		if (value === null) {
-			delete resource.custom.fields[name];
-		} else {
-			resource.custom.fields[name] = value;
-		}
+		this._setCustomFieldValues(resource, { name, value });
 	}
 
-	setCustomType(
+	async setCustomType(
 		context: RepositoryContext,
 		resource: Writable<AssociateRole>,
 		{ type, fields }: AssociateRoleSetCustomTypeAction,
 	) {
-		if (type) {
-			resource.custom = createCustomFields(
-				{ type, fields },
-				context.projectKey,
-				this._storage,
-			);
-		} else {
-			resource.custom = undefined;
-		}
+		await this._setCustomType(context, resource, { type, fields });
 	}
 
 	setName(