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

package/src/storage/in-memory.ts

@@ -1,4 +1,3 @@
-import assert from "node:assert";
 import type {
 	AssociateRole,
 	AttributeGroup,
@@ -14,10 +13,8 @@ import type {
 	DiscountGroup,
 	Extension,
 	InvalidInputError,
-	InvalidJsonInputError,
 	InventoryEntry,
 	Order,
-	PagedQueryResponse,
 	Payment,
 	Product,
 	ProductDiscount,
@@ -29,12 +26,8 @@ import type {
 	QuoteRequest,
 	RecurrencePolicy,
 	RecurringOrder,
-	Reference,
-	ReferencedResourceNotFoundError,
-	ResourceIdentifier,
 	ShippingMethod,
 	ShoppingList,
-	ShoppingListLineItem,
 	StagedQuote,
 	State,
 	Store,
@@ -45,16 +38,15 @@ import type {
 } from "@commercetools/platform-sdk";
 import { CommercetoolsError } from "#src/exceptions.ts";
 import { cloneObject } from "../helpers.ts";
-import { parseExpandClause } from "../lib/expandParser.ts";
 import { parseQueryExpression } from "../lib/predicateParser.ts";
 import type {
 	PagedQueryResponseMap,
 	ResourceMap,
 	ResourceType,
-	Writable,
 } from "../types.ts";
 import type { GetParams, ProjectStorage, QueryParams } from "./abstract.ts";
 import { AbstractStorage } from "./abstract.ts";
+import { StorageMap } from "./storage-map.ts";
 
 export class InMemoryStorage extends AbstractStorage {
 	protected resources: {
@@ -65,7 +57,10 @@ export class InMemoryStorage extends AbstractStorage {
 		[projectKey: string]: Project;
 	} = {};
 
-	addProject = (projectKey: string): Project => {
+	// Secondary index for custom objects: projectKey -> "container\0key" -> resource id
+	private _customObjectIndex: Map<string, Map<string, string>> = new Map();
+
+	async addProject(projectKey: string): Promise<Project> {
 		if (!this.projects[projectKey]) {
 			this.projects[projectKey] = {
 				key: projectKey,
@@ -104,222 +99,221 @@ export class InMemoryStorage extends AbstractStorage {
 						status: "Deactivated",
 					},
 				},
+				discounts: {
+					discountCombinationMode: "Stacking",
+				},
 				version: 1,
 			};
 		}
 		return this.projects[projectKey];
-	};
+	}
 
-	saveProject = (project: Project): Project => {
-		this.projects[project.key] = project;
+	async saveProject(project: Project): Promise<Project> {
+		this.projects[project.key] = cloneObject(project);
 		return project;
-	};
-
-	getProject = (projectKey: string): Project => this.addProject(projectKey);
-
-	// Expand resolves a nested reference and injects the object in the given obj
-	public expand = <T>(
-		projectKey: string,
-		obj: T,
-		clause: undefined | string | string[],
-	): T => {
-		if (!clause) return obj;
-		const newObj = cloneObject(obj);
-		if (Array.isArray(clause)) {
-			for (const c of clause) {
-				this._resolveResource(projectKey, newObj, c);
-			}
-		} else {
-			this._resolveResource(projectKey, newObj, clause);
-		}
-		return newObj;
-	};
-
-	private _resolveResource = (projectKey: string, obj: any, expand: string) => {
-		const params = parseExpandClause(expand);
-
-		// 'lineItems[*].variant' on ShoppingList is an exception, these variants are not references
-		if (params.index === "*") {
-			const reference = obj[params.element];
-			if (
-				params.element === "lineItems" &&
-				params.rest?.startsWith("variant") &&
-				reference.every(
-					(item: any) =>
-						item.variant === undefined && item.variantId !== undefined,
-				)
-			) {
-				for (const item of reference as ShoppingListLineItem[]) {
-					this._resolveShoppingListLineItemVariant(projectKey, item);
-				}
-			}
-		}
+	}
 
-		if (!params.index) {
-			const reference = obj[params.element];
-			if (reference === undefined) {
-				return;
-			}
-			this._resolveReference(projectKey, reference, params.rest);
-		} else if (params.index === "*") {
-			const reference = obj[params.element];
-			if (reference === undefined || !Array.isArray(reference)) return;
-			for (const itemRef of reference as Writable<Reference>[]) {
-				this._resolveReference(projectKey, itemRef, params.rest);
-			}
-		} else {
-			const reference = obj[params.element][params.index];
-			if (reference === undefined) return;
-			this._resolveReference(projectKey, reference, params.rest);
-		}
-	};
+	async getProject(projectKey: string): Promise<Project> {
+		await this.addProject(projectKey);
+		return cloneObject(this.projects[projectKey]);
+	}
 
-	private forProjectKey(projectKey: string): ProjectStorage {
-		this.addProject(projectKey);
+	private async forProjectKey(projectKey: string): Promise<ProjectStorage> {
+		await this.addProject(projectKey);
 
 		let projectStorage = this.resources[projectKey];
 		if (!projectStorage) {
 			projectStorage = this.resources[projectKey] = {
-				"associate-role": new Map<string, AssociateRole>(),
-				"attribute-group": new Map<string, AttributeGroup>(),
-				"business-unit": new Map<string, BusinessUnit>(),
-				cart: new Map<string, Cart>(),
-				"cart-discount": new Map<string, CartDiscount>(),
-				category: new Map<string, Category>(),
-				channel: new Map<string, Channel>(),
-				customer: new Map<string, Customer>(),
-				"customer-group": new Map<string, CustomerGroup>(),
-				"discount-code": new Map<string, DiscountCode>(),
-				"discount-group": new Map<string, DiscountGroup>(),
-				extension: new Map<string, Extension>(),
-				"inventory-entry": new Map<string, InventoryEntry>(),
-				"key-value-document": new Map<string, CustomObject>(),
-				order: new Map<string, Order>(),
-				"order-edit": new Map<string, any>(),
-				payment: new Map<string, Payment>(),
-				product: new Map<string, Product>(),
-				quote: new Map<string, Quote>(),
-				"quote-request": new Map<string, QuoteRequest>(),
-				"product-discount": new Map<string, ProductDiscount>(),
-				"product-selection": new Map<string, any>(),
-				"product-type": new Map<string, ProductType>(),
-				"product-projection": new Map<string, ProductProjection>(),
-				"product-tailoring": new Map<string, ProductTailoring>(),
-				"recurrence-policy": new Map<string, RecurrencePolicy>(),
-				"recurring-order": new Map<string, RecurringOrder>(),
-				review: new Map<string, any>(),
-				"shipping-method": new Map<string, ShippingMethod>(),
-				"staged-quote": new Map<string, StagedQuote>(),
-				state: new Map<string, State>(),
-				store: new Map<string, Store>(),
-				"shopping-list": new Map<string, ShoppingList>(),
-				"standalone-price": new Map<string, any>(),
-				subscription: new Map<string, Subscription>(),
-				"tax-category": new Map<string, TaxCategory>(),
-				type: new Map<string, Type>(),
-				zone: new Map<string, Zone>(),
+				"associate-role": new StorageMap<string, AssociateRole>(),
+				"attribute-group": new StorageMap<string, AttributeGroup>(),
+				"business-unit": new StorageMap<string, BusinessUnit>(),
+				cart: new StorageMap<string, Cart>(),
+				"cart-discount": new StorageMap<string, CartDiscount>(),
+				category: new StorageMap<string, Category>(),
+				channel: new StorageMap<string, Channel>(),
+				customer: new StorageMap<string, Customer>(),
+				"customer-group": new StorageMap<string, CustomerGroup>(),
+				"discount-code": new StorageMap<string, DiscountCode>(),
+				"discount-group": new StorageMap<string, DiscountGroup>(),
+				extension: new StorageMap<string, Extension>(),
+				"inventory-entry": new StorageMap<string, InventoryEntry>(),
+				"key-value-document": new StorageMap<string, CustomObject>(),
+				order: new StorageMap<string, Order>(),
+				"order-edit": new StorageMap<string, any>(),
+				payment: new StorageMap<string, Payment>(),
+				product: new StorageMap<string, Product>(),
+				quote: new StorageMap<string, Quote>(),
+				"quote-request": new StorageMap<string, QuoteRequest>(),
+				"product-discount": new StorageMap<string, ProductDiscount>(),
+				"product-selection": new StorageMap<string, any>(),
+				"product-type": new StorageMap<string, ProductType>(),
+				"product-projection": new StorageMap<string, ProductProjection>(),
+				"product-tailoring": new StorageMap<string, ProductTailoring>(),
+				"recurrence-policy": new StorageMap<string, RecurrencePolicy>(),
+				"recurring-order": new StorageMap<string, RecurringOrder>(),
+				review: new StorageMap<string, any>(),
+				"shipping-method": new StorageMap<string, ShippingMethod>(),
+				"staged-quote": new StorageMap<string, StagedQuote>(),
+				state: new StorageMap<string, State>(),
+				store: new StorageMap<string, Store>(),
+				"shopping-list": new StorageMap<string, ShoppingList>(),
+				"standalone-price": new StorageMap<string, any>(),
+				subscription: new StorageMap<string, Subscription>(),
+				"tax-category": new StorageMap<string, TaxCategory>(),
+				type: new StorageMap<string, Type>(),
+				zone: new StorageMap<string, Zone>(),
 			};
 		}
 		return projectStorage;
 	}
 
-	clear() {
+	async clear(): Promise<void> {
 		for (const [, projectStorage] of Object.entries(this.resources)) {
 			for (const [, value] of Object.entries(projectStorage)) {
 				value?.clear();
 			}
 		}
+		this._customObjectIndex.clear();
 	}
 
-	all<RT extends ResourceType>(
+	async all<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
-	): ResourceMap[RT][] {
-		const store = this.forProjectKey(projectKey)[typeId];
+	): Promise<ResourceMap[RT][]> {
+		const projectStorage = await this.forProjectKey(projectKey);
+		const store = projectStorage[typeId];
 		if (store) {
-			return Array.from(store.values()).map(cloneObject) as ResourceMap[RT][];
+			// StorageMap.values() already returns cloned values
+			return Array.from(store.values()) as ResourceMap[RT][];
 		}
 		return [];
 	}
 
-	add<RT extends ResourceType>(
+	async count(projectKey: string, typeId: ResourceType): Promise<number> {
+		const projectStorage = await this.forProjectKey(projectKey);
+		const store = projectStorage[typeId];
+		return store ? store.size : 0;
+	}
+
+	async add<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
 		obj: ResourceMap[RT],
 		params: GetParams = {},
-	): ResourceMap[RT] {
-		const store = this.forProjectKey(projectKey);
+	): Promise<ResourceMap[RT]> {
+		const store = await this.forProjectKey(projectKey);
+		// StorageMap.set() clones the value before storing
 		store[typeId]?.set(obj.id, obj);
 
-		const resource = this.get(projectKey, typeId, obj.id, params);
-		assert(
-			resource,
-			`resource of type ${typeId} with id ${obj.id} not created`,
-		);
-		return cloneObject(resource);
+		// Maintain secondary index for custom objects
+		if (typeId === "key-value-document") {
+			const co = obj as unknown as CustomObject;
+			let projectIndex = this._customObjectIndex.get(projectKey);
+			if (!projectIndex) {
+				projectIndex = new Map();
+				this._customObjectIndex.set(projectKey, projectIndex);
+			}
+			projectIndex.set(`${co.container}\0${co.key}`, co.id);
+		}
+
+		// StorageMap.get() returns a clone, so we get a fresh copy for expand
+		const clone = store[typeId]?.get(obj.id) as ResourceMap[RT];
+		return this.expand(projectKey, clone, params.expand);
 	}
 
-	get<RT extends ResourceType>(
+	async get<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
 		id: string,
 		params: GetParams = {},
-	): ResourceMap[RT] | null {
-		const resource = this.forProjectKey(projectKey)[typeId]?.get(id);
+	): Promise<ResourceMap[RT] | null> {
+		const projectStorage = await this.forProjectKey(projectKey);
+		// StorageMap.get() already returns a clone
+		const resource = projectStorage[typeId]?.get(id);
 		if (resource) {
-			const clone = cloneObject(resource);
-			return this.expand(projectKey, clone, params.expand) as ResourceMap[RT];
+			const expanded = await this.expand(projectKey, resource, params.expand);
+			return expanded as ResourceMap[RT];
 		}
 		return null;
 	}
 
-	getByKey<RT extends ResourceType>(
+	async getByKey<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
 		key: string,
 		params: GetParams = {},
-	): ResourceMap[RT] | null {
-		const store = this.forProjectKey(projectKey);
-		const resourceStore = store[typeId];
+	): Promise<ResourceMap[RT] | null> {
+		const store = await this.forProjectKey(projectKey);
 		if (!store) {
 			throw new Error("No type");
 		}
+		const resourceStore = store[typeId];
 
+		// StorageMap.values() already returns cloned values
 		const resources: any[] = Array.from(resourceStore.values());
 		const resource = resources.find((e) => e.key === key);
 		if (resource) {
-			const clone = cloneObject(resource);
-			return this.expand(projectKey, clone, params.expand) as ResourceMap[RT];
+			const expanded = await this.expand(projectKey, resource, params.expand);
+			return expanded as ResourceMap[RT];
 		}
 		return null;
 	}
 
-	delete<RT extends ResourceType>(
+	async delete<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
 		id: string,
 		params: GetParams = {},
-	): ResourceMap[RT] | null {
-		const resource = this.get(projectKey, typeId, id);
+	): Promise<ResourceMap[RT] | null> {
+		const resource = await this.get(projectKey, typeId, id);
 
 		if (resource) {
-			this.forProjectKey(projectKey)[typeId]?.delete(id);
+			const projectStorage = await this.forProjectKey(projectKey);
+			projectStorage[typeId]?.delete(id);
+
+			// Remove from secondary index for custom objects
+			if (typeId === "key-value-document") {
+				const co = resource as unknown as CustomObject;
+				this._customObjectIndex
+					.get(projectKey)
+					?.delete(`${co.container}\0${co.key}`);
+			}
+
 			return this.expand(projectKey, resource, params.expand);
 		}
 		return resource;
 	}
 
-	query<RT extends ResourceType>(
+	async getByContainerAndKey(
+		projectKey: string,
+		container: string,
+		key: string,
+	): Promise<CustomObject | null> {
+		const projectIndex = this._customObjectIndex.get(projectKey);
+		if (!projectIndex) {
+			return null;
+		}
+		const id = projectIndex.get(`${container}\0${key}`);
+		if (!id) {
+			return null;
+		}
+		const resource = await this.get(projectKey, "key-value-document", id);
+		return resource as CustomObject | null;
+	}
+
+	async query<RT extends ResourceType>(
 		projectKey: string,
 		typeId: RT,
 		params: QueryParams,
-	): PagedQueryResponseMap[RT] {
-		const store = this.forProjectKey(projectKey)[typeId];
+	): Promise<PagedQueryResponseMap[RT]> {
+		const projectStorage = await this.forProjectKey(projectKey);
+		const store = projectStorage[typeId];
 		if (!store) {
 			throw new Error("No type");
 		}
 
-		let resources = this.all<RT>(projectKey, typeId);
+		// all() already returns cloned values via StorageMap
+		let resources = await this.all<RT>(projectKey, typeId);
 
 		// Apply predicates
 		if (params.where) {
@@ -355,157 +349,20 @@ export class InMemoryStorage extends AbstractStorage {
 
 		// Expand the resources
 		if (params.expand !== undefined) {
-			resources = resources.map((resource) =>
-				this.expand(projectKey, resource, params.expand),
+			resources = await Promise.all(
+				resources.map((resource) =>
+					this.expand(projectKey, resource, params.expand),
+				),
 			);
 		}
 
 		return {
-			count: totalResources,
-			total: resources.length,
-			offset: offset,
-			limit: limit,
-			results: resources.map(cloneObject),
-		} as PagedQueryResponseMap[RT];
-	}
-
-	search(
-		projectKey: string,
-		typeId: ResourceType,
-		params: QueryParams,
-	): PagedQueryResponse {
-		let resources = this.all(projectKey, typeId);
-
-		// Apply predicates
-		if (params.where) {
-			try {
-				const filterFunc = parseQueryExpression(params.where);
-				resources = resources.filter((resource) => filterFunc(resource, {}));
-			} catch (err) {
-				throw new CommercetoolsError<InvalidInputError>(
-					{
-						code: "InvalidInput",
-						message: (err as any).message,
-					},
-					400,
-				);
-			}
-		}
-
-		// Get the total before slicing the array
-		const totalResources = resources.length;
-
-		// Apply offset, limit
-		const offset = params.offset || 0;
-		const limit = params.limit || 20;
-		resources = resources.slice(offset, offset + limit);
-
-		// Expand the resources
-		if (params.expand !== undefined) {
-			resources = resources.map((resource) =>
-				this.expand(projectKey, resource, params.expand),
-			);
-		}
-
-		return {
-			count: totalResources,
-			total: resources.length,
+			count: resources.length,
+			total: totalResources,
 			offset: offset,
 			limit: limit,
+			// Resources are already clones from StorageMap
 			results: resources,
-		};
-	}
-
-	getByResourceIdentifier<RT extends ResourceType>(
-		projectKey: string,
-		identifier: ResourceIdentifier,
-	): ResourceMap[RT] {
-		if (identifier.id) {
-			const resource = this.get(projectKey, identifier.typeId, identifier.id);
-			if (resource) {
-				return resource as ResourceMap[RT];
-			}
-
-			throw new CommercetoolsError<ReferencedResourceNotFoundError>({
-				code: "ReferencedResourceNotFound",
-				message: `The referenced object of type '${identifier.typeId}' with id '${identifier.id}' was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
-				typeId: identifier.typeId,
-				id: identifier.id,
-			});
-		}
-
-		if (identifier.key) {
-			const resource = this.getByKey(
-				projectKey,
-				identifier.typeId,
-				identifier.key,
-			);
-			if (resource) {
-				return resource as ResourceMap[RT];
-			}
-
-			throw new CommercetoolsError<ReferencedResourceNotFoundError>({
-				code: "ReferencedResourceNotFound",
-				message: `The referenced object of type '${identifier.typeId}' with key '${identifier.key}' was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
-				typeId: identifier.typeId,
-				key: identifier.key,
-			});
-		}
-		throw new CommercetoolsError<InvalidJsonInputError>({
-			code: "InvalidJsonInput",
-			message: "Request body does not contain valid JSON.",
-			detailedErrorMessage: "ResourceIdentifier requires an 'id' xor a 'key'",
-		});
-	}
-
-	private _resolveReference(
-		projectKey: string,
-		reference: any,
-		expand: string | undefined,
-	) {
-		if (reference === undefined) return;
-
-		if (
-			reference.typeId !== undefined &&
-			(reference.id !== undefined || reference.key !== undefined)
-		) {
-			// First check if the object is already resolved. This is the case when
-			// the complete resource is pushed via the .add() method.
-			if (!reference.obj) {
-				reference.obj = this.getByResourceIdentifier(projectKey, {
-					typeId: reference.typeId,
-					id: reference.id,
-					key: reference.key,
-				} as ResourceIdentifier);
-			}
-			if (expand) {
-				this._resolveResource(projectKey, reference.obj, expand);
-			}
-		} else {
-			if (expand) {
-				this._resolveResource(projectKey, reference, expand);
-			}
-		}
-	}
-
-	private _resolveShoppingListLineItemVariant(
-		projectKey: string,
-		lineItem: ShoppingListLineItem,
-	) {
-		const product = this.getByResourceIdentifier(projectKey, {
-			typeId: "product",
-			id: lineItem.productId,
-		}) as Product | undefined;
-
-		if (!product) {
-			return;
-		}
-
-		const variant = [
-			product.masterData.current.masterVariant,
-			...product.masterData.current.variants,
-		].find((e) => e.id === lineItem.variantId);
-		// @ts-expect-error
-		lineItem.variant = variant;
+		} as PagedQueryResponseMap[RT];
 	}
 }