@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/services/my-customer.ts

@@ -1,139 +1,130 @@
-import { Request, Response, Router } from 'express'
-import { CustomerRepository } from '../repositories/customer.js'
-import { getRepositoryContext } from '../repositories/helpers.js'
-import AbstractService from './abstract.js'
-import { hashPassword } from '../lib/password.js'
-import {
-	Customer,
-	Update,
-	InvalidCurrentPasswordError,
-} from '@commercetools/platform-sdk'
+import { Update } from "@commercetools/platform-sdk";
+import { Request, Response, Router } from "express";
+import { updateRequestSchema } from "~src/schemas/update-request";
+import { validateData } from "~src/validate";
+import { hashPassword } from "../lib/password";
+import { getRepositoryContext } from "../repositories/helpers";
+import { MyCustomerRepository } from "../repositories/my-customer";
+import AbstractService from "./abstract";
 
 export class MyCustomerService extends AbstractService {
-	public repository: CustomerRepository
+	public repository: MyCustomerRepository;
 
-	constructor(parent: Router, repository: CustomerRepository) {
-		super(parent)
-		this.repository = repository
+	constructor(parent: Router, repository: MyCustomerRepository) {
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'me'
+		return "me";
 	}
 
 	registerRoutes(parent: Router) {
 		// Overwrite this function to be able to handle /me path.
-		const basePath = this.getBasePath()
-		const router = Router({ mergeParams: true })
+		const basePath = this.getBasePath();
+		const router = Router({ mergeParams: true });
 
-		this.extraRoutes(router)
+		this.extraRoutes(router);
 
-		router.get('', this.getMe.bind(this))
-		router.post('', this.updateMe.bind(this))
-		router.delete('', this.deleteMe.bind(this))
+		router.get("", this.getMe.bind(this));
+		router.post("", this.updateMe.bind(this));
+		router.delete("", this.deleteMe.bind(this));
 
-		router.post('/signup', this.signUp.bind(this))
+		router.post("/signup", this.signUp.bind(this));
 
-		router.post('/login', this.signIn.bind(this))
-		router.post('/password', this.changePassword.bind(this))
+		router.post("/login", this.signIn.bind(this));
+		router.post("/password", this.changePassword.bind(this));
+		router.post("/password/reset", this.resetPassword.bind(this));
 
-		parent.use(`/${basePath}`, router)
+		parent.use(`/${basePath}`, router);
 	}
 
 	getMe(request: Request, response: Response) {
-		const resource = this.repository.getMe(getRepositoryContext(request))
+		const resource = this.repository.getMe(getRepositoryContext(request));
 		if (!resource) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
-		return response.status(200).send(resource)
+		return response.status(200).send(resource);
 	}
 
 	updateMe(request: Request, response: Response) {
-		const resource = this.repository.getMe(getRepositoryContext(request))
+		const resource = this.repository.getMe(getRepositoryContext(request));
 
 		if (!resource) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
-		const updateRequest: Update = request.body
+		const updateRequest = validateData<Update>(
+			request.body,
+			updateRequestSchema,
+		);
 		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);
 	}
+
 	deleteMe(request: Request, response: Response) {
-		const resource = this.repository.deleteMe(getRepositoryContext(request))
+		const resource = this.repository.deleteMe(getRepositoryContext(request));
 		if (!resource) {
-			return response.status(404).send('Not found')
+			return response.status(404).send("Not found");
 		}
 
-		return response.status(200).send(resource)
+		return response.status(200).send(resource);
 	}
 
 	signUp(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({ customer: result })
+			draft,
+		);
+		const result = this._expandWithId(request, resource.id);
+		return response.status(this.createStatusCode).send({ customer: result });
 	}
 
 	changePassword(request: Request, response: Response) {
-		const { currentPassword, newPassword } = request.body
-		const encodedPassword = hashPassword(currentPassword)
-
-		const result = this.repository.query(getRepositoryContext(request), {
-			where: [`password = "${encodedPassword}"`],
-		})
-
-		if (result.count === 0) {
-			return response.status(404).send({
-				message: 'Account with the given credentials not found.',
-				errors: [
-					{
-						code: 'InvalidCurrentPassword',
-						message: 'Account with the given credentials not found.',
-					} as InvalidCurrentPasswordError,
-				],
-			})
-		}
+		const customer = this.repository.changePassword(
+			getRepositoryContext(request),
+			request.body,
+		);
 
-		const newCustomer: Customer = {
-			...result.results[0],
-			password: hashPassword(newPassword),
-		}
+		return response.status(200).send(customer);
+	}
 
-		this.repository.saveNew(getRepositoryContext(request), newCustomer)
+	resetPassword(request: Request, response: Response) {
+		const customer = this.repository.resetPassword(
+			getRepositoryContext(request),
+			request.body,
+		);
 
-		return response.status(200).send(newCustomer)
+		return response.status(200).send(customer);
 	}
 
 	signIn(request: Request, response: Response) {
-		const { email, password } = request.body
-		const encodedPassword = hashPassword(password)
+		const { email, password } = request.body;
+		const encodedPassword = hashPassword(password);
 
 		const result = this.repository.query(getRepositoryContext(request), {
 			where: [`email = "${email}"`, `password = "${encodedPassword}"`],
-		})
+		});
 
 		if (result.count === 0) {
 			return response.status(400).send({
-				message: 'Account with the given credentials not found.',
+				message: "Account with the given credentials not found.",
 				errors: [
 					{
-						code: 'InvalidCredentials',
-						message: 'Account with the given credentials not found.',
+						code: "InvalidCredentials",
+						message: "Account with the given credentials not found.",
 					},
 				],
-			})
+			});
 		}
 
-		return response.status(200).send({ customer: result.results[0] })
+		return response.status(200).send({ customer: result.results[0] });
 	}
 }

package/src/services/my-order.ts

@@ -1,34 +1,34 @@
-import { Router } from 'express'
-import { MyOrderRepository } from '../repositories/my-order.js'
-import AbstractService from './abstract.js'
+import { Router } from "express";
+import { MyOrderRepository } from "../repositories/my-order";
+import AbstractService from "./abstract";
 
 export class MyOrderService extends AbstractService {
-	public repository: MyOrderRepository
+	public repository: MyOrderRepository;
 
 	constructor(parent: Router, repository: MyOrderRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'me'
+		return "me";
 	}
 
 	registerRoutes(parent: Router) {
 		// Overwrite this function to be able to handle /me/active-cart path.
-		const basePath = this.getBasePath()
-		const router = Router({ mergeParams: true })
+		const basePath = this.getBasePath();
+		const router = Router({ mergeParams: true });
 
-		this.extraRoutes(router)
+		this.extraRoutes(router);
 
-		router.get('/orders/', this.get.bind(this))
-		router.get('/orders/:id', this.getWithId.bind(this))
+		router.get("/orders/", this.get.bind(this));
+		router.get("/orders/:id", this.getWithId.bind(this));
 
-		router.delete('/orders/:id', this.deleteWithId.bind(this))
+		router.delete("/orders/:id", this.deleteWithId.bind(this));
 
-		router.post('/orders/', this.post.bind(this))
-		router.post('/orders/:id', this.postWithId.bind(this))
+		router.post("/orders/", this.post.bind(this));
+		router.post("/orders/:id", this.postWithId.bind(this));
 
-		parent.use(`/${basePath}`, router)
+		parent.use(`/${basePath}`, router);
 	}
 }

package/src/services/my-payment.test.ts

@@ -1,78 +1,78 @@
-import type { MyPaymentDraft } from '@commercetools/platform-sdk'
-import supertest from 'supertest'
-import { beforeEach, describe, expect, test } from 'vitest'
-import { CommercetoolsMock } from '../index.js'
+import type { MyPaymentDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { beforeEach, describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
 
-const ctMock = new CommercetoolsMock()
+const ctMock = new CommercetoolsMock();
 
-describe('MyPayment', () => {
+describe("MyPayment", () => {
 	beforeEach(async () => {
 		const response = await supertest(ctMock.app)
-			.post('/dummy/types')
+			.post("/dummy/types")
 			.send({
-				key: 'custom-payment',
+				key: "custom-payment",
 				name: {
-					'nl-NL': 'custom-payment',
+					"nl-NL": "custom-payment",
 				},
-				resourceTypeIds: ['payment'],
-			})
-		expect(response.status).toBe(201)
-	})
+				resourceTypeIds: ["payment"],
+			});
+		expect(response.status).toBe(201);
+	});
 
-	test('Create payment', async () => {
+	test("Create payment", async () => {
 		const draft: MyPaymentDraft = {
-			amountPlanned: { currencyCode: 'EUR', centAmount: 1337 },
+			amountPlanned: { currencyCode: "EUR", centAmount: 1337 },
 			custom: {
-				type: { typeId: 'type', key: 'custom-payment' },
+				type: { typeId: "type", key: "custom-payment" },
 				fields: {
-					foo: 'bar',
+					foo: "bar",
 				},
 			},
-		}
+		};
 		const response = await supertest(ctMock.app)
-			.post('/dummy/me/payments')
-			.send(draft)
+			.post("/dummy/me/payments")
+			.send(draft);
 
-		expect(response.status).toBe(201)
+		expect(response.status).toBe(201);
 		expect(response.body).toEqual({
 			id: expect.anything(),
 			createdAt: expect.anything(),
 			lastModifiedAt: expect.anything(),
 			version: 1,
 			amountPlanned: {
-				type: 'centPrecision',
+				type: "centPrecision",
 				fractionDigits: 2,
-				currencyCode: 'EUR',
+				currencyCode: "EUR",
 				centAmount: 1337,
 			},
 			paymentStatus: {},
 			transactions: [],
 			interfaceInteractions: [],
 			custom: {
-				type: { typeId: 'type', id: expect.anything() },
-				fields: { foo: 'bar' },
+				type: { typeId: "type", id: expect.anything() },
+				fields: { foo: "bar" },
 			},
-		})
-	})
-	test('Get payment', async () => {
+		});
+	});
+	test("Get payment", async () => {
 		const draft: MyPaymentDraft = {
-			amountPlanned: { currencyCode: 'EUR', centAmount: 1337 },
+			amountPlanned: { currencyCode: "EUR", centAmount: 1337 },
 			custom: {
-				type: { typeId: 'type', key: 'custom-payment' },
+				type: { typeId: "type", key: "custom-payment" },
 				fields: {
-					foo: 'bar',
+					foo: "bar",
 				},
 			},
-		}
+		};
 		const createResponse = await supertest(ctMock.app)
-			.post('/dummy/me/payments')
-			.send(draft)
+			.post("/dummy/me/payments")
+			.send(draft);
 
 		const response = await supertest(ctMock.app).get(
-			`/dummy/me/payments/${createResponse.body.id}`
-		)
+			`/dummy/me/payments/${createResponse.body.id}`,
+		);
 
-		expect(response.status).toBe(200)
-		expect(response.body).toEqual(createResponse.body)
-	})
-})
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
+});

package/src/services/my-payment.ts

@@ -1,16 +1,16 @@
-import { Router } from 'express'
-import { PaymentRepository } from '../repositories/payment.js'
-import AbstractService from './abstract.js'
+import { Router } from "express";
+import { PaymentRepository } from "../repositories/payment";
+import AbstractService from "./abstract";
 
 export class MyPaymentService extends AbstractService {
-	public repository: PaymentRepository
+	public repository: PaymentRepository;
 
 	constructor(parent: Router, repository: PaymentRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'me/payments'
+		return "me/payments";
 	}
 }

package/src/services/my-shopping-list.ts

@@ -1,16 +1,16 @@
-import { Router } from 'express'
-import { ShoppingListRepository } from '../repositories/shopping-list.js'
-import AbstractService from './abstract.js'
+import { Router } from "express";
+import { ShoppingListRepository } from "../repositories/shopping-list";
+import AbstractService from "./abstract";
 
 export class MyShoppingListService extends AbstractService {
-	public repository: ShoppingListRepository
+	public repository: ShoppingListRepository;
 
 	constructor(parent: Router, repository: ShoppingListRepository) {
-		super(parent)
-		this.repository = repository
+		super(parent);
+		this.repository = repository;
 	}
 
 	getBasePath() {
-		return 'me/shopping-lists'
+		return "me/shopping-lists";
 	}
 }