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

package/src/repositories/payment/actions.ts

@@ -1,5 +1,6 @@
 import type {
 	CustomerReference,
+	InvalidOperationError,
 	Payment,
 	PaymentAddInterfaceInteractionAction,
 	PaymentAddTransactionAction,
@@ -25,11 +26,14 @@ import type {
 	PaymentSetStatusInterfaceTextAction,
 	PaymentSetTransactionCustomFieldAction,
 	PaymentSetTransactionCustomTypeAction,
+	PaymentSetTransactionInterfaceIdAction,
 	PaymentTransitionStateAction,
 	PaymentUpdateAction,
+	ReferencedResourceNotFoundError,
 	State,
 	Transaction,
 } from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "#src/exceptions.ts";
 import type { Writable } from "#src/types.ts";
 import type { RepositoryContext, UpdateHandlerInterface } from "../abstract.ts";
 import { AbstractUpdateHandler } from "../abstract.ts";
@@ -44,24 +48,31 @@ export class PaymentUpdateHandler
 	extends AbstractUpdateHandler
 	implements UpdateHandlerInterface<Payment, PaymentUpdateAction>
 {
-	addInterfaceInteraction(
+	async addInterfaceInteraction(
 		context: RepositoryContext,
 		resource: Writable<Payment>,
 		{ type, fields }: PaymentAddInterfaceInteractionAction,
 	) {
-		resource.interfaceInteractions.push(
-			createCustomFields({ type, fields }, context.projectKey, this._storage)!,
+		const customFields = await createCustomFields(
+			{ type, fields },
+			context.projectKey,
+			this._storage,
 		);
+		resource.interfaceInteractions.push(customFields!);
 	}
 
-	addTransaction(
+	async addTransaction(
 		context: RepositoryContext,
 		resource: Writable<Payment>,
 		{ transaction }: PaymentAddTransactionAction,
 	) {
 		resource.transactions = [
 			...resource.transactions,
-			transactionFromTransactionDraft(context, this._storage, transaction),
+			await transactionFromTransactionDraft(
+				context,
+				this._storage,
+				transaction,
+			),
 		];
 	}
 
@@ -89,6 +100,19 @@ export class PaymentUpdateHandler
 		}
 	}
 
+	setTransactionInterfaceId(
+		_context: RepositoryContext,
+		resource: Writable<Payment>,
+		{ transactionId, interfaceId }: PaymentSetTransactionInterfaceIdAction,
+	) {
+		const transaction = resource.transactions.find(
+			(e: Transaction) => e.id === transactionId,
+		);
+		if (transaction) {
+			transaction.interfaceId = interfaceId;
+		}
+	}
+
 	changeTransactionState(
 		_context: RepositoryContext,
 		resource: Writable<Payment>,
@@ -126,13 +150,13 @@ export class PaymentUpdateHandler
 		resource.customer = undefined;
 	}
 
-	setCustomer(
+	async setCustomer(
 		_context: RepositoryContext,
 		resource: Writable<Payment>,
 		{ customer }: PaymentSetCustomerAction,
 	) {
 		if (customer) {
-			const c = getReferenceFromResourceIdentifier<CustomerReference>(
+			const c = await getReferenceFromResourceIdentifier<CustomerReference>(
 				customer,
 				_context.projectKey,
 				this._storage,
@@ -147,37 +171,15 @@ export class PaymentUpdateHandler
 		resource: Payment,
 		{ name, value }: PaymentSetCustomFieldAction,
 	) {
-		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<Payment>,
 		{ type, fields }: PaymentSetCustomTypeAction,
 	) {
-		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 });
 	}
 
 	setInterfaceId(
@@ -246,14 +248,17 @@ export class PaymentUpdateHandler
 		);
 		if (transaction) {
 			if (!transaction.custom) {
-				throw new Error("Transaction has no custom field");
+				throw new CommercetoolsError<InvalidOperationError>({
+					code: "InvalidOperation",
+					message: "Transaction has no custom field",
+				});
 			}
 
 			transaction.custom.fields[name] = value;
 		}
 	}
 
-	setTransactionCustomType(
+	async setTransactionCustomType(
 		context: RepositoryContext,
 		resource: Writable<Payment>,
 		{ transactionId, type, fields }: PaymentSetTransactionCustomTypeAction,
@@ -265,12 +270,16 @@ export class PaymentUpdateHandler
 			if (!type) {
 				transaction.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",
+					});
 				}
 
 				transaction.custom = {
@@ -284,18 +293,22 @@ export class PaymentUpdateHandler
 		}
 	}
 
-	transitionState(
+	async transitionState(
 		context: RepositoryContext,
 		resource: Writable<Payment>,
 		{ state }: PaymentTransitionStateAction,
 	) {
-		const stateObj = this._storage.getByResourceIdentifier(
+		const stateObj = (await this._storage.getByResourceIdentifier(
 			context.projectKey,
 			state,
-		) as State | null;
+		)) as State | null;
 
 		if (!stateObj) {
-			throw new Error(`State ${state} not found`);
+			throw new CommercetoolsError<ReferencedResourceNotFoundError>({
+				code: "ReferencedResourceNotFound",
+				message: `State ${state} not found`,
+				typeId: "state",
+			});
 		}
 
 		resource.paymentStatus.state = {
@@ -339,13 +352,16 @@ export class PaymentUpdateHandler
 		{ name, value }: PaymentSetMethodInfoCustomFieldAction,
 	) {
 		if (!resource.paymentMethodInfo.custom) {
-			throw new Error("PaymentMethodInfo has no custom field");
+			throw new CommercetoolsError<InvalidOperationError>({
+				code: "InvalidOperation",
+				message: "PaymentMethodInfo has no custom field",
+			});
 		}
 
 		resource.paymentMethodInfo.custom.fields[name] = value;
 	}
 
-	setMethodInfoCustomType(
+	async setMethodInfoCustomType(
 		context: RepositoryContext,
 		resource: Writable<Payment>,
 		{ type, fields }: PaymentSetMethodInfoCustomTypeAction,
@@ -353,12 +369,16 @@ export class PaymentUpdateHandler
 		if (!type) {
 			resource.paymentMethodInfo.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",
+				});
 			}
 
 			resource.paymentMethodInfo.custom = {

package/src/repositories/payment/helpers.ts

@@ -7,14 +7,14 @@ import type { AbstractStorage } from "#src/storage/index.ts";
 import type { RepositoryContext } from "../abstract.ts";
 import { createCentPrecisionMoney, createCustomFields } from "../helpers.ts";
 
-export const transactionFromTransactionDraft = (
+export const transactionFromTransactionDraft = async (
 	context: RepositoryContext,
 	storage: AbstractStorage,
 	draft: TransactionDraft,
-): Transaction => ({
+): Promise<Transaction> => ({
 	...draft,
 	id: uuidv4(),
 	amount: createCentPrecisionMoney(draft.amount),
-	custom: createCustomFields(draft.custom, context.projectKey, storage),
+	custom: await createCustomFields(draft.custom, context.projectKey, storage),
 	state: draft.state ?? "Initial", // Documented as default
 });

package/src/repositories/payment/index.ts

@@ -5,6 +5,7 @@ import type {
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
 import { getBaseResourceProperties } from "#src/helpers.ts";
+import { PaymentDraftSchema } from "#src/schemas/generated/payment.ts";
 import type { RepositoryContext } from "../abstract.ts";
 import { AbstractResourceRepository } from "../abstract.ts";
 import {
@@ -19,11 +20,31 @@ export class PaymentRepository extends AbstractResourceRepository<"payment"> {
 	constructor(config: Config) {
 		super("payment", config);
 		this.actions = new PaymentUpdateHandler(this._storage);
+		this.draftSchema = PaymentDraftSchema;
 	}
 
-	create(context: RepositoryContext, draft: PaymentDraft): Payment {
+	async create(
+		context: RepositoryContext,
+		draft: PaymentDraft,
+	): Promise<Payment> {
+		const transactions = await Promise.all(
+			(draft.transactions || []).map((t) =>
+				transactionFromTransactionDraft(context, this._storage, t),
+			),
+		);
+		const interfaceInteractions = await Promise.all(
+			(draft.interfaceInteractions || []).map(async (interaction) => {
+				const customFields = await createCustomFields(
+					interaction,
+					context.projectKey,
+					this._storage,
+				);
+				return customFields!;
+			}),
+		);
+
 		const resource: Payment = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			key: draft.key,
 			amountPlanned: createCentPrecisionMoney(draft.amountPlanned),
 			paymentMethodInfo: { ...draft.paymentMethodInfo!, custom: undefined },
@@ -31,7 +52,7 @@ export class PaymentRepository extends AbstractResourceRepository<"payment"> {
 				? {
 						...draft.paymentStatus,
 						state: draft.paymentStatus.state
-							? getReferenceFromResourceIdentifier<StateReference>(
+							? await getReferenceFromResourceIdentifier<StateReference>(
 									draft.paymentStatus.state,
 									context.projectKey,
 									this._storage,
@@ -39,20 +60,15 @@ export class PaymentRepository extends AbstractResourceRepository<"payment"> {
 							: undefined,
 					}
 				: {},
-			transactions: (draft.transactions || []).map((t) =>
-				transactionFromTransactionDraft(context, this._storage, t),
-			),
-			interfaceInteractions: (draft.interfaceInteractions || []).map(
-				(interaction) =>
-					createCustomFields(interaction, context.projectKey, this._storage)!,
-			),
-			custom: createCustomFields(
+			transactions,
+			interfaceInteractions,
+			custom: await createCustomFields(
 				draft.custom,
 				context.projectKey,
 				this._storage,
 			),
 		};
 
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }