@labdigital/commercetools-mock 2.17.1 → 2.18.0

package/src/repositories/channel.ts

@@ -9,18 +9,22 @@ import type {
 	ChannelSetCustomTypeAction,
 	ChannelSetGeoLocationAction,
 	ChannelUpdateAction,
-} from '@commercetools/platform-sdk'
-import { getBaseResourceProperties } from '../helpers.js'
-import type { Writable } from '../types.js'
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "../helpers";
+import { AbstractStorage } from "../storage/abstract";
+import type { Writable } from "../types";
 import {
 	AbstractResourceRepository,
+	AbstractUpdateHandler,
+	UpdateHandlerInterface,
 	type RepositoryContext,
-} from './abstract.js'
-import { createAddress, createCustomFields } from './helpers.js'
+} from "./abstract";
+import { createAddress, createCustomFields } from "./helpers";
 
-export class ChannelRepository extends AbstractResourceRepository<'channel'> {
-	getTypeId() {
-		return 'channel' as const
+export class ChannelRepository extends AbstractResourceRepository<"channel"> {
+	constructor(storage: AbstractStorage) {
+		super("channel", storage);
+		this.actions = new ChannelUpdateHandler(this._storage);
 	}
 
 	create(context: RepositoryContext, draft: ChannelDraft): Channel {
@@ -35,95 +39,89 @@ export class ChannelRepository extends AbstractResourceRepository<'channel'> {
 			custom: createCustomFields(
 				draft.custom,
 				context.projectKey,
-				this._storage
+				this._storage,
 			),
-		}
-		this.saveNew(context, resource)
-		return resource
+		};
+		return this.saveNew(context, resource);
 	}
+}
 
-	actions: Partial<
-		Record<
-			ChannelUpdateAction['action'],
-			(
-				context: RepositoryContext,
-				resource: Writable<Channel>,
-				action: any
-			) => void
-		>
-	> = {
-		changeKey: (
-			context: RepositoryContext,
-			resource: Writable<Channel>,
-			{ key }: ChannelChangeKeyAction
-		) => {
-			resource.key = key
-		},
+class ChannelUpdateHandler
+	extends AbstractUpdateHandler
+	implements Partial<UpdateHandlerInterface<Channel, ChannelUpdateAction>>
+{
+	changeDescription(
+		context: RepositoryContext,
+		resource: Writable<Channel>,
+		{ description }: ChannelChangeDescriptionAction,
+	) {
+		resource.description = description;
+	}
 
-		changeName: (
-			context: RepositoryContext,
-			resource: Writable<Channel>,
-			{ name }: ChannelChangeNameAction
-		) => {
-			resource.name = name
-		},
+	changeKey(
+		context: RepositoryContext,
+		resource: Writable<Channel>,
+		{ key }: ChannelChangeKeyAction,
+	) {
+		resource.key = key;
+	}
 
-		changeDescription: (
-			context: RepositoryContext,
-			resource: Writable<Channel>,
-			{ description }: ChannelChangeDescriptionAction
-		) => {
-			resource.description = description
-		},
+	changeName(
+		context: RepositoryContext,
+		resource: Writable<Channel>,
+		{ name }: ChannelChangeNameAction,
+	) {
+		resource.name = name;
+	}
 
-		setAddress: (
-			context: RepositoryContext,
-			resource: Writable<Channel>,
-			{ address }: ChannelSetAddressAction
-		) => {
-			resource.address = createAddress(
-				address,
-				context.projectKey,
-				this._storage
-			)
-		},
+	setAddress(
+		context: RepositoryContext,
+		resource: Writable<Channel>,
+		{ address }: ChannelSetAddressAction,
+	) {
+		resource.address = createAddress(
+			address,
+			context.projectKey,
+			this._storage,
+		);
+	}
 
-		setGeoLocation: (
-			context: RepositoryContext,
-			resource: Writable<Channel>,
-			{ geoLocation }: ChannelSetGeoLocationAction
-		) => {
-			resource.geoLocation = geoLocation
-		},
+	setCustomField(
+		context: RepositoryContext,
+		resource: Writable<Channel>,
+		{ name, value }: ChannelSetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			return;
+		}
+		if (value === null) {
+			delete resource.custom.fields[name];
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
+
+	setCustomType(
+		context: RepositoryContext,
+		resource: Writable<Channel>,
+		{ type, fields }: ChannelSetCustomTypeAction,
+	) {
+		if (type) {
+			resource.custom = createCustomFields(
+				{ type, fields },
+				context.projectKey,
+				this._storage,
+			);
+		} else {
+			resource.custom = undefined;
+		}
+	}
 
-		setCustomType: (
-			context: RepositoryContext,
-			resource: Writable<Channel>,
-			{ type, fields }: ChannelSetCustomTypeAction
-		) => {
-			if (type) {
-				resource.custom = createCustomFields(
-					{ type, fields },
-					context.projectKey,
-					this._storage
-				)
-			} else {
-				resource.custom = undefined
-			}
-		},
-		setCustomField: (
-			context: RepositoryContext,
-			resource: Writable<Channel>,
-			{ name, value }: ChannelSetCustomFieldAction
-		) => {
-			if (!resource.custom) {
-				return
-			}
-			if (value === null) {
-				delete resource.custom.fields[name]
-			} else {
-				resource.custom.fields[name] = value
-			}
-		},
+	setGeoLocation(
+		context: RepositoryContext,
+		resource: Writable<Channel>,
+		{ geoLocation }: ChannelSetGeoLocationAction,
+	) {
+		resource.geoLocation = geoLocation;
 	}
 }

package/src/repositories/custom-object.ts

@@ -2,97 +2,98 @@ import type {
 	CustomObject,
 	CustomObjectDraft,
 	InvalidOperationError,
-} from '@commercetools/platform-sdk'
-import { CommercetoolsError } from '../exceptions.js'
-import { cloneObject, getBaseResourceProperties } from '../helpers.js'
-import type { Writable } from '../types.js'
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "~src/exceptions";
+import { AbstractStorage } from "~src/storage";
+import { cloneObject, getBaseResourceProperties } from "../helpers";
+import type { Writable } from "../types";
 import {
 	AbstractResourceRepository,
 	QueryParams,
 	type RepositoryContext,
-} from './abstract.js'
-import { checkConcurrentModification } from './errors.js'
+} from "./abstract";
+import { checkConcurrentModification } from "./errors";
 
-export class CustomObjectRepository extends AbstractResourceRepository<'key-value-document'> {
-	getTypeId() {
-		return 'key-value-document' as const
+export class CustomObjectRepository extends AbstractResourceRepository<"key-value-document"> {
+	constructor(storage: AbstractStorage) {
+		super("key-value-document", storage);
 	}
 
 	create(
 		context: RepositoryContext,
-		draft: Writable<CustomObjectDraft>
+		draft: Writable<CustomObjectDraft>,
 	): CustomObject {
 		const current = this.getWithContainerAndKey(
 			context,
 			draft.container,
-			draft.key
-		) as Writable<CustomObject | undefined>
+			draft.key,
+		) as Writable<CustomObject | undefined>;
 
 		if (current) {
 			// Only check version if it is passed in the draft
 			if (draft.version) {
-				checkConcurrentModification(current.version, draft.version, current.id)
+				checkConcurrentModification(current.version, draft.version, current.id);
 			} else {
-				draft.version = current.version
+				draft.version = current.version;
 			}
 
 			if (draft.value !== current.value) {
-				const updated = cloneObject(current) as Writable<CustomObject>
-				updated.value = draft.value
-				updated.version += 1
-				this.saveUpdate(context, draft.version, updated)
-				return updated
+				const updated = cloneObject(current) as Writable<CustomObject>;
+				updated.value = draft.value;
+				updated.version += 1;
+				this.saveUpdate(context, draft.version, updated);
+				return updated;
 			}
-			return current
+			return current;
 		} else {
 			// If the resource is new the only valid version is 0
 			if (draft.version) {
 				throw new CommercetoolsError<InvalidOperationError>(
 					{
-						code: 'InvalidOperation',
-						message: 'version on create must be 0',
+						code: "InvalidOperation",
+						message: "version on create must be 0",
 					},
-					400
-				)
+					400,
+				);
 			}
-			const baseProperties = getBaseResourceProperties()
+			const baseProperties = getBaseResourceProperties();
 			const resource: CustomObject = {
 				...baseProperties,
 				container: draft.container,
 				key: draft.key,
 				value: draft.value,
-			}
+			};
 
-			this.saveNew(context, resource)
-			return resource
+			this.saveNew(context, resource);
+			return resource;
 		}
 	}
 
+	getWithContainerAndKey(
+		context: RepositoryContext,
+		container: string,
+		key: string,
+	) {
+		const items = this._storage.all(context.projectKey, this.getTypeId());
+		return items.find(
+			(item) => item.container === container && item.key === key,
+		);
+	}
+
 	queryWithContainer(
 		context: RepositoryContext,
 		container: string,
-		params: QueryParams = {}
+		params: QueryParams = {},
 	) {
-		const whereClause = params.where || []
-		whereClause.push(`container="${container}"`)
+		const whereClause = params.where || [];
+		whereClause.push(`container="${container}"`);
 		const result = this._storage.query(context.projectKey, this.getTypeId(), {
 			...params,
 			where: whereClause,
-		})
+		});
 
 		// @ts-ignore
-		result.results = result.results.map(this.postProcessResource)
-		return result
-	}
-
-	getWithContainerAndKey(
-		context: RepositoryContext,
-		container: string,
-		key: string
-	) {
-		const items = this._storage.all(context.projectKey, this.getTypeId())
-		return items.find(
-			(item) => item.container === container && item.key === key
-		)
+		result.results = result.results.map(this.postProcessResource);
+		return result;
 	}
 }

package/src/repositories/customer/actions.ts

@@ -0,0 +1,165 @@
+import type {
+	Customer,
+	CustomerChangeAddressAction,
+	CustomerChangeEmailAction,
+	CustomerSetAuthenticationModeAction,
+	CustomerSetCompanyNameAction,
+	CustomerSetCustomFieldAction,
+	CustomerSetCustomerNumberAction,
+	CustomerSetFirstNameAction,
+	CustomerSetLastNameAction,
+	CustomerSetVatIdAction,
+	CustomerUpdateAction,
+	InvalidInputError,
+	InvalidJsonInputError,
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "~src/exceptions";
+import { hashPassword } from "~src/lib/password";
+import type { Writable } from "~src/types";
+import {
+	AbstractUpdateHandler,
+	UpdateHandlerInterface,
+	type RepositoryContext,
+} from "../abstract";
+import { createAddress } from "../helpers";
+
+export class CustomerUpdateHandler
+	extends AbstractUpdateHandler
+	implements Partial<UpdateHandlerInterface<Customer, CustomerUpdateAction>>
+{
+	changeAddress(
+		context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ addressId, addressKey, address }: CustomerChangeAddressAction,
+	) {
+		const oldAddressIndex = resource.addresses.findIndex((a) => {
+			if (a.id != undefined && addressId != undefined && a.id === addressId) {
+				return true;
+			}
+
+			return (
+				a.key != undefined && addressKey != undefined && a.key === addressKey
+			);
+		});
+
+		if (oldAddressIndex === -1) {
+			throw new CommercetoolsError<InvalidInputError>(
+				{
+					code: "InvalidInput",
+					message: `Address with id '${addressId}' or key '${addressKey}' not found.`,
+				},
+				400,
+			);
+		}
+
+		const newAddress = createAddress(
+			address,
+			context.projectKey,
+			this._storage,
+		);
+
+		if (newAddress) {
+			resource.addresses[oldAddressIndex] = {
+				id: addressId,
+				...newAddress,
+			};
+		}
+	}
+
+	changeEmail(
+		_context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ email }: CustomerChangeEmailAction,
+	) {
+		resource.email = email;
+	}
+
+	setAuthenticationMode(
+		_context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ authMode, password }: CustomerSetAuthenticationModeAction,
+	) {
+		if (resource.authenticationMode === authMode) {
+			throw new CommercetoolsError<InvalidInputError>(
+				{
+					code: "InvalidInput",
+					message: `The customer is already using the '${resource.authenticationMode}' authentication mode.`,
+				},
+				400,
+			);
+		}
+		resource.authenticationMode = authMode;
+		if (authMode === "ExternalAuth") {
+			delete resource.password;
+			return;
+		}
+		if (authMode === "Password") {
+			resource.password = password ? hashPassword(password) : undefined;
+			return;
+		}
+		throw new CommercetoolsError<InvalidJsonInputError>(
+			{
+				code: "InvalidJsonInput",
+				message: "Request body does not contain valid JSON.",
+				detailedErrorMessage: `actions -> authMode: Invalid enum value: '${authMode}'. Expected one of: 'Password','ExternalAuth'`,
+			},
+			400,
+		);
+	}
+
+	setCompanyName(
+		_context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ companyName }: CustomerSetCompanyNameAction,
+	) {
+		resource.companyName = companyName;
+	}
+
+	setCustomerNumber(
+		_context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ customerNumber }: CustomerSetCustomerNumberAction,
+	) {
+		if (resource.customerNumber) {
+			throw new Error(
+				"A Customer number already exists and cannot be set again.",
+			);
+		}
+		resource.customerNumber = customerNumber;
+	}
+
+	setCustomField(
+		_context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ name, value }: CustomerSetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			throw new Error("Resource has no custom field");
+		}
+		resource.custom.fields[name] = value;
+	}
+
+	setFirstName(
+		_context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ firstName }: CustomerSetFirstNameAction,
+	) {
+		resource.firstName = firstName;
+	}
+
+	setLastName(
+		_context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ lastName }: CustomerSetLastNameAction,
+	) {
+		resource.lastName = lastName;
+	}
+
+	setVatId(
+		_context: RepositoryContext,
+		resource: Writable<Customer>,
+		{ vatId }: CustomerSetVatIdAction,
+	) {
+		resource.vatId = vatId;
+	}
+}

package/src/repositories/customer/index.ts

@@ -0,0 +1,79 @@
+import type {
+	Customer,
+	CustomerDraft,
+	CustomerToken,
+	DuplicateFieldError,
+	ResourceNotFoundError,
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "~src/exceptions";
+import { getBaseResourceProperties } from "~src/helpers";
+import { createPasswordResetToken, hashPassword } from "~src/lib/password";
+import { AbstractStorage } from "~src/storage/abstract";
+import {
+	AbstractResourceRepository,
+	type RepositoryContext,
+} from "../abstract";
+import { CustomerUpdateHandler } from "./actions";
+
+export class CustomerRepository extends AbstractResourceRepository<"customer"> {
+	constructor(storage: AbstractStorage) {
+		super("customer", storage);
+		this.actions = new CustomerUpdateHandler(storage);
+	}
+
+	create(context: RepositoryContext, draft: CustomerDraft): Customer {
+		// Check uniqueness
+		const results = this._storage.query(context.projectKey, this.getTypeId(), {
+			where: [`email="${draft.email.toLocaleLowerCase()}"`],
+		});
+		if (results.count > 0) {
+			throw new CommercetoolsError<any>({
+				code: "CustomerAlreadyExists",
+				statusCode: 400,
+				message:
+					"There is already an existing customer with the provided email.",
+				errors: [
+					{
+						code: "DuplicateField",
+						message: `Customer with email '${draft.email}' already exists.`,
+						duplicateValue: draft.email,
+						field: "email",
+					} as DuplicateFieldError,
+				],
+			});
+		}
+
+		const resource: Customer = {
+			...getBaseResourceProperties(),
+			authenticationMode: draft.authenticationMode || "Password",
+			email: draft.email.toLowerCase(),
+			password: draft.password ? hashPassword(draft.password) : undefined,
+			isEmailVerified: draft.isEmailVerified || false,
+			addresses: [],
+			customerNumber: draft.customerNumber,
+		};
+		return this.saveNew(context, resource);
+	}
+
+	passwordResetToken(context: RepositoryContext, email: string): CustomerToken {
+		const results = this._storage.query(context.projectKey, this.getTypeId(), {
+			where: [`email="${email.toLocaleLowerCase()}"`],
+		});
+		if (results.count === 0) {
+			throw new CommercetoolsError<ResourceNotFoundError>({
+				code: "ResourceNotFound",
+				message: `The Customer with ID '${email}' was not found.`,
+			});
+		}
+		const expiresAt = new Date(Date.now() + 30 * 60);
+		const customer = results.results[0] as Customer;
+		const { version: _, ...rest } = getBaseResourceProperties();
+		const token = createPasswordResetToken(customer);
+		return {
+			...rest,
+			customerId: customer.id,
+			expiresAt: expiresAt.toISOString(),
+			value: token,
+		};
+	}
+}