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

package/src/repositories/product/index.ts

@@ -7,6 +7,7 @@ import type {
 	ProductPagedSearchResponse,
 	ProductSearchRequest,
 	ProductTypeReference,
+	RequiredFieldError,
 	StateReference,
 	TaxCategoryReference,
 } from "@commercetools/platform-sdk";
@@ -15,6 +16,7 @@ import { CommercetoolsError } from "#src/exceptions.ts";
 import { getBaseResourceProperties } from "#src/helpers.ts";
 import { ReviewStatisticsService } from "#src/lib/review-statistics.ts";
 import { ProductSearch } from "#src/product-search.ts";
+import { ProductDraftSchema } from "#src/schemas/generated/product.ts";
 import type { GetParams, RepositoryContext } from "../abstract.ts";
 import { AbstractResourceRepository } from "../abstract.ts";
 import { getReferenceFromResourceIdentifier } from "../helpers.ts";
@@ -30,20 +32,32 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 		this.actions = new ProductUpdateHandler(config.storage);
 		this._searchService = new ProductSearch(config);
 		this._reviewStatisticsService = new ReviewStatisticsService(config.storage);
+		this.draftSchema = ProductDraftSchema;
 	}
 
-	create(context: RepositoryContext, draft: ProductDraft): Product {
+	async create(
+		context: RepositoryContext,
+		draft: ProductDraft,
+	): Promise<Product> {
 		if (!draft.masterVariant) {
-			throw new Error("Missing master variant");
+			throw new CommercetoolsError<RequiredFieldError>(
+				{
+					code: "RequiredField",
+					message: "Missing master variant",
+					field: "masterVariant",
+				},
+				400,
+			);
 		}
 
 		let productType: ProductTypeReference | undefined;
 		try {
-			productType = getReferenceFromResourceIdentifier<ProductTypeReference>(
-				draft.productType,
-				context.projectKey,
-				this._storage,
-			);
+			productType =
+				await getReferenceFromResourceIdentifier<ProductTypeReference>(
+					draft.productType,
+					context.projectKey,
+					this._storage,
+				);
 		} catch (err) {
 			if (this.config.strict) {
 				throw err;
@@ -51,7 +65,7 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 
 			// For now accept missing product types (but warn)
 			process.emitWarning(
-				`Error resolving product-type '${draft.productType.id}'. This will be throw an error in later releases.`,
+				`Error resolving product-type '${draft.productType.id}'. This will throw an error in later releases.`,
 			);
 			productType = {
 				typeId: "product-type",
@@ -61,10 +75,10 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 
 		// Resolve Product categories
 		const categoryReferences: CategoryReference[] = [];
-		draft.categories?.forEach((category) => {
+		for (const category of draft.categories ?? []) {
 			if (category) {
 				categoryReferences.push(
-					getReferenceFromResourceIdentifier<CategoryReference>(
+					await getReferenceFromResourceIdentifier<CategoryReference>(
 						category,
 						context.projectKey,
 						this._storage,
@@ -80,13 +94,13 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 					400,
 				);
 			}
-		});
+		}
 
 		// Resolve Tax category
 		let taxCategoryReference: TaxCategoryReference | undefined;
 		if (draft.taxCategory) {
 			taxCategoryReference =
-				getReferenceFromResourceIdentifier<TaxCategoryReference>(
+				await getReferenceFromResourceIdentifier<TaxCategoryReference>(
 					draft.taxCategory,
 					context.projectKey,
 					this._storage,
@@ -97,29 +111,32 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 		let productStateReference: StateReference | undefined;
 		if (draft.state) {
 			productStateReference =
-				getReferenceFromResourceIdentifier<StateReference>(
+				await getReferenceFromResourceIdentifier<StateReference>(
 					draft.state,
 					context.projectKey,
 					this._storage,
 				);
 		}
 
+		const variants = await Promise.all(
+			draft.variants?.map((variant, index) =>
+				variantFromDraft(context, this._storage, index + 2, variant),
+			) ?? [],
+		);
+
 		const productData: ProductData = {
 			name: draft.name,
 			slug: draft.slug,
 			description: draft.description,
 			attributes: draft.attributes ?? [],
 			categories: categoryReferences,
-			masterVariant: variantFromDraft(
+			masterVariant: await variantFromDraft(
 				context,
 				this._storage,
 				1,
 				draft.masterVariant,
 			),
-			variants:
-				draft.variants?.map((variant, index) =>
-					variantFromDraft(context, this._storage, index + 2, variant),
-				) ?? [],
+			variants,
 			metaTitle: draft.metaTitle,
 			metaDescription: draft.metaDescription,
 			metaKeywords: draft.metaKeywords,
@@ -127,7 +144,7 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 		};
 
 		const resource: Product = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			key: draft.key,
 			productType: productType,
 			taxCategory: taxCategoryReference,
@@ -140,17 +157,17 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 			},
 		};
 
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 
-	postProcessResource(
+	async postProcessResource(
 		context: RepositoryContext,
 		resource: Product,
 		params?: GetParams,
-	): Product {
+	): Promise<Product> {
 		// Add review statistics to the product
 		const reviewStatistics =
-			this._reviewStatisticsService.calculateProductReviewStatistics(
+			await this._reviewStatisticsService.calculateProductReviewStatistics(
 				context.projectKey,
 				resource.id,
 			);
@@ -161,10 +178,10 @@ export class ProductRepository extends AbstractResourceRepository<"product"> {
 		};
 	}
 
-	search(
+	async search(
 		context: RepositoryContext,
 		searchRequest: ProductSearchRequest,
-	): ProductPagedSearchResponse {
+	): Promise<ProductPagedSearchResponse> {
 		return this._searchService.search(context.projectKey, searchRequest);
 	}
 }

package/src/repositories/product-discount.ts

@@ -19,6 +19,7 @@ import type {
 	ProductDiscountValueRelative,
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
+import { ProductDiscountDraftSchema } from "#src/schemas/generated/product-discount.ts";
 import { getBaseResourceProperties } from "../helpers.ts";
 import type { Writable } from "../types.ts";
 import type { RepositoryContext, UpdateHandlerInterface } from "./abstract.ts";
@@ -32,14 +33,15 @@ export class ProductDiscountRepository extends AbstractResourceRepository<"produ
 	constructor(config: Config) {
 		super("product-discount", config);
 		this.actions = new ProductDiscountUpdateHandler(this._storage);
+		this.draftSchema = ProductDiscountDraftSchema;
 	}
 
-	create(
+	async create(
 		context: RepositoryContext,
 		draft: ProductDiscountDraft,
-	): ProductDiscount {
+	): Promise<ProductDiscount> {
 		const resource: ProductDiscount = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			key: draft.key,
 			name: draft.name,
 			description: draft.description,
@@ -51,7 +53,7 @@ export class ProductDiscountRepository extends AbstractResourceRepository<"produ
 			validUntil: draft.validUntil,
 			references: [],
 		};
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }
 

package/src/repositories/product-projection.ts

@@ -1,5 +1,6 @@
 import type {
 	InvalidInputError,
+	InvalidOperationError,
 	ProductDraft,
 	ProductProjection,
 	QueryParam,
@@ -37,43 +38,60 @@ export class ProductProjectionRepository extends AbstractResourceRepository<"pro
 		this._searchService = new ProductProjectionSearch(config);
 	}
 
-	create(context: RepositoryContext, draft: ProductDraft): ProductProjection {
-		throw new Error("No valid action");
+	async create(
+		context: RepositoryContext,
+		draft: ProductDraft,
+	): Promise<ProductProjection> {
+		throw new CommercetoolsError<InvalidOperationError>(
+			{
+				code: "InvalidOperation",
+				message: "No valid action",
+			},
+			400,
+		);
 	}
 
-	get(
+	async get(
 		context: RepositoryContext,
 		id: string,
 		params: GetParams = {},
-	): ProductProjection | null {
-		const resource = this._storage.get(
+	): Promise<ProductProjection | null> {
+		const resource = await this._storage.get(
 			context.projectKey,
 			"product",
 			id,
 			params,
 		);
 		if (resource) {
-			return this._searchService.transform(resource, false, context.projectKey);
+			return await this._searchService.transform(
+				resource,
+				false,
+				context.projectKey,
+			);
 		}
 		return null;
 	}
 
-	query(context: RepositoryContext, params: ProductProjectionQueryParams = {}) {
-		let resources = this._storage
-			.all(context.projectKey, "product")
-			.map((r) =>
+	async query(
+		context: RepositoryContext,
+		params: ProductProjectionQueryParams = {},
+	) {
+		const allProducts = await this._storage.all(context.projectKey, "product");
+		let resources = await Promise.all(
+			allProducts.map((r) =>
 				this._searchService.transform(
 					r,
 					params.staged ?? false,
 					context.projectKey,
 				),
-			)
-			.filter((p) => {
-				if (!(params.staged ?? false)) {
-					return p.published;
-				}
-				return true;
-			});
+			),
+		);
+		resources = resources.filter((p) => {
+			if (!(params.staged ?? false)) {
+				return p.published;
+			}
+			return true;
+		});
 
 		// Apply predicates
 		if (params.where) {
@@ -116,8 +134,10 @@ export class ProductProjectionRepository extends AbstractResourceRepository<"pro
 
 		// Expand the resources
 		if (params.expand !== undefined) {
-			resources = resources.map((resource) =>
-				this._storage.expand(context.projectKey, resource, params.expand),
+			resources = await Promise.all(
+				resources.map((resource) =>
+					this._storage.expand(context.projectKey, resource, params.expand),
+				),
 			);
 		}
 
@@ -130,8 +150,8 @@ export class ProductProjectionRepository extends AbstractResourceRepository<"pro
 		const results = resources.slice(offset, offset + limit);
 
 		return {
-			count: totalResults,
-			total: results.length,
+			count: results.length,
+			total: totalResults,
 			offset: offset,
 			limit: limit,
 			results: results,

package/src/repositories/product-selection.ts

@@ -6,7 +6,7 @@ import type {
 	ProductSelectionUpdateAction,
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
-import { createCustomFields } from "#src/repositories/helpers.ts";
+import { ProductSelectionDraftSchema } from "#src/schemas/generated/product-selection.ts";
 import { getBaseResourceProperties } from "../helpers.ts";
 import type { Writable } from "../types.ts";
 import type { RepositoryContext, UpdateHandlerInterface } from "./abstract.ts";
@@ -19,20 +19,21 @@ export class ProductSelectionRepository extends AbstractResourceRepository<"prod
 	constructor(config: Config) {
 		super("product-selection", config);
 		this.actions = new ProductSelectionUpdateHandler(this._storage);
+		this.draftSchema = ProductSelectionDraftSchema;
 	}
 
-	create(
+	async create(
 		context: RepositoryContext,
 		draft: ProductSelectionDraft,
-	): ProductSelection {
+	): Promise<ProductSelection> {
 		const resource: ProductSelection = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			productCount: 0,
 			key: draft.key,
 			name: draft.name,
 			mode: "Individual",
 		};
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }
 
@@ -51,19 +52,11 @@ class ProductSelectionUpdateHandler
 		resource.name = name;
 	}
 
-	setCustomType(
+	async setCustomType(
 		context: RepositoryContext,
 		resource: Writable<ProductSelection>,
 		{ type, fields }: ProductSelectionSetCustomTypeAction,
 	) {
-		if (type) {
-			resource.custom = createCustomFields(
-				{ type, fields },
-				context.projectKey,
-				this._storage,
-			);
-		} else {
-			resource.custom = undefined;
-		}
+		await this._setCustomType(context, resource, { type, fields });
 	}
 }

package/src/repositories/product-tailoring.ts

@@ -1,8 +1,11 @@
 import type {
+	InvalidOperationError,
 	ProductTailoring,
 	ProductTailoringUpdateAction,
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
+import { CommercetoolsError } from "#src/exceptions.ts";
+import { ProductTailoringDraftSchema } from "#src/schemas/generated/product-tailoring.ts";
 import type { RepositoryContext, UpdateHandlerInterface } from "./abstract.ts";
 import {
 	AbstractResourceRepository,
@@ -13,10 +16,20 @@ export class ProductTailoringRepository extends AbstractResourceRepository<"prod
 	constructor(config: Config) {
 		super("product-tailoring", config);
 		this.actions = new ProductTailoringUpdateHandler(this._storage);
+		this.draftSchema = ProductTailoringDraftSchema;
 	}
 
-	create(context: RepositoryContext, draft: any): ProductTailoring {
-		throw new Error("Create method for product-tailoring not implemented.");
+	async create(
+		context: RepositoryContext,
+		draft: any,
+	): Promise<ProductTailoring> {
+		throw new CommercetoolsError<InvalidOperationError>(
+			{
+				code: "InvalidOperation",
+				message: "Create method for product-tailoring not implemented.",
+			},
+			400,
+		);
 	}
 }
 
@@ -28,6 +41,12 @@ class ProductTailoringUpdateHandler
 		>
 {
 	setSlug() {
-		throw new Error("SetSlug method for product-tailoring not implemented.");
+		throw new CommercetoolsError<InvalidOperationError>(
+			{
+				code: "InvalidOperation",
+				message: "SetSlug method for product-tailoring not implemented.",
+			},
+			400,
+		);
 	}
 }

package/src/repositories/product-type.ts

@@ -2,17 +2,23 @@ import type {
 	AttributeDefinition,
 	AttributeDefinitionDraft,
 	AttributeType,
+	InvalidOperationError,
 	ProductType,
 	ProductTypeAddAttributeDefinitionAction,
 	ProductTypeChangeAttributeOrderByNameAction,
+	ProductTypeChangeDescriptionAction,
 	ProductTypeChangeLabelAction,
 	ProductTypeChangeLocalizedEnumValueLabelAction,
+	ProductTypeChangeNameAction,
 	ProductTypeDraft,
 	ProductTypeRemoveAttributeDefinitionAction,
 	ProductTypeRemoveEnumValuesAction,
+	ProductTypeSetKeyAction,
 	ProductTypeUpdateAction,
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
+import { CommercetoolsError } from "#src/exceptions.ts";
+import { ProductTypeDraftSchema } from "#src/schemas/generated/product-type.ts";
 import { getBaseResourceProperties } from "../helpers.ts";
 import type { Writable } from "../types.ts";
 import type { RepositoryContext, UpdateHandlerInterface } from "./abstract.ts";
@@ -25,11 +31,15 @@ export class ProductTypeRepository extends AbstractResourceRepository<"product-t
 	constructor(config: Config) {
 		super("product-type", config);
 		this.actions = new ProductTypeUpdateHandler(config.storage);
+		this.draftSchema = ProductTypeDraftSchema;
 	}
 
-	create(context: RepositoryContext, draft: ProductTypeDraft): ProductType {
+	async create(
+		context: RepositoryContext,
+		draft: ProductTypeDraft,
+	): Promise<ProductType> {
 		const resource: ProductType = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			key: draft.key,
 			name: draft.name,
 			description: draft.description,
@@ -38,7 +48,7 @@ export class ProductTypeRepository extends AbstractResourceRepository<"product-t
 			),
 		};
 
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }
 
@@ -86,7 +96,14 @@ class ProductTypeUpdateHandler
 		attributeNames.forEach((attrName) => {
 			const attr = attrs.get(attrName);
 			if (attr === undefined) {
-				throw new Error("New attr");
+				throw new CommercetoolsError<InvalidOperationError>(
+					{
+						code: "InvalidOperation",
+						message:
+							"Adding new attribute definitions is not fully supported yet",
+					},
+					400,
+				);
 			}
 			result.push(attr);
 
@@ -172,4 +189,28 @@ class ProductTypeUpdateHandler
 			}
 		});
 	}
+
+	setKey(
+		_context: RepositoryContext,
+		resource: Writable<ProductType>,
+		{ key }: ProductTypeSetKeyAction,
+	) {
+		resource.key = key;
+	}
+
+	changeName(
+		_context: RepositoryContext,
+		resource: Writable<ProductType>,
+		{ name }: ProductTypeChangeNameAction,
+	) {
+		resource.name = name;
+	}
+
+	changeDescription(
+		_context: RepositoryContext,
+		resource: Writable<ProductType>,
+		{ description }: ProductTypeChangeDescriptionAction,
+	) {
+		resource.description = description;
+	}
 }

package/src/repositories/project.ts

@@ -1,4 +1,5 @@
 import type {
+	InvalidOperationError,
 	Project,
 	ProjectChangeBusinessUnitSearchStatusAction,
 	ProjectChangeBusinessUnitStatusOnCreationAction,
@@ -21,6 +22,7 @@ import type {
 } from "@commercetools/platform-sdk";
 import type { ProjectSetBusinessUnitAssociateRoleOnCreationAction } from "@commercetools/platform-sdk/dist/declarations/src/generated/models/project";
 import type { Config } from "#src/config.ts";
+import { CommercetoolsError } from "#src/exceptions.ts";
 import { maskSecretValue } from "../lib/masking.ts";
 import type { Writable } from "../types.ts";
 import type { RepositoryContext, UpdateHandlerInterface } from "./abstract.ts";
@@ -32,25 +34,37 @@ export class ProjectRepository extends AbstractRepository<Project> {
 		this.actions = new ProjectUpdateHandler(config.storage);
 	}
 
-	get(context: RepositoryContext): Project | null {
-		const resource = this._storage.getProject(context.projectKey);
-		return this.postProcessResource(context, resource);
+	async get(context: RepositoryContext): Promise<Project | null> {
+		const resource = await this._storage.getProject(context.projectKey);
+		return await this.postProcessResource(context, resource);
 	}
 
-	postProcessResource(context: RepositoryContext, resource: Project): Project {
+	async postProcessResource(
+		context: RepositoryContext,
+		resource: Project | null,
+	): Promise<Project | null> {
 		if (resource) {
 			return maskSecretValue(resource, "externalOAuth.authorizationHeader");
 		}
 		return resource;
 	}
 
-	saveNew(context: RepositoryContext, resource: Writable<Project>) {
+	async saveNew(
+		context: RepositoryContext,
+		resource: Writable<Project>,
+	): Promise<Project> {
 		resource.version = 1;
-		this._storage.saveProject(resource);
+		await this._storage.saveProject(resource);
+		return resource;
 	}
 
-	saveUpdate(context: RepositoryContext, version: number, resource: Project) {
-		this._storage.saveProject(resource);
+	async saveUpdate(
+		context: RepositoryContext,
+		version: number,
+		resource: Project,
+	): Promise<Project> {
+		await this._storage.saveProject(resource);
+		return resource;
 	}
 }
 
@@ -132,7 +146,13 @@ class ProjectUpdateHandler
 		{ status }: ProjectChangeCustomerSearchStatusAction,
 	) {
 		if (!resource.searchIndexing?.customers) {
-			throw new Error("Invalid project state");
+			throw new CommercetoolsError<InvalidOperationError>(
+				{
+					code: "InvalidOperation",
+					message: "Invalid project state",
+				},
+				400,
+			);
 		}
 		resource.searchIndexing.customers.status = status;
 		resource.searchIndexing.customers.lastModifiedAt = new Date().toISOString();
@@ -144,7 +164,13 @@ class ProjectUpdateHandler
 		{ status }: ProjectChangeBusinessUnitSearchStatusAction,
 	) {
 		if (!resource.searchIndexing?.businessUnits) {
-			throw new Error("Invalid project state");
+			throw new CommercetoolsError<InvalidOperationError>(
+				{
+					code: "InvalidOperation",
+					message: "Invalid project state",
+				},
+				400,
+			);
 		}
 		resource.searchIndexing.businessUnits.status = status;
 		resource.searchIndexing.businessUnits.lastModifiedAt =
@@ -197,7 +223,13 @@ class ProjectUpdateHandler
 		{ status }: ProjectChangeOrderSearchStatusAction,
 	) {
 		if (!resource.searchIndexing?.orders) {
-			throw new Error("Invalid project state");
+			throw new CommercetoolsError<InvalidOperationError>(
+				{
+					code: "InvalidOperation",
+					message: "Invalid project state",
+				},
+				400,
+			);
 		}
 		resource.searchIndexing.orders.status = status;
 		resource.searchIndexing.orders.lastModifiedAt = new Date().toISOString();
@@ -210,7 +242,13 @@ class ProjectUpdateHandler
 	) {
 		if (mode === "ProductsSearch") {
 			if (!resource.searchIndexing?.productsSearch) {
-				throw new Error("Invalid project state");
+				throw new CommercetoolsError<InvalidOperationError>(
+					{
+						code: "InvalidOperation",
+						message: "Invalid project state",
+					},
+					400,
+				);
 			}
 			resource.searchIndexing.productsSearch.status = enabled
 				? "Activated"
@@ -221,7 +259,13 @@ class ProjectUpdateHandler
 		}
 
 		if (!resource.searchIndexing?.products) {
-			throw new Error("Invalid project state");
+			throw new CommercetoolsError<InvalidOperationError>(
+				{
+					code: "InvalidOperation",
+					message: "Invalid project state",
+				},
+				400,
+			);
 		}
 		resource.searchIndexing.products.status = enabled
 			? "Activated"