@labdigital/commercetools-mock 2.66.0 → 3.0.0-beta.0

package/src/repositories/quote/actions.ts

@@ -22,46 +22,25 @@ export class QuoteUpdateHandler
 		resource: Quote,
 		{ name, value }: QuoteSetCustomFieldAction,
 	) {
-		if (!resource.custom) {
-			throw new Error("Resource has no custom field");
-		}
-		resource.custom.fields[name] = value;
+		this._setCustomFieldValues(resource, { name, value });
 	}
 
-	setCustomType(
+	async setCustomType(
 		context: RepositoryContext,
 		resource: Writable<Quote>,
 		{ type, fields }: QuoteSetCustomTypeAction,
 	) {
-		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 || {},
-			};
-		}
+		await this._setCustomType(context, resource, { type, fields });
 	}
 
-	transitionState(
+	async transitionState(
 		context: RepositoryContext,
 		resource: Writable<Quote>,
 		{ state, force }: QuoteTransitionStateAction,
 	) {
 		let stateReference: StateReference | undefined;
 		if (state) {
-			stateReference = getReferenceFromResourceIdentifier<StateReference>(
+			stateReference = await getReferenceFromResourceIdentifier<StateReference>(
 				state,
 				context.projectKey,
 				this._storage,
@@ -77,7 +56,5 @@ export class QuoteUpdateHandler
 				400,
 			);
 		}
-
-		return resource;
 	}
 }

package/src/repositories/quote/index.ts

@@ -1,6 +1,12 @@
-import type { Quote, QuoteDraft } from "@commercetools/platform-sdk";
+import type {
+	InvalidOperationError,
+	Quote,
+	QuoteDraft,
+} from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
+import { CommercetoolsError } from "#src/exceptions.ts";
 import { getBaseResourceProperties } from "#src/helpers.ts";
+import { QuoteDraftSchema } from "#src/schemas/generated/quote.ts";
 import type { RepositoryContext } from "../abstract.ts";
 import { AbstractResourceRepository } from "../abstract.ts";
 import { QuoteUpdateHandler } from "./actions.ts";
@@ -9,25 +15,42 @@ export class QuoteRepository extends AbstractResourceRepository<"quote"> {
 	constructor(config: Config) {
 		super("quote", config);
 		this.actions = new QuoteUpdateHandler(config.storage);
+		this.draftSchema = QuoteDraftSchema;
 	}
 
-	create(context: RepositoryContext, draft: QuoteDraft): Quote {
-		const staged = this._storage.getByResourceIdentifier<"staged-quote">(
+	async create(context: RepositoryContext, draft: QuoteDraft): Promise<Quote> {
+		const staged = await this._storage.getByResourceIdentifier<"staged-quote">(
 			context.projectKey,
 			draft.stagedQuote,
 		);
 
-		const cart = this._storage.getByResourceIdentifier<"cart">(
+		if (!staged.quotationCart) {
+			throw new CommercetoolsError<InvalidOperationError>(
+				{
+					code: "InvalidOperation",
+					message: "Staged quote does not have a quotation cart",
+				},
+				400,
+			);
+		}
+
+		const cart = await this._storage.getByResourceIdentifier<"cart">(
 			context.projectKey,
 			staged.quotationCart,
 		);
 
 		if (!cart.customerId) {
-			throw new Error("Cart does not have a customer");
+			throw new CommercetoolsError<InvalidOperationError>(
+				{
+					code: "InvalidOperation",
+					message: "Cart does not have a customer",
+				},
+				400,
+			);
 		}
 
 		const resource: Quote = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			quoteState: "Accepted",
 			quoteRequest: staged.quoteRequest,
 			lineItems: cart.lineItems,

package/src/repositories/quote-request/actions.ts

@@ -23,46 +23,25 @@ export class QuoteRequestUpdateHandler
 		resource: QuoteRequest,
 		{ name, value }: QuoteRequestSetCustomFieldAction,
 	) {
-		if (!resource.custom) {
-			throw new Error("Resource has no custom field");
-		}
-		resource.custom.fields[name] = value;
+		this._setCustomFieldValues(resource, { name, value });
 	}
 
-	setCustomType(
+	async setCustomType(
 		context: RepositoryContext,
 		resource: Writable<QuoteRequest>,
 		{ type, fields }: QuoteRequestSetCustomTypeAction,
 	) {
-		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 || {},
-			};
-		}
+		await this._setCustomType(context, resource, { type, fields });
 	}
 
-	transitionState(
+	async transitionState(
 		context: RepositoryContext,
 		resource: Writable<QuoteRequest>,
 		{ state, force }: QuoteRequestTransitionStateAction,
 	) {
 		let stateReference: StateReference | undefined;
 		if (state) {
-			stateReference = getReferenceFromResourceIdentifier<StateReference>(
+			stateReference = await getReferenceFromResourceIdentifier<StateReference>(
 				state,
 				context.projectKey,
 				this._storage,
@@ -78,7 +57,5 @@ export class QuoteRequestUpdateHandler
 				400,
 			);
 		}
-
-		return resource;
 	}
 }

package/src/repositories/quote-request/index.test.ts

@@ -132,10 +132,10 @@ describe("QuoteRequest repository", () => {
 			},
 		};
 
-		storage.add("dummy", "cart", cart);
+		await storage.add("dummy", "cart", cart);
 		const ctx = { projectKey: "dummy" };
 
-		const result = repository.create(ctx, {
+		const result = await repository.create(ctx, {
 			cart: {
 				id: cart.id,
 				typeId: "cart",
@@ -144,7 +144,7 @@ describe("QuoteRequest repository", () => {
 		});
 		expect(result.cart?.id).toBe(cart.id);
 
-		const items = repository.query(ctx);
+		const items = await repository.query(ctx);
 		expect(items.count).toBe(1);
 
 		expect(result.billingAddress).toEqual(cart.billingAddress);

package/src/repositories/quote-request/index.ts

@@ -2,12 +2,16 @@ import assert from "node:assert";
 import type {
 	Cart,
 	CartReference,
+	InvalidOperationError,
 	MyQuoteRequestDraft,
 	QuoteRequest,
 	QuoteRequestDraft,
+	ResourceNotFoundError,
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
+import { CommercetoolsError } from "#src/exceptions.ts";
 import { getBaseResourceProperties } from "#src/helpers.ts";
+import { QuoteRequestDraftSchema } from "#src/schemas/generated/quote-request.ts";
 import type { RepositoryContext } from "../abstract.ts";
 import { AbstractResourceRepository } from "../abstract.ts";
 import { QuoteRequestUpdateHandler } from "./actions.ts";
@@ -16,42 +20,58 @@ export class QuoteRequestRepository extends AbstractResourceRepository<"quote-re
 	constructor(config: Config) {
 		super("quote-request", config);
 		this.actions = new QuoteRequestUpdateHandler(config.storage);
+		this.draftSchema = QuoteRequestDraftSchema;
 	}
 
-	create(
+	async create(
 		context: RepositoryContext,
 		draft: QuoteRequestDraft | MyQuoteRequestDraft,
-	): QuoteRequest {
+	): Promise<QuoteRequest> {
 		// Handle the 'my' version of the draft
 		if ("cartId" in draft) {
-			return this.createFromCart(context, {
+			return await this.createFromCart(context, {
 				id: draft.cartId,
 				typeId: "cart",
 			});
 		}
 
 		assert(draft.cart, "draft.cart is missing");
-		return this.createFromCart(context, {
+		return await this.createFromCart(context, {
 			id: draft.cart.id!,
 			typeId: "cart",
 		});
 	}
 
-	createFromCart(context: RepositoryContext, cartReference: CartReference) {
-		const cart = this._storage.getByResourceIdentifier(
+	async createFromCart(
+		context: RepositoryContext,
+		cartReference: CartReference,
+	) {
+		const cart = (await this._storage.getByResourceIdentifier(
 			context.projectKey,
 			cartReference,
-		) as Cart | null;
+		)) as Cart | null;
 		if (!cart) {
-			throw new Error("Cannot find cart");
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: "Cannot find cart",
+				},
+				404,
+			);
 		}
 
 		if (!cart.customerId) {
-			throw new Error("Cart does not have a customer");
+			throw new CommercetoolsError<InvalidOperationError>(
+				{
+					code: "InvalidOperation",
+					message: "Cart does not have a customer",
+				},
+				400,
+			);
 		}
 
 		const resource: QuoteRequest = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			billingAddress: cart.billingAddress,
 			cart: cartReference,
 			country: cart.country,
@@ -75,6 +95,6 @@ export class QuoteRequestRepository extends AbstractResourceRepository<"quote-re
 			totalPrice: cart.totalPrice,
 			store: cart.store,
 		};
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }

package/src/repositories/quote-staged/actions.ts

@@ -23,46 +23,25 @@ export class StagedQuoteUpdateHandler
 		resource: StagedQuote,
 		{ name, value }: StagedQuoteSetCustomFieldAction,
 	) {
-		if (!resource.custom) {
-			throw new Error("Resource has no custom field");
-		}
-		resource.custom.fields[name] = value;
+		this._setCustomFieldValues(resource, { name, value });
 	}
 
-	setCustomType(
+	async setCustomType(
 		context: RepositoryContext,
 		resource: Writable<StagedQuote>,
 		{ type, fields }: StagedQuoteSetCustomTypeAction,
 	) {
-		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 || {},
-			};
-		}
+		await this._setCustomType(context, resource, { type, fields });
 	}
 
-	transitionState(
+	async transitionState(
 		context: RepositoryContext,
 		resource: Writable<StagedQuote>,
 		{ state, force }: StagedQuoteTransitionStateAction,
 	) {
 		let stateReference: StateReference | undefined;
 		if (state) {
-			stateReference = getReferenceFromResourceIdentifier<StateReference>(
+			stateReference = await getReferenceFromResourceIdentifier<StateReference>(
 				state,
 				context.projectKey,
 				this._storage,
@@ -78,7 +57,5 @@ export class StagedQuoteUpdateHandler
 				400,
 			);
 		}
-
-		return resource;
 	}
 }

package/src/repositories/quote-staged/index.ts

@@ -1,9 +1,12 @@
 import type {
+	ResourceNotFoundError,
 	StagedQuote,
 	StagedQuoteDraft,
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
+import { CommercetoolsError } from "#src/exceptions.ts";
 import { getBaseResourceProperties } from "#src/helpers.ts";
+import { StagedQuoteDraftSchema } from "#src/schemas/generated/staged-quote.ts";
 import type { RepositoryContext } from "../abstract.ts";
 import { AbstractResourceRepository } from "../abstract.ts";
 import { StagedQuoteUpdateHandler } from "./actions.ts";
@@ -12,25 +15,36 @@ export class StagedQuoteRepository extends AbstractResourceRepository<"staged-qu
 	constructor(config: Config) {
 		super("staged-quote", config);
 		this.actions = new StagedQuoteUpdateHandler(config.storage);
+		this.draftSchema = StagedQuoteDraftSchema;
 	}
 
-	create(context: RepositoryContext, draft: StagedQuoteDraft): StagedQuote {
-		const quoteRequest = this._storage.getByResourceIdentifier<"quote-request">(
-			context.projectKey,
-			draft.quoteRequest,
-		);
+	async create(
+		context: RepositoryContext,
+		draft: StagedQuoteDraft,
+	): Promise<StagedQuote> {
+		const quoteRequest =
+			await this._storage.getByResourceIdentifier<"quote-request">(
+				context.projectKey,
+				draft.quoteRequest,
+			);
 
 		if (!quoteRequest.cart) {
-			throw new Error("Cannot find quote request");
+			throw new CommercetoolsError<ResourceNotFoundError>(
+				{
+					code: "ResourceNotFound",
+					message: "Cannot find quote request",
+				},
+				404,
+			);
 		}
 
-		const cart = this._storage.getByResourceIdentifier<"cart">(
+		const cart = await this._storage.getByResourceIdentifier<"cart">(
 			context.projectKey,
 			quoteRequest.cart,
 		);
 
 		const resource: StagedQuote = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			stagedQuoteState: "InProgress",
 			quoteRequest: {
 				typeId: "quote-request",

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

@@ -4,6 +4,7 @@ import type {
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
 import { getBaseResourceProperties } from "#src/helpers.ts";
+import { RecurrencePolicyDraftSchema } from "#src/schemas/generated/recurrence-policy.ts";
 import {
 	AbstractResourceRepository,
 	type RepositoryContext,
@@ -14,19 +15,20 @@ export class RecurrencePolicyRepository extends AbstractResourceRepository<"recu
 	constructor(config: Config) {
 		super("recurrence-policy", config);
 		this.actions = new RecurrencePolicyUpdateHandler(config.storage);
+		this.draftSchema = RecurrencePolicyDraftSchema;
 	}
 
-	create(
+	async create(
 		context: RepositoryContext,
 		draft: RecurrencePolicyDraft,
-	): RecurrencePolicy {
+	): Promise<RecurrencePolicy> {
 		const resource: RecurrencePolicy = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			key: draft.key,
 			name: draft.name,
 			description: draft.description,
 			schedule: draft.schedule,
 		};
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }

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

@@ -25,40 +25,15 @@ export class RecurringOrderUpdateHandler
 		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;
-		}
+		this._setCustomFieldValues(resource, { name, value });
 	}
 
-	setCustomType(
+	async 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 || {},
-			};
-		}
+		await this._setCustomType(context, resource, { type, fields });
 	}
 
 	setExpiresAt(
@@ -81,14 +56,14 @@ export class RecurringOrderUpdateHandler
 		context: RepositoryContext,
 		resource: Writable<RecurringOrder>,
 		{
-			skipConfiguration,
+			skipConfigurationInputDraft,
 			updatedExpiresAt,
 		}: RecurringOrderSetOrderSkipConfigurationAction,
 	) {
-		if (skipConfiguration) {
+		if (skipConfigurationInputDraft) {
 			resource.skipConfiguration = {
-				type: skipConfiguration.type,
-				totalToSkip: skipConfiguration.totalToSkip,
+				type: skipConfigurationInputDraft.type,
+				totalToSkip: skipConfigurationInputDraft.totalToSkip,
 				skipped: 0,
 				lastSkippedAt: undefined,
 			};

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

@@ -5,6 +5,7 @@ import type {
 } from "@commercetools/platform-sdk";
 import type { Config } from "#src/config.ts";
 import { getBaseResourceProperties } from "#src/helpers.ts";
+import { RecurringOrderDraftSchema } from "#src/schemas/generated/recurring-order.ts";
 import {
 	AbstractResourceRepository,
 	type RepositoryContext,
@@ -16,23 +17,24 @@ export class RecurringOrderRepository extends AbstractResourceRepository<"recurr
 	constructor(config: Config) {
 		super("recurring-order", config);
 		this.actions = new RecurringOrderUpdateHandler(config.storage);
+		this.draftSchema = RecurringOrderDraftSchema;
 	}
 
-	create(
+	async create(
 		context: RepositoryContext,
 		draft: RecurringOrderDraft,
-	): RecurringOrder {
+	): Promise<RecurringOrder> {
 		assert(draft.cart, "draft.cart is missing");
 
 		const orderRepo = new OrderRepository(this.config);
 
-		const initialOrder = orderRepo.createFromCart(context, {
+		const initialOrder = await orderRepo.createFromCart(context, {
 			id: draft.cart.id!,
 			typeId: "cart",
 		});
 
 		const resource: RecurringOrder = {
-			...getBaseResourceProperties(),
+			...getBaseResourceProperties(context.clientId),
 			key: draft.key,
 			cart: {
 				typeId: "cart",
@@ -42,11 +44,11 @@ export class RecurringOrderRepository extends AbstractResourceRepository<"recurr
 				typeId: "order",
 				id: initialOrder.id,
 			},
-			startsAt: draft.startsAt,
+			startsAt: draft.startsAt ?? new Date().toISOString(),
 			expiresAt: draft.expiresAt,
 			recurringOrderState: "Active",
 			schedule: { type: "standard", intervalUnit: "month", value: 1 },
 		};
-		return this.saveNew(context, resource);
+		return await this.saveNew(context, resource);
 	}
 }