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

package/src/repositories/inventory-entry/index.ts

@@ -1,44 +1,52 @@
 import type {
+	ChannelReference,
 	InventoryEntry,
 	InventoryEntryDraft,
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
 import { getBaseResourceProperties } from "#src/helpers.ts";
+import { InventoryEntryDraftSchema } from "#src/schemas/generated/inventory-entry.ts";
 import {
 	AbstractResourceRepository,
 	type RepositoryContext,
 } from "../abstract.ts";
-import { createCustomFields } from "../helpers.ts";
+import {
+	createCustomFields,
+	getReferenceFromResourceIdentifier,
+} from "../helpers.ts";
 import { InventoryEntryUpdateHandler } from "./actions.ts";
 
 export class InventoryEntryRepository extends AbstractResourceRepository<"inventory-entry"> {
 	constructor(config: Config) {
 		super("inventory-entry", config);
 		this.actions = new InventoryEntryUpdateHandler(config.storage);
+		this.draftSchema = InventoryEntryDraftSchema;
 	}
 
-	create(
+	async create(
 		context: RepositoryContext,
 		draft: InventoryEntryDraft,
-	): InventoryEntry {
+	): Promise<InventoryEntry> {
 		const resource: InventoryEntry = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			sku: draft.sku,
 			quantityOnStock: draft.quantityOnStock,
 			availableQuantity: draft.quantityOnStock,
 			expectedDelivery: draft.expectedDelivery,
 			restockableInDays: draft.restockableInDays,
-			supplyChannel: {
-				...draft.supplyChannel,
-				typeId: "channel",
-				id: draft.supplyChannel?.id ?? "",
-			},
-			custom: createCustomFields(
+			supplyChannel: draft.supplyChannel
+				? await getReferenceFromResourceIdentifier<ChannelReference>(
+						draft.supplyChannel,
+						context.projectKey,
+						this._storage,
+					)
+				: undefined,
+			custom: await createCustomFields(
 				draft.custom,
 				context.projectKey,
 				this._storage,
 			),
 		};
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }

package/src/repositories/my-customer.ts

@@ -12,14 +12,14 @@ import type { RepositoryContext } from "./abstract.ts";
 import { CustomerRepository } from "./customer/index.ts";
 
 export class MyCustomerRepository extends CustomerRepository {
-	changePassword(
+	async changePassword(
 		context: RepositoryContext,
 		changePassword: MyCustomerChangePassword,
 	) {
 		const { currentPassword, newPassword } = changePassword;
 		const encodedPassword = hashPassword(currentPassword);
 
-		const result = this._storage.query(context.projectKey, "customer", {
+		const result = await this._storage.query(context.projectKey, "customer", {
 			where: [`password = "${encodedPassword}"`],
 		});
 		if (result.count === 0) {
@@ -41,11 +41,11 @@ export class MyCustomerRepository extends CustomerRepository {
 		customer.version += 1;
 
 		// Update storage
-		this._storage.add(context.projectKey, "customer", customer);
+		await this._storage.add(context.projectKey, "customer", customer);
 		return customer;
 	}
 
-	confirmEmail(
+	async confirmEmail(
 		context: RepositoryContext,
 		resetPassword: MyCustomerEmailVerify,
 	) {
@@ -59,11 +59,11 @@ export class MyCustomerRepository extends CustomerRepository {
 			});
 		}
 
-		const customer = this._storage.get(
+		const customer = (await this._storage.get(
 			context.projectKey,
 			"customer",
 			customerId,
-		) as Writable<Customer> | undefined;
+		)) as Writable<Customer> | undefined;
 
 		if (!customer) {
 			throw new CommercetoolsError<ResourceNotFoundError>({
@@ -76,30 +76,31 @@ export class MyCustomerRepository extends CustomerRepository {
 		customer.version += 1;
 
 		// Update storage
-		this._storage.add(context.projectKey, "customer", customer);
+		await this._storage.add(context.projectKey, "customer", customer);
 		return customer;
 	}
 
-	deleteMe(context: RepositoryContext): Customer | undefined {
+	async deleteMe(context: RepositoryContext): Promise<Customer | undefined> {
 		// grab the first customer you can find for now. In the future we should
 		// use the customer id from the scope of the token
-		const results = this._storage.query(
+		const results = await this._storage.query(
 			context.projectKey,
 			this.getTypeId(),
 			{},
 		);
 
 		if (results.count > 0) {
-			return this.delete(context, results.results[0].id) as Customer;
+			const deleted = await this.delete(context, results.results[0].id);
+			return deleted as Customer;
 		}
 
 		return;
 	}
 
-	getMe(context: RepositoryContext): Customer | undefined {
+	async getMe(context: RepositoryContext): Promise<Customer | undefined> {
 		// grab the first customer you can find for now. In the future we should
 		// use the customer id from the scope of the token
-		const results = this._storage.query(
+		const results = await this._storage.query(
 			context.projectKey,
 			this.getTypeId(),
 			{},

package/src/repositories/my-order.ts

@@ -8,12 +8,15 @@ import type { RepositoryContext } from "./abstract.ts";
 import { OrderRepository } from "./order/index.ts";
 
 export class MyOrderRepository extends OrderRepository {
-	create(context: RepositoryContext, draft: MyOrderFromCartDraft): Order {
+	async create(
+		context: RepositoryContext,
+		draft: MyOrderFromCartDraft,
+	): Promise<Order> {
 		assert(draft.id, "draft.id is missing");
 		const cartIdentifier = {
 			id: draft.id,
 			typeId: "cart",
 		} as CartReference;
-		return this.createFromCart(context, cartIdentifier);
+		return await this.createFromCart(context, cartIdentifier);
 	}
 }

package/src/repositories/order/actions.ts

@@ -2,6 +2,7 @@ import type {
 	CustomLineItemReturnItem,
 	Delivery,
 	GeneralError,
+	InvalidOperationError,
 	LineItemReturnItem,
 	Order,
 	OrderAddDeliveryAction,
@@ -28,6 +29,9 @@ import type {
 	OrderUpdateAction,
 	OrderUpdateSyncInfoAction,
 	Parcel,
+	ReferencedResourceNotFoundError,
+	RequiredFieldError,
+	ResourceNotFoundError,
 	ReturnInfo,
 	State,
 	Store,
@@ -44,17 +48,21 @@ export class OrderUpdateHandler
 	extends AbstractUpdateHandler
 	implements Partial<UpdateHandlerInterface<Order, OrderUpdateAction>>
 {
-	addPayment(
+	async addPayment(
 		context: RepositoryContext,
 		resource: Writable<Order>,
 		{ payment }: OrderAddPaymentAction,
 	) {
-		const resolvedPayment = this._storage.getByResourceIdentifier(
+		const resolvedPayment = await this._storage.getByResourceIdentifier(
 			context.projectKey,
 			payment,
 		);
 		if (!resolvedPayment) {
-			throw new Error(`Payment ${payment.id} not found`);
+			throw new CommercetoolsError<ReferencedResourceNotFoundError>({
+				code: "ReferencedResourceNotFound",
+				message: `Payment ${payment.id} not found`,
+				typeId: "payment",
+			});
 		}
 
 		if (!resource.paymentInfo) {
@@ -69,7 +77,7 @@ export class OrderUpdateHandler
 		});
 	}
 
-	addReturnInfo(
+	async addReturnInfo(
 		context: RepositoryContext,
 		resource: Writable<Order>,
 		info: OrderAddReturnInfoAction,
@@ -78,14 +86,19 @@ export class OrderUpdateHandler
 			resource.returnInfo = [];
 		}
 
-		const resolved: ReturnInfo = {
-			items: info.items.map((item) => {
+		const items = await Promise.all(
+			info.items.map(async (item) => {
 				const common = {
 					...getBaseResourceProperties(),
 					quantity: item.quantity,
 					paymentState: "Initial",
-					shipmentState: "Initial",
+					shipmentState: item.shipmentState ?? "Advised",
 					comment: item.comment,
+					custom: await createCustomFields(
+						item.custom,
+						context.projectKey,
+						this._storage,
+					),
 				};
 				if (item.customLineItemId) {
 					return {
@@ -100,6 +113,10 @@ export class OrderUpdateHandler
 					lineItemId: item.customLineItemId || item.lineItemId,
 				} as LineItemReturnItem;
 			}),
+		);
+
+		const resolved: ReturnInfo = {
+			items,
 			returnTrackingId: info.returnTrackingId,
 			returnDate: info.returnDate,
 		};
@@ -164,61 +181,52 @@ export class OrderUpdateHandler
 		resource: Order,
 		{ name, value }: OrderSetCustomFieldAction,
 	) {
-		if (!resource.custom) {
-			throw new Error("Resource has no custom field");
-		}
-		resource.custom.fields[name] = value;
+		this._setCustomFieldValues(resource, { name, value });
 	}
 
-	setCustomType(
+	async setCustomType(
 		context: RepositoryContext,
 		resource: Writable<Order>,
 		{ type, fields }: OrderSetCustomTypeAction,
 	) {
-		if (!type) {
-			resource.custom = undefined;
-		} else {
-			const resolvedType = this._storage.getByResourceIdentifier(
-				context.projectKey,
-				type,
-			);
-			if (!resolvedType) {
-				throw new Error(`Type ${type} not found`);
-			}
-
-			resource.custom = {
-				type: {
-					typeId: "type",
-					id: resolvedType.id,
-				},
-				fields: fields || {},
-			};
-		}
+		await this._setCustomType(context, resource, { type, fields });
 	}
 
-	addDelivery(
+	async addDelivery(
 		context: RepositoryContext,
 		resource: Writable<Order>,
 		{ action, items, ...deliveryDraft }: OrderAddDeliveryAction,
 	) {
 		if (!resource.shippingInfo) {
-			throw new Error("Resource has no shipping info");
+			throw new CommercetoolsError<InvalidOperationError>({
+				code: "InvalidOperation",
+				message: "Resource has no shipping info",
+			});
 		}
 
 		if (!items) {
-			throw new Error("Delivery items are required");
+			throw new CommercetoolsError<RequiredFieldError>({
+				code: "RequiredField",
+				message: "Delivery items are required",
+				field: "items",
+			});
 		}
 
 		if (!resource.shippingInfo.deliveries) {
 			resource.shippingInfo.deliveries = [];
 		}
 
-		const parcels: Parcel[] =
-			deliveryDraft.parcels?.map((p) => ({
+		const parcels: Parcel[] = await Promise.all(
+			deliveryDraft.parcels?.map(async (p) => ({
 				...getBaseResourceProperties(),
 				...p,
-				custom: createCustomFields(p.custom, context.projectKey, this._storage),
-			})) ?? [];
+				custom: await createCustomFields(
+					p.custom,
+					context.projectKey,
+					this._storage,
+				),
+			})) ?? [],
+		);
 
 		const delivery: Delivery = {
 			...getBaseResourceProperties(),
@@ -230,7 +238,7 @@ export class OrderUpdateHandler
 				context.projectKey,
 				this._storage,
 			),
-			custom: createCustomFields(
+			custom: await createCustomFields(
 				deliveryDraft.custom,
 				context.projectKey,
 				this._storage,
@@ -246,7 +254,10 @@ export class OrderUpdateHandler
 		{ deliveryId, name, value }: OrderSetDeliveryCustomFieldAction,
 	) {
 		if (!resource.shippingInfo) {
-			throw new Error("Resource has no shipping info");
+			throw new CommercetoolsError<InvalidOperationError>({
+				code: "InvalidOperation",
+				message: "Resource has no shipping info",
+			});
 		}
 
 		for (const delivery of resource.shippingInfo.deliveries || []) {
@@ -278,13 +289,16 @@ export class OrderUpdateHandler
 		}
 
 		if (!lineItem.custom) {
-			throw new Error("Resource has no custom field");
+			throw new CommercetoolsError<InvalidOperationError>({
+				code: "InvalidOperation",
+				message: "Resource has no custom field",
+			});
 		}
 
 		lineItem.custom.fields[name] = value;
 	}
 
-	setLineItemCustomType(
+	async setLineItemCustomType(
 		context: RepositoryContext,
 		resource: Writable<Order>,
 		{ lineItemId, lineItemKey, type, fields }: OrderSetLineItemCustomTypeAction,
@@ -308,12 +322,16 @@ export class OrderUpdateHandler
 		if (!type) {
 			lineItem.custom = undefined;
 		} else {
-			const resolvedType = this._storage.getByResourceIdentifier(
+			const resolvedType = await this._storage.getByResourceIdentifier(
 				context.projectKey,
 				type,
 			);
 			if (!resolvedType) {
-				throw new Error(`Type ${type} not found`);
+				throw new CommercetoolsError<ReferencedResourceNotFoundError>({
+					code: "ReferencedResourceNotFound",
+					message: `Type ${type} not found`,
+					typeId: "type",
+				});
 			}
 
 			lineItem.custom = {
@@ -348,7 +366,10 @@ export class OrderUpdateHandler
 		{ parcelId, name, value }: OrderSetParcelCustomFieldAction,
 	) {
 		if (!resource.shippingInfo) {
-			throw new Error("Resource has no shipping info");
+			throw new CommercetoolsError<InvalidOperationError>({
+				code: "InvalidOperation",
+				message: "Resource has no shipping info",
+			});
 		}
 
 		for (const delivery of resource.shippingInfo.deliveries || []) {
@@ -380,18 +401,22 @@ export class OrderUpdateHandler
 		);
 	}
 
-	setStore(
+	async setStore(
 		context: RepositoryContext,
 		resource: Writable<Order>,
 		{ store }: OrderSetStoreAction,
 	) {
 		if (!store) return;
-		const resolvedType = this._storage.getByResourceIdentifier(
+		const resolvedType = await this._storage.getByResourceIdentifier(
 			context.projectKey,
 			store,
 		);
 		if (!resolvedType) {
-			throw new Error(`No store found with key=${store.key}`);
+			throw new CommercetoolsError<ReferencedResourceNotFoundError>({
+				code: "ReferencedResourceNotFound",
+				message: `No store found with key=${store.key}`,
+				typeId: "store",
+			});
 		}
 
 		const storeReference = resolvedType as Store;
@@ -401,19 +426,23 @@ export class OrderUpdateHandler
 		};
 	}
 
-	transitionState(
+	async transitionState(
 		context: RepositoryContext,
 		resource: Writable<Order>,
 		{ state }: OrderTransitionStateAction,
 	) {
-		const resolvedType = this._storage.getByResourceIdentifier(
+		const resolvedType = (await this._storage.getByResourceIdentifier(
 			context.projectKey,
 			state,
-		) as State | null;
+		)) as State | null;
 
 		if (!resolvedType) {
-			throw new Error(
-				`No state found with key=${state.key} or id=${state.key}`,
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: `No state found with key=${state.key} or id=${state.key}`,
+				},
+				404,
 			);
 		}
 
@@ -424,18 +453,22 @@ export class OrderUpdateHandler
 		};
 	}
 
-	updateSyncInfo(
+	async updateSyncInfo(
 		context: RepositoryContext,
 		resource: Writable<Order>,
 		{ channel, externalId, syncedAt }: OrderUpdateSyncInfoAction,
 	) {
 		if (!channel) return;
-		const resolvedType = this._storage.getByResourceIdentifier(
+		const resolvedType = await this._storage.getByResourceIdentifier(
 			context.projectKey,
 			channel,
 		);
 		if (!resolvedType) {
-			throw new Error(`Channel ${channel} not found`);
+			throw new CommercetoolsError<ReferencedResourceNotFoundError>({
+				code: "ReferencedResourceNotFound",
+				message: `Channel ${channel} not found`,
+				typeId: "channel",
+			});
 		}
 
 		const syncData: SyncInfo = {