@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/repositories/type/actions.ts

@@ -0,0 +1,162 @@
+import type {
+	FieldDefinition,
+	InvalidOperationError,
+	Type,
+	TypeAddEnumValueAction,
+	TypeAddFieldDefinitionAction,
+	TypeChangeEnumValueLabelAction,
+	TypeChangeFieldDefinitionOrderAction,
+	TypeChangeNameAction,
+	TypeRemoveFieldDefinitionAction,
+	TypeSetDescriptionAction,
+	TypeUpdateAction,
+} from "@commercetools/platform-sdk";
+import isEqual from "lodash.isequal";
+import { CommercetoolsError } from "~src/exceptions";
+import type { Writable } from "~src/types";
+import { AbstractUpdateHandler, RepositoryContext } from "../abstract";
+
+type TypeUpdateHandlerMethod<T> = (
+	context: RepositoryContext,
+	resource: Writable<Type>,
+	action: T,
+) => void;
+
+type TypeUpdateActions = Partial<{
+	[P in TypeUpdateAction as P["action"]]: TypeUpdateHandlerMethod<P>;
+}>;
+
+export class TypeUpdateHandler
+	extends AbstractUpdateHandler
+	implements TypeUpdateActions
+{
+	addEnumValue(
+		context: RepositoryContext,
+		resource: Writable<Type>,
+		{ fieldName, value }: TypeAddEnumValueAction,
+	) {
+		resource.fieldDefinitions.forEach((field) => {
+			if (field.name === fieldName) {
+				// TODO, should be done better i suppose
+				if (field.type.name === "Enum") {
+					field.type.values.push(value);
+				} else if (
+					field.type.name === "Set" &&
+					field.type.elementType.name === "Enum"
+				) {
+					field.type.elementType.values.push(value);
+				} else {
+					throw new Error("Type is not a Enum (or Set of Enum)");
+				}
+			}
+		});
+	}
+
+	addFieldDefinition(
+		context: RepositoryContext,
+		resource: Writable<Type>,
+		{ fieldDefinition }: TypeAddFieldDefinitionAction,
+	) {
+		resource.fieldDefinitions.push(fieldDefinition);
+	}
+
+	changeEnumValueLabel(
+		context: RepositoryContext,
+		resource: Writable<Type>,
+		{ fieldName, value }: TypeChangeEnumValueLabelAction,
+	) {
+		resource.fieldDefinitions.forEach((field) => {
+			if (field.name === fieldName) {
+				// TODO, should be done better i suppose
+				if (field.type.name === "Enum") {
+					field.type.values.forEach((v) => {
+						if (v.key === value.key) {
+							v.label = value.label;
+						}
+					});
+				} else if (
+					field.type.name === "Set" &&
+					field.type.elementType.name === "Enum"
+				) {
+					field.type.elementType.values.forEach((v) => {
+						if (v.key === value.key) {
+							v.label = value.label;
+						}
+					});
+				} else {
+					throw new Error("Type is not a Enum (or Set of Enum)");
+				}
+			}
+		});
+	}
+
+	changeFieldDefinitionOrder(
+		context: RepositoryContext,
+		resource: Writable<Type>,
+		{ fieldNames }: TypeChangeFieldDefinitionOrderAction,
+	) {
+		const fields = new Map(
+			resource.fieldDefinitions.map((item) => [item.name, item]),
+		);
+		const result: FieldDefinition[] = [];
+		let current = resource.fieldDefinitions;
+
+		fieldNames.forEach((fieldName) => {
+			const field = fields.get(fieldName);
+			if (field === undefined) {
+				throw new Error("New field");
+			}
+			result.push(field);
+
+			// Remove from current items
+			current = current.filter((f) => f.name !== fieldName);
+		});
+
+		if (
+			isEqual(
+				fieldNames,
+				resource.fieldDefinitions.map((item) => item.name),
+			)
+		) {
+			throw new CommercetoolsError<InvalidOperationError>({
+				code: "InvalidOperation",
+				message: "'fieldDefinitions' has no changes.",
+				action: {
+					action: "changeFieldDefinitionOrder",
+					fieldNames: fieldNames,
+				},
+			});
+		}
+
+		resource.fieldDefinitions = result;
+		// Add fields which were not specified in the order as last items. Not
+		// sure if this follows commercetools
+		resource.fieldDefinitions.push(...current);
+	}
+
+	changeName(
+		context: RepositoryContext,
+		resource: Writable<Type>,
+		{ name }: TypeChangeNameAction,
+	) {
+		resource.name = name;
+	}
+
+	removeFieldDefinition(
+		context: RepositoryContext,
+		resource: Writable<Type>,
+		{ fieldName }: TypeRemoveFieldDefinitionAction,
+	) {
+		resource.fieldDefinitions = resource.fieldDefinitions.filter(
+			(f) => f.name !== fieldName,
+		);
+	}
+
+	setDescription(
+		context: RepositoryContext,
+		resource: Writable<Type>,
+		{ description }: TypeSetDescriptionAction,
+	) {
+		resource.description = description;
+	}
+}

package/src/repositories/type/index.ts

@@ -0,0 +1,24 @@
+import type { Type, TypeDraft } from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "~src/helpers";
+import { AbstractStorage } from "~src/storage/abstract";
+import { AbstractResourceRepository, RepositoryContext } from "../abstract";
+import { TypeUpdateHandler } from "./actions";
+
+export class TypeRepository extends AbstractResourceRepository<"type"> {
+	constructor(storage: AbstractStorage) {
+		super("type", storage);
+		this.actions = new TypeUpdateHandler(storage);
+	}
+
+	create(context: RepositoryContext, draft: TypeDraft): Type {
+		const resource: Type = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			name: draft.name,
+			resourceTypeIds: draft.resourceTypeIds,
+			fieldDefinitions: draft.fieldDefinitions || [],
+			description: draft.description,
+		};
+		return this.saveNew(context, resource);
+	}
+}

package/src/repositories/zone.ts

@@ -7,14 +7,21 @@ import type {
 	ZoneSetDescriptionAction,
 	ZoneSetKeyAction,
 	ZoneUpdateAction,
-} from '@commercetools/platform-sdk'
-import { getBaseResourceProperties } from '../helpers.js'
-import type { Writable } from '../types.js'
-import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "../helpers";
+import { AbstractStorage } from "../storage/abstract";
+import type { Writable } from "../types";
+import {
+	AbstractResourceRepository,
+	AbstractUpdateHandler,
+	RepositoryContext,
+	UpdateHandlerInterface,
+} from "./abstract";
 
-export class ZoneRepository extends AbstractResourceRepository<'zone'> {
-	getTypeId() {
-		return 'zone' as const
+export class ZoneRepository extends AbstractResourceRepository<"zone"> {
+	constructor(storage: AbstractStorage) {
+		super("zone", storage);
+		this.actions = new ZoneUpdateHandler(storage);
 	}
 
 	create(context: RepositoryContext, draft: ZoneDraft): Zone {
@@ -24,58 +31,55 @@ export class ZoneRepository extends AbstractResourceRepository<'zone'> {
 			locations: draft.locations || [],
 			name: draft.name,
 			description: draft.description,
-		}
-		this.saveNew(context, resource)
-		return resource
+		};
+		return this.saveNew(context, resource);
+	}
+}
+
+class ZoneUpdateHandler
+	extends AbstractUpdateHandler
+	implements Partial<UpdateHandlerInterface<Zone, ZoneUpdateAction>>
+{
+	addLocation(
+		context: RepositoryContext,
+		resource: Writable<Zone>,
+		{ location }: ZoneAddLocationAction,
+	) {
+		resource.locations.push(location);
+	}
+
+	changeName(
+		context: RepositoryContext,
+		resource: Writable<Zone>,
+		{ name }: ZoneChangeNameAction,
+	) {
+		resource.name = name;
+	}
+
+	removeLocation(
+		context: RepositoryContext,
+		resource: Writable<Zone>,
+		{ location }: ZoneRemoveLocationAction,
+	) {
+		resource.locations = resource.locations.filter(
+			(loc) =>
+				!(loc.country === location.country && loc.state === location.state),
+		);
+	}
+
+	setDescription(
+		context: RepositoryContext,
+		resource: Writable<Zone>,
+		{ description }: ZoneSetDescriptionAction,
+	) {
+		resource.description = description;
 	}
 
-	actions: Partial<
-		Record<
-			ZoneUpdateAction['action'],
-			(
-				context: RepositoryContext,
-				resource: Writable<Zone>,
-				action: any
-			) => void
-		>
-	> = {
-		addLocation: (
-			context: RepositoryContext,
-			resource: Writable<Zone>,
-			{ location }: ZoneAddLocationAction
-		) => {
-			resource.locations.push(location)
-		},
-		removeLocation: (
-			context: RepositoryContext,
-			resource: Writable<Zone>,
-			{ location }: ZoneRemoveLocationAction
-		) => {
-			resource.locations = resource.locations.filter(
-				(loc) =>
-					!(loc.country === location.country && loc.state === location.state)
-			)
-		},
-		changeName: (
-			context: RepositoryContext,
-			resource: Writable<Zone>,
-			{ name }: ZoneChangeNameAction
-		) => {
-			resource.name = name
-		},
-		setDescription: (
-			context: RepositoryContext,
-			resource: Writable<Zone>,
-			{ description }: ZoneSetDescriptionAction
-		) => {
-			resource.description = description
-		},
-		setKey: (
-			context: RepositoryContext,
-			resource: Writable<Zone>,
-			{ key }: ZoneSetKeyAction
-		) => {
-			resource.key = key
-		},
+	setKey(
+		context: RepositoryContext,
+		resource: Writable<Zone>,
+		{ key }: ZoneSetKeyAction,
+	) {
+		resource.key = key;
 	}
 }

package/src/schemas/update-request.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+const UpdateActionSchema = z
+	.object({
+		action: z.string(),
+	})
+	.passthrough();
+
+export const updateRequestSchema = z.object({
+	version: z.number(),
+	actions: z.array(UpdateActionSchema),
+});

package/src/server.ts

@@ -1,14 +1,14 @@
-import { CommercetoolsMock } from './index.js'
+import { CommercetoolsMock } from "./index";
 
-process.on('SIGINT', function () {
-	console.info('Stopping server...')
-	process.exit()
-})
+process.on("SIGINT", function () {
+	console.info("Stopping server...");
+	process.exit();
+});
 
-const instance = new CommercetoolsMock()
+const instance = new CommercetoolsMock();
 
-let port = 3000
+let port = 3000;
 
-if (process.env.HTTP_SERVER_PORT) port = parseInt(process.env.HTTP_SERVER_PORT)
+if (process.env.HTTP_SERVER_PORT) port = parseInt(process.env.HTTP_SERVER_PORT);
 
-instance.runServer(port)
+instance.runServer(port);

package/src/services/abstract.ts

@@ -1,95 +1,100 @@
-import type { Update } from '@commercetools/platform-sdk'
-import { type Request, type Response, Router } from 'express'
-import { ParsedQs } from 'qs'
-import { AbstractResourceRepository } from '../repositories/abstract.js'
-import { getRepositoryContext } from '../repositories/helpers.js'
-import { queryParamsArray } from '../helpers.js'
+import type { Update } from "@commercetools/platform-sdk";
+import { Router, type Request, type Response } from "express";
+import { ParsedQs } from "qs";
+import { updateRequestSchema } from "~src/schemas/update-request";
+import { validateData } from "~src/validate";
+import { queryParamsArray } from "../helpers";
+import { AbstractResourceRepository } from "../repositories/abstract";
+import { getRepositoryContext } from "../repositories/helpers";
 
 export default abstract class AbstractService {
-	protected abstract getBasePath(): string
-	public abstract repository: AbstractResourceRepository<any>
+	public abstract repository: AbstractResourceRepository<any>;
 
-	createStatusCode = 201
+	createStatusCode = 201;
 
 	constructor(parent: Router) {
-		this.registerRoutes(parent)
+		this.registerRoutes(parent);
 	}
 
+	protected abstract getBasePath(): string;
+
 	extraRoutes(router: Router) {}
 
 	registerRoutes(parent: Router) {
-		const basePath = this.getBasePath()
-		const router = Router({ mergeParams: true })
+		const basePath = this.getBasePath();
+		const router = Router({ mergeParams: true });
 
 		// Bind this first since the `/:id` routes are currently a bit to greedy
-		this.extraRoutes(router)
+		this.extraRoutes(router);
 
-		router.get('/', this.get.bind(this))
-		router.get('/key=:key', this.getWithKey.bind(this)) // same thing goes for the key routes
-		router.get('/:id', this.getWithId.bind(this))
+		router.get("/", this.get.bind(this));
+		router.get("/key=:key", this.getWithKey.bind(this)); // same thing goes for the key routes
+		router.get("/:id", this.getWithId.bind(this));
 
-		router.delete('/key=:key', this.deleteWithKey.bind(this))
-		router.delete('/:id', this.deleteWithId.bind(this))
+		router.delete("/key=:key", this.deleteWithKey.bind(this));
+		router.delete("/:id", this.deleteWithId.bind(this));
 
-		router.post('/', this.post.bind(this))
-		router.post('/key=:key', this.postWithKey.bind(this))
-		router.post('/:id', this.postWithId.bind(this))
+		router.post("/", this.post.bind(this));
+		router.post("/key=:key", this.postWithKey.bind(this));
+		router.post("/:id", this.postWithId.bind(this));
 
-		parent.use(`/${basePath}`, router)
+		parent.use(`/${basePath}`, router);
 	}
 
 	get(request: Request, response: Response) {
-		const limit = this._parseParam(request.query.limit)
-		const offset = this._parseParam(request.query.offset)
+		const limit = this._parseParam(request.query.limit);
+		const offset = this._parseParam(request.query.offset);
 
 		const result = this.repository.query(getRepositoryContext(request), {
 			expand: this._parseParam(request.query.expand),
 			where: this._parseParam(request.query.where),
 			limit: limit !== undefined ? Number(limit) : undefined,
 			offset: offset !== undefined ? Number(offset) : undefined,
-		})
-		return response.status(200).send(result)
+		});
+		return response.status(200).send(result);
 	}
 
 	getWithId(request: Request, response: Response) {
-		const result = this._expandWithId(request, request.params['id'])
+		const result = this._expandWithId(request, request.params["id"]);
 		if (!result) {
-			return response.status(404).send()
+			return response.status(404).send();
 		}
-		return response.status(200).send(result)
+		return response.status(200).send(result);
 	}
 
 	getWithKey(request: Request, response: Response) {
 		const result = this.repository.getByKey(
 			getRepositoryContext(request),
-			request.params['key'],
-			{ expand: this._parseParam(request.query.expand) }
-		)
-		if (!result) return response.status(404).send()
-		return response.status(200).send(result)
+			request.params["key"],
+			{
+				expand: this._parseParam(request.query.expand),
+			},
+		);
+		if (!result) return response.status(404).send();
+		return response.status(200).send(result);
 	}
 
 	deleteWithId(request: Request, response: Response) {
 		const result = this.repository.delete(
 			getRepositoryContext(request),
-			request.params['id'],
+			request.params["id"],
 			{
 				expand: this._parseParam(request.query.expand),
-			}
-		)
+			},
+		);
 		if (!result) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
-		return response.status(200).send(result)
+		return response.status(200).send(result);
 	}
 
 	deleteWithKey(request: Request, response: Response) {
 		const resource = this.repository.getByKey(
 			getRepositoryContext(request),
-			request.params['key']
-		)
+			request.params["key"],
+		);
 		if (!resource) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
 
 		const result = this.repository.delete(
@@ -97,63 +102,71 @@ export default abstract class AbstractService {
 			resource.id,
 			{
 				expand: this._parseParam(request.query.expand),
-			}
-		)
+			},
+		);
 		if (!result) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
-		return response.status(200).send(result)
+		return response.status(200).send(result);
 	}
 
 	post(request: Request, response: Response) {
-		const draft = request.body
+		const draft = request.body;
 		const resource = this.repository.create(
 			getRepositoryContext(request),
-			draft
-		)
-		const result = this._expandWithId(request, resource.id)
-		return response.status(this.createStatusCode).send(result)
+			draft,
+		);
+		const result = this._expandWithId(request, resource.id);
+		return response.status(this.createStatusCode).send(result);
 	}
 
 	postWithId(request: Request, response: Response) {
-		const updateRequest: Update = request.body
+		const updateRequest = validateData<Update>(
+			request.body,
+			updateRequestSchema,
+		);
 		const resource = this.repository.get(
 			getRepositoryContext(request),
-			request.params['id']
-		)
+			request.params["id"],
+		);
 		if (!resource) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
 
 		const updatedResource = this.repository.processUpdateActions(
 			getRepositoryContext(request),
 			resource,
 			updateRequest.version,
-			updateRequest.actions
-		)
+			updateRequest.actions,
+		);
 
-		const result = this._expandWithId(request, updatedResource.id)
-		return response.status(200).send(result)
+		const result = this._expandWithId(request, updatedResource.id);
+		return response.status(200).send(result);
 	}
 
 	postWithKey(request: Request, response: Response) {
-		const updateRequest: Update = request.body
+		const updateRequest = validateData<Update>(
+			request.body,
+			updateRequestSchema,
+		);
+
 		const resource = this.repository.getByKey(
 			getRepositoryContext(request),
-			request.params['key']
-		)
+			request.params["key"],
+		);
 		if (!resource) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
+
 		const updatedResource = this.repository.processUpdateActions(
 			getRepositoryContext(request),
 			resource,
 			updateRequest.version,
-			updateRequest.actions
-		)
+			updateRequest.actions,
+		);
 
-		const result = this._expandWithId(request, updatedResource.id)
-		return response.status(200).send(result)
+		const result = this._expandWithId(request, updatedResource.id);
+		return response.status(200).send(result);
 	}
 
 	protected _expandWithId(request: Request, resourceId: string) {
@@ -162,15 +175,15 @@ export default abstract class AbstractService {
 			resourceId,
 			{
 				expand: this._parseParam(request.query.expand),
-			}
-		)
-		return result
+			},
+		);
+		return result;
 	}
 
 	// No idea what i'm doing
 	protected _parseParam(
-		value: string | ParsedQs | string[] | ParsedQs[] | undefined
+		value: string | ParsedQs | string[] | ParsedQs[] | undefined,
 	): string[] | undefined {
-		return queryParamsArray(value)
+		return queryParamsArray(value);
 	}
 }