@labdigital/commercetools-mock 2.17.1 → 2.18.0

package/src/repositories/abstract.ts

@@ -4,212 +4,264 @@ import type {
 	QueryParam,
 	ResourceNotFoundError,
 	UpdateAction,
-} from '@commercetools/platform-sdk'
-import deepEqual from 'deep-equal'
-import { CommercetoolsError } from '../exceptions.js'
-import { cloneObject } from '../helpers.js'
-import { AbstractStorage } from '../storage/index.js'
-import { ResourceMap, ResourceType, ShallowWritable } from './../types.js'
-import { checkConcurrentModification } from './errors.js'
+} from "@commercetools/platform-sdk";
+import deepEqual from "deep-equal";
+import { CommercetoolsError } from "~src/exceptions";
+import { cloneObject } from "../helpers";
+import { AbstractStorage } from "../storage";
+import {
+	ResourceMap,
+	ResourceType,
+	ShallowWritable,
+	Writable,
+} from "./../types";
+import { checkConcurrentModification } from "./errors";
 
 export type QueryParams = {
-	expand?: string[]
-	where?: string[]
-	offset?: number
-	limit?: number
+	expand?: string[];
+	where?: string[];
+	offset?: number;
+	limit?: number;
 
 	// Predicate var values. Should always start with `var.`
-	[key: string]: QueryParam
-}
+	[key: string]: QueryParam;
+};
 
 export type GetParams = {
-	expand?: string[]
-}
+	expand?: string[];
+};
 
 export type RepositoryContext = {
-	projectKey: string
-	storeKey?: string
-}
+	projectKey: string;
+	storeKey?: string;
+};
 
 export abstract class AbstractRepository<R extends BaseResource | Project> {
-	protected _storage: AbstractStorage
-	protected actions: Partial<
-		Record<
-			any,
-			(context: RepositoryContext, resource: any, action: any) => void
-		>
-	> = {}
+	protected _storage: AbstractStorage;
+
+	protected actions: AbstractUpdateHandler | undefined;
 
 	constructor(storage: AbstractStorage) {
-		this._storage = storage
+		this._storage = storage;
 	}
 
-	abstract saveNew({ projectKey }: RepositoryContext, resource: R): void
+	abstract saveNew({ projectKey }: RepositoryContext, resource: R): void;
 
 	abstract saveUpdate(
 		{ projectKey }: RepositoryContext,
 		version: number,
-		resource: R
-	): void
+		resource: R,
+	): void;
+
+	abstract postProcessResource(resource: any): any;
 
 	processUpdateActions(
 		context: RepositoryContext,
 		resource: R,
 		version: number,
-		actions: UpdateAction[]
+		actions: UpdateAction[],
 	): R {
-		// Deep-copy
-		const updatedResource = cloneObject(resource) as ShallowWritable<R>
-		const identifier = (resource as BaseResource).id
-			? (resource as BaseResource).id
-			: (resource as Project).key
-
-		actions.forEach((action) => {
-			const updateFunc = this.actions[action.action]
-
-			if (!updateFunc) {
-				console.error(`No mock implemented for update action ${action.action}`)
-				throw new Error(
-					`No mock implemented for update action ${action.action}`
-				)
-			}
-
-			const beforeUpdate = cloneObject(resource)
-			updateFunc(context, updatedResource, action)
-
-			// Check if the object is updated. We need to increase the version of
-			// an object per action which does an actual modification.
-			// This isn't the most performant method to do this (the update action
-			// should return a flag) but for now the easiest.
-			if (!deepEqual(beforeUpdate, updatedResource)) {
-				// We only check the version when there is an actual modification to
-				// be stored.
-				checkConcurrentModification(resource.version, version, identifier)
+		if (!this.actions) {
+			throw new Error("No actions defined");
+		}
 
-				updatedResource.version += 1
-			}
-		})
+		const updatedResource = this.actions.apply(
+			context,
+			resource,
+			version,
+			actions,
+		);
 
 		// If all actions succeeded we write the new version
 		// to the storage.
 		if (resource.version != updatedResource.version) {
-			this.saveUpdate(context, version, updatedResource)
+			this.saveUpdate(context, version, updatedResource);
 		}
 
-		const result = this.postProcessResource(updatedResource)
+		const result = this.postProcessResource(updatedResource);
 		if (!result) {
-			throw new Error('invalid post process action')
+			throw new Error("invalid post process action");
 		}
-		return result
+		return result;
 	}
-
-	abstract postProcessResource(resource: any): any
 }
 
 export abstract class AbstractResourceRepository<
 	T extends ResourceType,
 > extends AbstractRepository<ResourceMap[T]> {
-	abstract create(context: RepositoryContext, draft: any): ResourceMap[T]
-	abstract getTypeId(): T
+	protected _typeId: T;
 
-	constructor(storage: AbstractStorage) {
-		super(storage)
+	constructor(typeId: T, storage: AbstractStorage) {
+		super(storage);
+		this._typeId = typeId;
 	}
 
-	postProcessResource(resource: ResourceMap[T]): ResourceMap[T] {
-		return resource
-	}
+	abstract create(context: RepositoryContext, draft: any): ResourceMap[T];
 
-	query(context: RepositoryContext, params: QueryParams = {}) {
-		const result = this._storage.query(context.projectKey, this.getTypeId(), {
-			...params,
-		})
+	protected getTypeId(): T {
+		return this._typeId;
+	}
 
-		// @ts-ignore
-		result.results = result.results.map(this.postProcessResource)
-		return result
+	delete(
+		context: RepositoryContext,
+		id: string,
+		params: GetParams = {},
+	): ResourceMap[T] | null {
+		const resource = this._storage.delete(
+			context.projectKey,
+			this.getTypeId(),
+			id,
+			params,
+		);
+		return resource ? this.postProcessResource(resource) : null;
 	}
 
 	get(
 		context: RepositoryContext,
 		id: string,
-		params: GetParams = {}
+		params: GetParams = {},
 	): ResourceMap[T] | null {
 		const resource = this._storage.get(
 			context.projectKey,
 			this.getTypeId(),
 			id,
-			params
-		)
-		return resource ? this.postProcessResource(resource) : null
+			params,
+		);
+		return resource ? this.postProcessResource(resource) : null;
 	}
 
 	getByKey(
 		context: RepositoryContext,
 		key: string,
-		params: GetParams = {}
+		params: GetParams = {},
 	): ResourceMap[T] | null {
 		const resource = this._storage.getByKey(
 			context.projectKey,
 			this.getTypeId(),
 			key,
-			params
-		)
-		return resource ? this.postProcessResource(resource) : null
+			params,
+		);
+		return resource ? this.postProcessResource(resource) : null;
 	}
 
-	delete(
-		context: RepositoryContext,
-		id: string,
-		params: GetParams = {}
-	): ResourceMap[T] | null {
-		const resource = this._storage.delete(
-			context.projectKey,
-			this.getTypeId(),
-			id,
-			params
-		)
-		return resource ? this.postProcessResource(resource) : null
+	postProcessResource(resource: ResourceMap[T]): ResourceMap[T] {
+		return resource;
+	}
+
+	query(context: RepositoryContext, params: QueryParams = {}) {
+		const result = this._storage.query(context.projectKey, this.getTypeId(), {
+			...params,
+		});
+
+		// @ts-ignore
+		result.results = result.results.map(this.postProcessResource);
+		return result;
 	}
 
 	saveNew(
 		context: RepositoryContext,
-		resource: ShallowWritable<ResourceMap[T]>
-	) {
-		resource.version = 1
-		this._storage.add(context.projectKey, this.getTypeId(), resource as any)
+		resource: ShallowWritable<ResourceMap[T]>,
+	): ResourceMap[T] {
+		resource.version = 1;
+		return this._storage.add(
+			context.projectKey,
+			this.getTypeId(),
+			resource as any,
+		);
 	}
 
 	saveUpdate(
 		context: RepositoryContext,
 		version: number,
-		resource: ShallowWritable<ResourceMap[T]>
+		resource: ShallowWritable<ResourceMap[T]>,
 	) {
 		// Check if the resource still exists.
 		const current = this._storage.get(
 			context.projectKey,
 			this.getTypeId(),
-			resource.id
-		)
+			resource.id,
+		);
 		if (!current) {
 			throw new CommercetoolsError<ResourceNotFoundError>(
 				{
-					code: 'ResourceNotFound',
-					message: 'Resource not found while updating',
+					code: "ResourceNotFound",
+					message: "Resource not found while updating",
 				},
-				400
-			)
+				400,
+			);
 		}
 
-		checkConcurrentModification(current.version, version, resource.id)
+		checkConcurrentModification(current.version, version, resource.id);
 
 		if (current.version === resource.version) {
-			throw new Error('Internal error: no changes to save')
+			throw new Error("Internal error: no changes to save");
 		}
-		resource.lastModifiedAt = new Date().toISOString()
+		resource.lastModifiedAt = new Date().toISOString();
+
+		this._storage.add(context.projectKey, this.getTypeId(), resource as any);
+
+		return resource;
+	}
+}
 
-		this._storage.add(context.projectKey, this.getTypeId(), resource as any)
+type UpdateActionHandlerMethod<A, T> = (
+	context: RepositoryContext,
+	resource: Writable<A>,
+	action: T,
+) => void;
 
-		return resource
+export type UpdateHandlerInterface<
+	A extends BaseResource | Project,
+	T extends UpdateAction,
+> = {
+	[P in T as P["action"]]: UpdateActionHandlerMethod<A, P>;
+};
+
+export class AbstractUpdateHandler {
+	constructor(protected _storage: AbstractStorage) {
+		if (!_storage) {
+			throw new Error("No storage provided");
+		}
+		this._storage = _storage;
+	}
+
+	apply<R extends BaseResource | Project>(
+		context: RepositoryContext,
+		resource: R,
+		version: number,
+		actions: UpdateAction[],
+	): R {
+		const updatedResource = cloneObject(resource) as ShallowWritable<R>;
+		const identifier = (resource as BaseResource).id
+			? (resource as BaseResource).id
+			: (resource as Project).key;
+
+		for (const action of actions) {
+			// @ts-ignore
+			const updateFunc = this[action.action].bind(this);
+
+			if (!updateFunc) {
+				console.error(`No mock implemented for update action ${action.action}`);
+				throw new Error(
+					`No mock implemented for update action ${action.action}`,
+				);
+			}
+
+			const beforeUpdate = cloneObject(resource);
+			updateFunc(context, updatedResource, action);
+
+			// Check if the object is updated. We need to increase the version of
+			// an object per action which does an actual modification.
+			// This isn't the most performant method to do this (the update action
+			// should return a flag) but for now the easiest.
+			if (!deepEqual(beforeUpdate, updatedResource)) {
+				// We only check the version when there is an actual modification to
+				// be stored.
+				checkConcurrentModification(resource.version, version, identifier);
+
+				updatedResource.version += 1;
+			}
+		}
+		return updatedResource;
 	}
 }

package/src/repositories/associate-role.ts

@@ -7,18 +7,23 @@ import type {
 	AssociateRoleSetCustomFieldAction,
 	AssociateRoleSetNameAction,
 	AssociateRoleSetPermissionsAction,
-} from '@commercetools/platform-sdk'
+	AssociateRoleUpdateAction,
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "../helpers";
+import { AbstractStorage } from "../storage/abstract";
+import { Writable } from "../types";
 import {
 	AbstractResourceRepository,
+	AbstractUpdateHandler,
+	UpdateHandlerInterface,
 	type RepositoryContext,
-} from './abstract.js'
-import { getBaseResourceProperties } from '../helpers.js'
-import { createCustomFields } from './helpers.js'
-import { Writable } from '../types.js'
+} from "./abstract";
+import { createCustomFields } from "./helpers";
 
-export class AssociateRoleRepository extends AbstractResourceRepository<'associate-role'> {
-	getTypeId() {
-		return 'associate-role' as const
+export class AssociateRoleRepository extends AbstractResourceRepository<"associate-role"> {
+	constructor(storage: AbstractStorage) {
+		super("associate-role", storage);
+		this.actions = new AssociateRoleUpdateHandler(this._storage);
 	}
 
 	create(context: RepositoryContext, draft: AssociateRoleDraft): AssociateRole {
@@ -31,82 +36,90 @@ export class AssociateRoleRepository extends AbstractResourceRepository<'associa
 			custom: createCustomFields(
 				draft.custom,
 				context.projectKey,
-				this._storage
+				this._storage,
 			),
+		};
+
+		return this.saveNew(context, resource);
+	}
+}
+
+class AssociateRoleUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		Partial<UpdateHandlerInterface<AssociateRole, AssociateRoleUpdateAction>>
+{
+	addPermission(
+		context: RepositoryContext,
+		resource: Writable<AssociateRole>,
+		{ permission }: AssociateRoleAddPermissionAction,
+	) {
+		if (!resource.permissions) {
+			resource.permissions = [permission];
+		} else {
+			resource.permissions.push(permission);
 		}
+	}
+
+	changeBuyerAssignable(
+		context: RepositoryContext,
+		resource: Writable<AssociateRole>,
+		{ buyerAssignable }: AssociateRoleChangeBuyerAssignableAction,
+	) {
+		resource.buyerAssignable = buyerAssignable;
+	}
 
-		this.saveNew(context, resource)
+	removePermission(
+		context: RepositoryContext,
+		resource: Writable<AssociateRole>,
+		{ permission }: AssociateRoleRemovePermissionAction,
+	) {
+		if (!resource.permissions) {
+			return;
+		}
 
-		return resource
+		resource.permissions = resource.permissions.filter((p) => {
+			p !== permission;
+		});
 	}
 
-	actions = {
-		setName: (
-			context: RepositoryContext,
-			resource: Writable<AssociateRole>,
-			{ name }: AssociateRoleSetNameAction
-		) => {
-			resource.name = name
-		},
-		setPermissions: (
-			context: RepositoryContext,
-			resource: Writable<AssociateRole>,
-			{ permissions }: AssociateRoleSetPermissionsAction
-		) => {
-			resource.permissions = permissions || []
-		},
-		setBuyerAssignable: (
-			context: RepositoryContext,
-			resource: Writable<AssociateRole>,
-			{ buyerAssignable }: AssociateRoleChangeBuyerAssignableAction
-		) => {
-			resource.buyerAssignable = buyerAssignable
-		},
-		changeBuyerAssignable: (
-			context: RepositoryContext,
-			resource: Writable<AssociateRole>,
-			{ buyerAssignable }: AssociateRoleChangeBuyerAssignableAction
-		) => {
-			resource.buyerAssignable = buyerAssignable
-		},
-		setCustomFields: (
-			context: RepositoryContext,
-			resource: Writable<AssociateRole>,
-			{ name, value }: AssociateRoleSetCustomFieldAction
-		) => {
-			if (!resource.custom) {
-				return
-			}
+	setBuyerAssignable(
+		context: RepositoryContext,
+		resource: Writable<AssociateRole>,
+		{ buyerAssignable }: AssociateRoleChangeBuyerAssignableAction,
+	) {
+		resource.buyerAssignable = buyerAssignable;
+	}
+
+	setCustomFields(
+		context: RepositoryContext,
+		resource: Writable<AssociateRole>,
+		{ name, value }: AssociateRoleSetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			return;
+		}
 
-			if (value === null) {
-				delete resource.custom.fields[name]
-			} else {
-				resource.custom.fields[name] = value
-			}
-		},
-		addPermission: (
-			context: RepositoryContext,
-			resource: Writable<AssociateRole>,
-			{ permission }: AssociateRoleAddPermissionAction
-		) => {
-			if (!resource.permissions) {
-				resource.permissions = [permission]
-			} else {
-				resource.permissions.push(permission)
-			}
-		},
-		removePermission: (
-			context: RepositoryContext,
-			resource: Writable<AssociateRole>,
-			{ permission }: AssociateRoleRemovePermissionAction
-		) => {
-			if (!resource.permissions) {
-				return
-			}
+		if (value === null) {
+			delete resource.custom.fields[name];
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
+
+	setName(
+		context: RepositoryContext,
+		resource: Writable<AssociateRole>,
+		{ name }: AssociateRoleSetNameAction,
+	) {
+		resource.name = name;
+	}
 
-			resource.permissions = resource.permissions.filter((p) => {
-				p !== permission
-			})
-		},
+	setPermissions(
+		context: RepositoryContext,
+		resource: Writable<AssociateRole>,
+		{ permissions }: AssociateRoleSetPermissionsAction,
+	) {
+		resource.permissions = permissions || [];
 	}
 }

package/src/repositories/attribute-group.ts

@@ -5,22 +5,27 @@ import type {
 	AttributeGroupSetAttributesAction,
 	AttributeGroupSetDescriptionAction,
 	AttributeGroupSetKeyAction,
-} from '@commercetools/platform-sdk'
+	AttributeGroupUpdateAction,
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "../helpers";
+import { AbstractStorage } from "../storage/abstract";
+import { Writable } from "../types";
 import {
 	AbstractResourceRepository,
+	AbstractUpdateHandler,
+	UpdateHandlerInterface,
 	type RepositoryContext,
-} from './abstract.js'
-import { getBaseResourceProperties } from '../helpers.js'
-import { Writable } from '../types.js'
+} from "./abstract";
 
-export class AttributeGroupRepository extends AbstractResourceRepository<'attribute-group'> {
-	getTypeId() {
-		return 'attribute-group' as const
+export class AttributeGroupRepository extends AbstractResourceRepository<"attribute-group"> {
+	constructor(storage: AbstractStorage) {
+		super("attribute-group", storage);
+		this.actions = new AttributeGroupUpdateHandler(this._storage);
 	}
 
 	create(
 		context: RepositoryContext,
-		draft: AttributeGroupDraft
+		draft: AttributeGroupDraft,
 	): AttributeGroup {
 		const resource: AttributeGroup = {
 			...getBaseResourceProperties(),
@@ -28,39 +33,45 @@ export class AttributeGroupRepository extends AbstractResourceRepository<'attrib
 			description: draft.description,
 			key: draft.key,
 			attributes: draft.attributes,
-		}
-		this.saveNew(context, resource)
-		return resource
+		};
+		return this.saveNew(context, resource);
+	}
+}
+
+class AttributeGroupUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		Partial<UpdateHandlerInterface<AttributeGroup, AttributeGroupUpdateAction>>
+{
+	changeName(
+		_context: RepositoryContext,
+		resource: Writable<AttributeGroup>,
+		{ name }: AttributeGroupChangeNameAction,
+	) {
+		resource.name = name;
+	}
+
+	setAttributes(
+		_context: RepositoryContext,
+		resource: Writable<AttributeGroup>,
+		{ attributes }: AttributeGroupSetAttributesAction,
+	) {
+		resource.attributes = attributes;
+	}
+
+	setDescription(
+		_context: RepositoryContext,
+		resource: Writable<AttributeGroup>,
+		{ description }: AttributeGroupSetDescriptionAction,
+	) {
+		resource.description = description;
 	}
 
-	actions = {
-		setAttributes: (
-			_context: RepositoryContext,
-			resource: Writable<AttributeGroup>,
-			{ attributes }: AttributeGroupSetAttributesAction
-		) => {
-			resource.attributes = attributes
-		},
-		changeName: (
-			_context: RepositoryContext,
-			resource: Writable<AttributeGroup>,
-			{ name }: AttributeGroupChangeNameAction
-		) => {
-			resource.name = name
-		},
-		setDescription: (
-			_context: RepositoryContext,
-			resource: Writable<AttributeGroup>,
-			{ description }: AttributeGroupSetDescriptionAction
-		) => {
-			resource.description = description
-		},
-		setKey: (
-			_context: RepositoryContext,
-			resource: Writable<AttributeGroup>,
-			{ key }: AttributeGroupSetKeyAction
-		) => {
-			resource.key = key
-		},
+	setKey(
+		_context: RepositoryContext,
+		resource: Writable<AttributeGroup>,
+		{ key }: AttributeGroupSetKeyAction,
+	) {
+		resource.key = key;
 	}
 }