@labdigital/commercetools-mock 2.54.0 → 2.55.0

package/src/repositories/recurrence-policy/actions.ts

@@ -0,0 +1,53 @@
+import type {
+	RecurrencePolicy,
+	RecurrencePolicySetDescriptionAction,
+	RecurrencePolicySetKeyAction,
+	RecurrencePolicySetNameAction,
+	RecurrencePolicySetScheduleAction,
+	RecurrencePolicyUpdateAction,
+} from "@commercetools/platform-sdk";
+import type { Writable } from "~src/types";
+import type { UpdateHandlerInterface } from "../abstract";
+import { AbstractUpdateHandler, type RepositoryContext } from "../abstract";
+
+export class RecurrencePolicyUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		Partial<
+			UpdateHandlerInterface<RecurrencePolicy, RecurrencePolicyUpdateAction>
+		>
+{
+	setKey(
+		context: RepositoryContext,
+		resource: Writable<RecurrencePolicy>,
+		{ key }: RecurrencePolicySetKeyAction,
+	) {
+		if (key) {
+			resource.key = key;
+		}
+	}
+
+	setDescription(
+		context: RepositoryContext,
+		resource: Writable<RecurrencePolicy>,
+		{ description }: RecurrencePolicySetDescriptionAction,
+	) {
+		resource.description = description;
+	}
+
+	setName(
+		context: RepositoryContext,
+		resource: Writable<RecurrencePolicy>,
+		{ name }: RecurrencePolicySetNameAction,
+	) {
+		resource.name = name;
+	}
+
+	setSchedule(
+		context: RepositoryContext,
+		resource: Writable<RecurrencePolicy>,
+		{ schedule }: RecurrencePolicySetScheduleAction,
+	) {
+		resource.schedule = schedule;
+	}
+}

package/src/repositories/recurrence-policy/index.ts

@@ -0,0 +1,36 @@
+import assert from "node:assert";
+import type {
+	RecurrencePolicy,
+	RecurrencePolicyDraft,
+	RecurringOrder,
+	RecurringOrderDraft,
+} from "@commercetools/platform-sdk";
+import type { Config } from "~src/config";
+import { getBaseResourceProperties } from "~src/helpers";
+import {
+	AbstractResourceRepository,
+	type RepositoryContext,
+} from "../abstract";
+import { OrderRepository } from "../order";
+import { RecurrencePolicyUpdateHandler } from "./actions";
+
+export class RecurrencePolicyRepository extends AbstractResourceRepository<"recurrence-policy"> {
+	constructor(config: Config) {
+		super("recurrence-policy", config);
+		this.actions = new RecurrencePolicyUpdateHandler(config.storage);
+	}
+
+	create(
+		context: RepositoryContext,
+		draft: RecurrencePolicyDraft,
+	): RecurrencePolicy {
+		const resource: RecurrencePolicy = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			name: draft.name,
+			description: draft.description,
+			schedule: draft.schedule,
+		};
+		return this.saveNew(context, resource);
+	}
+}

package/src/repositories/recurring-order/actions.ts

@@ -0,0 +1,157 @@
+import type {
+	RecurringOrder,
+	RecurringOrderSetCustomFieldAction,
+	RecurringOrderSetCustomTypeAction,
+	RecurringOrderSetExpiresAtAction,
+	RecurringOrderSetKeyAction,
+	RecurringOrderSetOrderSkipConfigurationAction,
+	RecurringOrderSetScheduleAction,
+	RecurringOrderSetStartsAtAction,
+	RecurringOrderSetStateAction,
+	RecurringOrderTransitionStateAction,
+	RecurringOrderUpdateAction,
+} from "@commercetools/platform-sdk";
+import type { Writable } from "~src/types";
+import type { UpdateHandlerInterface } from "../abstract";
+import { AbstractUpdateHandler, type RepositoryContext } from "../abstract";
+
+export class RecurringOrderUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		Partial<UpdateHandlerInterface<RecurringOrder, RecurringOrderUpdateAction>>
+{
+	setCustomField(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ name, value }: RecurringOrderSetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			throw new Error("Resource has no custom field");
+		}
+		if (value === null) {
+			delete resource.custom.fields[name];
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
+
+	setCustomType(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ type, fields }: RecurringOrderSetCustomTypeAction,
+	) {
+		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 || {},
+			};
+		}
+	}
+
+	setExpiresAt(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ expiresAt }: RecurringOrderSetExpiresAtAction,
+	) {
+		resource.expiresAt = expiresAt;
+	}
+
+	setKey(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ key }: RecurringOrderSetKeyAction,
+	) {
+		resource.key = key;
+	}
+
+	setOrderSkipConfiguration(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{
+			skipConfiguration,
+			updatedExpiresAt,
+		}: RecurringOrderSetOrderSkipConfigurationAction,
+	) {
+		if (skipConfiguration) {
+			resource.skipConfiguration = {
+				type: skipConfiguration.type,
+				totalToSkip: skipConfiguration.totalToSkip,
+				skipped: 0,
+				lastSkippedAt: undefined,
+			};
+		} else {
+			resource.skipConfiguration = undefined;
+		}
+		if (updatedExpiresAt !== undefined) {
+			resource.expiresAt = updatedExpiresAt;
+		}
+	}
+
+	setSchedule(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ recurrencePolicy }: RecurringOrderSetScheduleAction,
+	) {
+		resource.schedule = {
+			...resource.schedule,
+			...recurrencePolicy,
+		};
+	}
+
+	setStartsAt(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ startsAt }: RecurringOrderSetStartsAtAction,
+	) {
+		resource.startsAt = startsAt;
+	}
+
+	setRecurringOrderState(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ recurringOrderState }: RecurringOrderSetStateAction,
+	) {
+		// Map the state draft to the actual state
+		switch (recurringOrderState.type) {
+			case "active":
+				resource.recurringOrderState = "Active";
+				if (recurringOrderState.resumesAt) {
+					resource.resumesAt = recurringOrderState.resumesAt;
+				}
+				break;
+			case "canceled":
+				resource.recurringOrderState = "Canceled";
+				break;
+			case "expired":
+				resource.recurringOrderState = "Expired";
+				break;
+			case "paused":
+				resource.recurringOrderState = "Paused";
+				break;
+		}
+	}
+
+	transitionState(
+		context: RepositoryContext,
+		resource: Writable<RecurringOrder>,
+		{ state, force }: RecurringOrderTransitionStateAction,
+	) {
+		resource.state = {
+			typeId: "state",
+			id: state.id!,
+		};
+	}
+}

package/src/repositories/recurring-order/index.ts

@@ -0,0 +1,52 @@
+import assert from "node:assert";
+import type {
+	RecurringOrder,
+	RecurringOrderDraft,
+} from "@commercetools/platform-sdk";
+import type { Config } from "~src/config";
+import { getBaseResourceProperties } from "~src/helpers";
+import {
+	AbstractResourceRepository,
+	type RepositoryContext,
+} from "../abstract";
+import { OrderRepository } from "../order";
+import { RecurringOrderUpdateHandler } from "./actions";
+
+export class RecurringOrderRepository extends AbstractResourceRepository<"recurring-order"> {
+	constructor(config: Config) {
+		super("recurring-order", config);
+		this.actions = new RecurringOrderUpdateHandler(config.storage);
+	}
+
+	create(
+		context: RepositoryContext,
+		draft: RecurringOrderDraft,
+	): RecurringOrder {
+		assert(draft.cart, "draft.cart is missing");
+
+		const orderRepo = new OrderRepository(this.config);
+
+		const initialOrder = orderRepo.createFromCart(context, {
+			id: draft.cart.id!,
+			typeId: "cart",
+		});
+
+		const resource: RecurringOrder = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			cart: {
+				typeId: "cart",
+				id: draft.cart.id!,
+			},
+			originOrder: {
+				typeId: "order",
+				id: initialOrder.id,
+			},
+			startsAt: draft.startsAt,
+			expiresAt: draft.expiresAt,
+			recurringOrderState: "Active",
+			schedule: { type: "standard", intervalUnit: "month", value: 1 },
+		};
+		return this.saveNew(context, resource);
+	}
+}

package/src/repositories/review.test.ts

@@ -36,6 +36,7 @@ describe("Review Repository", () => {
 			current: {
 				name: { "en-US": "Test Product" },
 				slug: { "en-US": "test-product" },
+				attributes: [],
 				categories: [],
 				masterVariant: {
 					id: 1,
@@ -49,6 +50,7 @@ describe("Review Repository", () => {
 			staged: {
 				name: { "en-US": "Test Product" },
 				slug: { "en-US": "test-product" },
+				attributes: [],
 				categories: [],
 				masterVariant: {
 					id: 1,

package/src/repositories/shopping-list/actions.ts

@@ -103,6 +103,7 @@ export class ShoppingListUpdateHandler
 				name: product.masterData.current.name,
 				variantId: varId,
 				quantity,
+				published: Boolean(product.masterData.current),
 			});
 		}
 	}

package/src/repositories/shopping-list/index.ts

@@ -75,6 +75,7 @@ export class ShoppingListRepository extends AbstractResourceRepository<"shopping
 			productId: draftLineItem.productId ?? "",
 			name: {},
 			variantId,
+			published: true,
 			quantity: draftLineItem.quantity ?? 1,
 			productType: { typeId: "product-type", id: "" },
 			custom: createCustomFields(

package/src/services/discount-group.test.ts

@@ -0,0 +1,270 @@
+import type { DiscountGroupDraft } from "@commercetools/platform-sdk";
+import supertest from "supertest";
+import { describe, expect, test } from "vitest";
+import { CommercetoolsMock } from "../index";
+
+const ctMock = new CommercetoolsMock();
+
+describe("DiscountGroup", () => {
+	test("Create discount group", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "premium-discount-group",
+			name: {
+				"en-GB": "Premium Discount Group",
+			},
+			description: {
+				"en-GB": "A discount group for premium customers",
+			},
+			sortOrder: "0.5",
+		};
+		const response = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(response.status).toBe(201);
+
+		expect(response.body).toEqual({
+			createdAt: expect.anything(),
+			id: expect.anything(),
+			key: "premium-discount-group",
+			lastModifiedAt: expect.anything(),
+			name: {
+				"en-GB": "Premium Discount Group",
+			},
+			description: {
+				"en-GB": "A discount group for premium customers",
+			},
+			sortOrder: "0.5",
+			version: 1,
+		});
+	});
+
+	test("Get discount group", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "test-discount-group",
+			name: {
+				"en-GB": "Test Discount Group",
+			},
+			sortOrder: "0.1",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const response = await supertest(ctMock.app).get(
+			`/dummy/discount-groups/${createResponse.body.id}`,
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
+
+	test("Get discount group by key", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "key-discount-group",
+			name: {
+				"en-GB": "Key Discount Group",
+			},
+			sortOrder: "0.2",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const response = await supertest(ctMock.app).get(
+			"/dummy/discount-groups/key=key-discount-group",
+		);
+
+		expect(response.status).toBe(200);
+		expect(response.body).toEqual(createResponse.body);
+	});
+
+	test("Query discount groups", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "query-discount-group",
+			name: {
+				"en-GB": "Query Discount Group",
+			},
+			sortOrder: "0.3",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const response = await supertest(ctMock.app).get("/dummy/discount-groups");
+
+		expect(response.status).toBe(200);
+		expect(response.body.count).toBeGreaterThan(0);
+		expect(response.body.results).toContainEqual(createResponse.body);
+	});
+
+	test("Update discount group - setName", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "update-name-group",
+			name: {
+				"en-GB": "Original Name",
+			},
+			sortOrder: "0.4",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const updateResponse = await supertest(ctMock.app)
+			.post(`/dummy/discount-groups/${createResponse.body.id}`)
+			.send({
+				version: createResponse.body.version,
+				actions: [
+					{
+						action: "setName",
+						name: {
+							"en-GB": "Updated Name",
+							de: "Aktualisierter Name",
+						},
+					},
+				],
+			});
+
+		expect(updateResponse.status).toBe(200);
+		expect(updateResponse.body.name).toEqual({
+			"en-GB": "Updated Name",
+			de: "Aktualisierter Name",
+		});
+		expect(updateResponse.body.version).toBe(2);
+	});
+
+	test("Update discount group - setDescription", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "update-description-group",
+			name: {
+				"en-GB": "Test Group",
+			},
+			sortOrder: "0.5",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const updateResponse = await supertest(ctMock.app)
+			.post(`/dummy/discount-groups/${createResponse.body.id}`)
+			.send({
+				version: createResponse.body.version,
+				actions: [
+					{
+						action: "setDescription",
+						description: {
+							"en-GB": "New description",
+							de: "Neue Beschreibung",
+						},
+					},
+				],
+			});
+
+		expect(updateResponse.status).toBe(200);
+		expect(updateResponse.body.description).toEqual({
+			"en-GB": "New description",
+			de: "Neue Beschreibung",
+		});
+		expect(updateResponse.body.version).toBe(2);
+	});
+
+	test("Update discount group - setKey", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "original-key",
+			name: {
+				"en-GB": "Test Group",
+			},
+			sortOrder: "0.6",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const updateResponse = await supertest(ctMock.app)
+			.post(`/dummy/discount-groups/${createResponse.body.id}`)
+			.send({
+				version: createResponse.body.version,
+				actions: [
+					{
+						action: "setKey",
+						key: "updated-key",
+					},
+				],
+			});
+
+		expect(updateResponse.status).toBe(200);
+		expect(updateResponse.body.key).toBe("updated-key");
+		expect(updateResponse.body.version).toBe(2);
+	});
+
+	test("Update discount group - setSortOrder", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "sort-order-group",
+			name: {
+				"en-GB": "Sort Order Group",
+			},
+			sortOrder: "0.1",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const updateResponse = await supertest(ctMock.app)
+			.post(`/dummy/discount-groups/${createResponse.body.id}`)
+			.send({
+				version: createResponse.body.version,
+				actions: [
+					{
+						action: "setSortOrder",
+						sortOrder: "0.9",
+					},
+				],
+			});
+
+		expect(updateResponse.status).toBe(200);
+		expect(updateResponse.body.sortOrder).toBe("0.9");
+		expect(updateResponse.body.version).toBe(2);
+	});
+
+	test("Delete discount group", async () => {
+		const draft: DiscountGroupDraft = {
+			key: "delete-group",
+			name: {
+				"en-GB": "Delete Group",
+			},
+			sortOrder: "0.7",
+		};
+		const createResponse = await supertest(ctMock.app)
+			.post("/dummy/discount-groups")
+			.send(draft);
+
+		expect(createResponse.status).toBe(201);
+
+		const deleteResponse = await supertest(ctMock.app)
+			.delete(`/dummy/discount-groups/${createResponse.body.id}`)
+			.query({ version: createResponse.body.version });
+
+		expect(deleteResponse.status).toBe(200);
+		expect(deleteResponse.body).toEqual(createResponse.body);
+
+		const getResponse = await supertest(ctMock.app).get(
+			`/dummy/discount-groups/${createResponse.body.id}`,
+		);
+
+		expect(getResponse.status).toBe(404);
+	});
+});

package/src/services/discount-group.ts

@@ -0,0 +1,16 @@
+import type { Router } from "express";
+import type { DiscountGroupRepository } from "../repositories/discount-group/index";
+import AbstractService from "./abstract";
+
+export class DiscountGroupService extends AbstractService {
+	public repository: DiscountGroupRepository;
+
+	constructor(parent: Router, repository: DiscountGroupRepository) {
+		super(parent);
+		this.repository = repository;
+	}
+
+	getBasePath() {
+		return "discount-groups";
+	}
+}

package/src/services/index.ts

@@ -11,6 +11,7 @@ import { CustomObjectService } from "./custom-object";
 import { CustomerService } from "./customer";
 import { CustomerGroupService } from "./customer-group";
 import { DiscountCodeService } from "./discount-code";
+import { DiscountGroupService } from "./discount-group";
 import { ExtensionServices } from "./extension";
 import { InventoryEntryService } from "./inventory-entry";
 import { MyBusinessUnitService } from "./my-business-unit";
@@ -29,6 +30,8 @@ import { ProductTypeService } from "./product-type";
 import { QuoteService } from "./quote";
 import { QuoteRequestService } from "./quote-request";
 import { StagedQuoteService } from "./quote-staged";
+import { RecurrencePolicyService } from "./recurrence-policy";
+import { RecurringOrderService } from "./recurring-order";
 import { ReviewService } from "./reviews";
 import { ShippingMethodService } from "./shipping-method";
 import { ShoppingListService } from "./shopping-list";
@@ -54,6 +57,7 @@ export const createServices = (
 	channel: new ChannelService(router, repos.channel),
 	"customer-group": new CustomerGroupService(router, repos["customer-group"]),
 	"discount-code": new DiscountCodeService(router, repos["discount-code"]),
+	"discount-group": new DiscountGroupService(router, repos["discount-group"]),
 	extension: new ExtensionServices(router, repos.extension),
 	"inventory-entry": new InventoryEntryService(
 		router,
@@ -98,6 +102,14 @@ export const createServices = (
 	),
 	quotes: new QuoteService(router, repos.quote),
 	"quote-request": new QuoteRequestService(router, repos["quote-request"]),
+	"recurrence-policy": new RecurrencePolicyService(
+		router,
+		repos["recurrence-policy"],
+	),
+	"recurring-order": new RecurringOrderService(
+		router,
+		repos["recurring-order"],
+	),
 	reviews: new ReviewService(router, repos.review),
 	"shopping-list": new ShoppingListService(router, repos["shopping-list"]),
 	"staged-quote": new StagedQuoteService(router, repos["staged-quote"]),

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

@@ -46,6 +46,7 @@ describe("MyCart", () => {
 			lineItems: [],
 			customLineItems: [],
 			shipping: [],
+			priceRoundingMode: "HalfEven",
 			shippingMode: "Single",
 			totalPrice: {
 				type: "centPrecision",

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

@@ -46,6 +46,7 @@ describe("MyPayment", () => {
 				centAmount: 1337,
 			},
 			paymentStatus: {},
+			paymentMethodInfo: {},
 			transactions: [],
 			interfaceInteractions: [],
 			custom: {

package/src/services/payment.test.ts

@@ -46,6 +46,7 @@ describe("Payment", () => {
 				centAmount: 1337,
 			},
 			paymentStatus: {},
+			paymentMethodInfo: {},
 			transactions: [],
 			interfaceInteractions: [],
 			custom: {