@labdigital/commercetools-mock 2.17.1 → 2.18.1

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

@@ -0,0 +1,44 @@
+import type {
+	InventoryEntry,
+	InventoryEntryDraft,
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "~src/helpers";
+import { AbstractStorage } from "~src/storage/abstract";
+import {
+	AbstractResourceRepository,
+	type RepositoryContext,
+} from "../abstract";
+import { createCustomFields } from "../helpers";
+import { InventoryEntryUpdateHandler } from "./actions";
+
+export class InventoryEntryRepository extends AbstractResourceRepository<"inventory-entry"> {
+	constructor(storage: AbstractStorage) {
+		super("inventory-entry", storage);
+		this.actions = new InventoryEntryUpdateHandler(storage);
+	}
+
+	create(
+		context: RepositoryContext,
+		draft: InventoryEntryDraft,
+	): InventoryEntry {
+		const resource: InventoryEntry = {
+			...getBaseResourceProperties(),
+			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(
+				draft.custom,
+				context.projectKey,
+				this._storage,
+			),
+		};
+		return this.saveNew(context, resource);
+	}
+}

package/src/repositories/my-customer.ts

@@ -0,0 +1,114 @@
+import {
+	Customer,
+	InvalidCurrentPasswordError,
+	MyCustomerChangePassword,
+	ResourceNotFoundError,
+	type MyCustomerResetPassword,
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "~src/exceptions";
+import { hashPassword, validatePasswordResetToken } from "../lib/password";
+import { Writable } from "../types";
+import { type RepositoryContext } from "./abstract";
+import { CustomerRepository } from "./customer";
+
+export class MyCustomerRepository extends CustomerRepository {
+	changePassword(
+		context: RepositoryContext,
+		changePassword: MyCustomerChangePassword,
+	) {
+		const { currentPassword, newPassword } = changePassword;
+		const encodedPassword = hashPassword(currentPassword);
+
+		const result = this._storage.query(context.projectKey, "customer", {
+			where: [`password = "${encodedPassword}"`],
+		});
+		if (result.count === 0) {
+			throw new CommercetoolsError<InvalidCurrentPasswordError>({
+				code: "InvalidCurrentPassword",
+				message: "Account with the given credentials not found.",
+			});
+		}
+
+		const customer = result.results[0] as Writable<Customer>;
+		if (customer.password !== hashPassword(currentPassword)) {
+			throw new CommercetoolsError<InvalidCurrentPasswordError>({
+				code: "InvalidCurrentPassword",
+				message: "The current password is invalid.",
+			});
+		}
+
+		customer.password = hashPassword(newPassword);
+		customer.version += 1;
+
+		// Update storage
+		this._storage.add(context.projectKey, "customer", customer);
+		return customer;
+	}
+
+	deleteMe(context: RepositoryContext): 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(
+			context.projectKey,
+			this.getTypeId(),
+			{},
+		);
+
+		if (results.count > 0) {
+			return this.delete(context, results.results[0].id) as Customer;
+		}
+
+		return;
+	}
+
+	getMe(context: RepositoryContext): 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(
+			context.projectKey,
+			this.getTypeId(),
+			{},
+		);
+
+		if (results.count > 0) {
+			return results.results[0] as Customer;
+		}
+
+		return;
+	}
+
+	resetPassword(
+		context: RepositoryContext,
+		resetPassword: MyCustomerResetPassword,
+	) {
+		const { newPassword, tokenValue } = resetPassword;
+
+		const customerId = validatePasswordResetToken(tokenValue);
+		if (!customerId) {
+			throw new CommercetoolsError<ResourceNotFoundError>({
+				code: "ResourceNotFound",
+				message: `The Customer with ID 'Token(${tokenValue})' was not found.`,
+			});
+		}
+
+		const customer = this._storage.get(
+			context.projectKey,
+			"customer",
+			customerId,
+		) as Writable<Customer> | undefined;
+
+		if (!customer) {
+			throw new CommercetoolsError<ResourceNotFoundError>({
+				code: "ResourceNotFound",
+				message: `The Customer with ID 'Token(${tokenValue})' was not found.`,
+			});
+		}
+
+		customer.password = hashPassword(newPassword);
+		customer.version += 1;
+
+		// Update storage
+		this._storage.add(context.projectKey, "customer", customer);
+		return customer;
+	}
+}

package/src/repositories/my-order.ts

@@ -2,18 +2,18 @@ import type {
 	CartReference,
 	MyOrderFromCartDraft,
 	Order,
-} from '@commercetools/platform-sdk'
-import assert from 'assert'
-import { type RepositoryContext } from './abstract.js'
-import { OrderRepository } from './order.js'
+} from "@commercetools/platform-sdk";
+import assert from "assert";
+import { type RepositoryContext } from "./abstract";
+import { OrderRepository } from "./order";
 
 export class MyOrderRepository extends OrderRepository {
 	create(context: RepositoryContext, draft: MyOrderFromCartDraft): Order {
-		assert(draft.id, 'draft.id is missing')
+		assert(draft.id, "draft.id is missing");
 		const cartIdentifier = {
 			id: draft.id,
-			typeId: 'cart',
-		} as CartReference
-		return this.createFromCart(context, cartIdentifier)
+			typeId: "cart",
+		} as CartReference;
+		return this.createFromCart(context, cartIdentifier);
 	}
 }

package/src/repositories/order/actions.ts

@@ -0,0 +1,281 @@
+import type {
+	CustomLineItemReturnItem,
+	LineItemReturnItem,
+	Order,
+	OrderAddPaymentAction,
+	OrderAddReturnInfoAction,
+	OrderChangeOrderStateAction,
+	OrderChangePaymentStateAction,
+	OrderSetBillingAddressAction,
+	OrderSetCustomFieldAction,
+	OrderSetCustomTypeAction,
+	OrderSetCustomerEmailAction,
+	OrderSetLocaleAction,
+	OrderSetOrderNumberAction,
+	OrderSetShippingAddressAction,
+	OrderSetStoreAction,
+	OrderTransitionStateAction,
+	OrderUpdateAction,
+	OrderUpdateSyncInfoAction,
+	ReturnInfo,
+	State,
+	Store,
+	SyncInfo,
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "~src/helpers";
+import type { Writable } from "~src/types";
+import {
+	AbstractUpdateHandler,
+	RepositoryContext,
+	UpdateHandlerInterface,
+} from "../abstract";
+import { createAddress } from "../helpers";
+
+export class OrderUpdateHandler
+	extends AbstractUpdateHandler
+	implements Partial<UpdateHandlerInterface<Order, OrderUpdateAction>>
+{
+	addPayment(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ payment }: OrderAddPaymentAction,
+	) {
+		const resolvedPayment = this._storage.getByResourceIdentifier(
+			context.projectKey,
+			payment,
+		);
+		if (!resolvedPayment) {
+			throw new Error(`Payment ${payment.id} not found`);
+		}
+
+		if (!resource.paymentInfo) {
+			resource.paymentInfo = {
+				payments: [],
+			};
+		}
+
+		resource.paymentInfo.payments.push({
+			typeId: "payment",
+			id: payment.id!,
+		});
+	}
+
+	addReturnInfo(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		info: OrderAddReturnInfoAction,
+	) {
+		if (!resource.returnInfo) {
+			resource.returnInfo = [];
+		}
+
+		const resolved: ReturnInfo = {
+			items: info.items.map((item) => {
+				const common = {
+					...getBaseResourceProperties(),
+					quantity: item.quantity,
+					paymentState: "Initial",
+					shipmentState: "Initial",
+					comment: item.comment,
+				};
+				if (item.customLineItemId) {
+					return {
+						...common,
+						type: "CustomLineItemReturnItem",
+						customLineItemId: item.customLineItemId,
+					} as CustomLineItemReturnItem;
+				}
+				return {
+					...common,
+					type: "LineItemReturnItem",
+					lineItemId: item.customLineItemId || item.lineItemId,
+				} as LineItemReturnItem;
+			}),
+			returnTrackingId: info.returnTrackingId,
+			returnDate: info.returnDate,
+		};
+
+		resource.returnInfo.push(resolved);
+	}
+
+	changeOrderState(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ orderState }: OrderChangeOrderStateAction,
+	) {
+		resource.orderState = orderState;
+	}
+
+	changePaymentState(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ paymentState }: OrderChangePaymentStateAction,
+	) {
+		resource.paymentState = paymentState;
+	}
+
+	setBillingAddress(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ address }: OrderSetBillingAddressAction,
+	) {
+		resource.billingAddress = createAddress(
+			address,
+			context.projectKey,
+			this._storage,
+		);
+	}
+
+	setCustomerEmail(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ email }: OrderSetCustomerEmailAction,
+	) {
+		resource.customerEmail = email;
+	}
+
+	setCustomField(
+		context: RepositoryContext,
+		resource: Order,
+		{ name, value }: OrderSetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			throw new Error("Resource has no custom field");
+		}
+		resource.custom.fields[name] = value;
+	}
+
+	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 || {},
+			};
+		}
+	}
+
+	setLocale(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ locale }: OrderSetLocaleAction,
+	) {
+		resource.locale = locale;
+	}
+
+	setOrderNumber(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ orderNumber }: OrderSetOrderNumberAction,
+	) {
+		resource.orderNumber = orderNumber;
+	}
+
+	setShippingAddress(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ address }: OrderSetShippingAddressAction,
+	) {
+		resource.shippingAddress = createAddress(
+			address,
+			context.projectKey,
+			this._storage,
+		);
+	}
+
+	setStore(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ store }: OrderSetStoreAction,
+	) {
+		if (!store) return;
+		const resolvedType = this._storage.getByResourceIdentifier(
+			context.projectKey,
+			store,
+		);
+		if (!resolvedType) {
+			throw new Error(`No store found with key=${store.key}`);
+		}
+
+		const storeReference = resolvedType as Store;
+		resource.store = {
+			typeId: "store",
+			key: storeReference.key,
+		};
+	}
+
+	transitionState(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ state }: OrderTransitionStateAction,
+	) {
+		const resolvedType = this._storage.getByResourceIdentifier(
+			context.projectKey,
+			state,
+		) as State | null;
+
+		if (!resolvedType) {
+			throw new Error(
+				`No state found with key=${state.key} or id=${state.key}`,
+			);
+		}
+
+		resource.state = {
+			typeId: "state",
+			id: resolvedType.id,
+			obj: { ...resolvedType, key: state.key ?? "" },
+		};
+	}
+
+	updateSyncInfo(
+		context: RepositoryContext,
+		resource: Writable<Order>,
+		{ channel, externalId, syncedAt }: OrderUpdateSyncInfoAction,
+	) {
+		if (!channel) return;
+		const resolvedType = this._storage.getByResourceIdentifier(
+			context.projectKey,
+			channel,
+		);
+		if (!resolvedType) {
+			throw new Error(`Channel ${channel} not found`);
+		}
+
+		const syncData: SyncInfo = {
+			channel: {
+				typeId: "channel",
+				id: resolvedType.id,
+			},
+			externalId,
+			syncedAt: syncedAt ?? new Date().toISOString(),
+		};
+
+		if (!resource.syncInfo?.length) {
+			resource.syncInfo = [syncData];
+		} else {
+			const lastSyncInfo = resource.syncInfo[resource.syncInfo.length - 1];
+			if (
+				lastSyncInfo.channel.id !== syncData.channel.id ||
+				lastSyncInfo.externalId !== syncData.externalId
+			) {
+				resource.syncInfo.push(syncData);
+			}
+		}
+	}
+}