@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/repositories/quote-request.ts

@@ -1,28 +1,16 @@
 import type {
 	QuoteRequest,
 	QuoteRequestDraft,
-	QuoteRequestUpdateAction,
-} from '@commercetools/platform-sdk'
-import type { Writable } from '../types.js'
-import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
+} from "@commercetools/platform-sdk";
+import { AbstractStorage } from "~src/storage";
+import { AbstractResourceRepository, RepositoryContext } from "./abstract";
 
-export class QuoteRequestRepository extends AbstractResourceRepository<'quote-request'> {
-	getTypeId() {
-		return 'quote-request' as const
+export class QuoteRequestRepository extends AbstractResourceRepository<"quote-request"> {
+	constructor(storage: AbstractStorage) {
+		super("quote-request", storage);
 	}
 
 	create(context: RepositoryContext, draft: QuoteRequestDraft): QuoteRequest {
-		throw new Error('not implemented')
+		throw new Error("not implemented");
 	}
-
-	actions: Partial<
-		Record<
-			QuoteRequestUpdateAction['action'],
-			(
-				context: RepositoryContext,
-				resource: Writable<QuoteRequest>,
-				action: any
-			) => void
-		>
-	> = {}
 }

package/src/repositories/quote.ts

@@ -1,28 +1,13 @@
-import type {
-	Quote,
-	QuoteDraft,
-	QuoteUpdateAction,
-} from '@commercetools/platform-sdk'
-import type { Writable } from '../types.js'
-import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
+import type { Quote, QuoteDraft } from "@commercetools/platform-sdk";
+import { AbstractStorage } from "~src/storage";
+import { AbstractResourceRepository, RepositoryContext } from "./abstract";
 
-export class QuoteRepository extends AbstractResourceRepository<'quote'> {
-	getTypeId() {
-		return 'quote' as const
+export class QuoteRepository extends AbstractResourceRepository<"quote"> {
+	constructor(storage: AbstractStorage) {
+		super("quote", storage);
 	}
 
 	create(context: RepositoryContext, draft: QuoteDraft): Quote {
-		throw new Error('not implemented')
+		throw new Error("not implemented");
 	}
-
-	actions: Partial<
-		Record<
-			QuoteUpdateAction['action'],
-			(
-				context: RepositoryContext,
-				resource: Writable<Quote>,
-				action: any
-			) => void
-		>
-	> = {}
 }

package/src/repositories/review.ts

@@ -3,24 +3,23 @@ import {
 	ProductReference,
 	type Review,
 	type ReviewDraft,
-	type ReviewUpdateAction,
 	type StateReference,
-} 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 { AbstractStorage } from "~src/storage";
+import { getBaseResourceProperties } from "../helpers";
+import { AbstractResourceRepository, RepositoryContext } from "./abstract";
 import {
 	createCustomFields,
 	getReferenceFromResourceIdentifier,
-} from './helpers.js'
+} from "./helpers";
 
-export class ReviewRepository extends AbstractResourceRepository<'review'> {
-	getTypeId() {
-		return 'review' as const
+export class ReviewRepository extends AbstractResourceRepository<"review"> {
+	constructor(storage: AbstractStorage) {
+		super("review", storage);
 	}
 
 	create(context: RepositoryContext, draft: ReviewDraft): Review {
-		if (!draft.target) throw new Error('Missing target')
+		if (!draft.target) throw new Error("Missing target");
 		const resource: Review = {
 			...getBaseResourceProperties(),
 
@@ -34,7 +33,7 @@ export class ReviewRepository extends AbstractResourceRepository<'review'> {
 				? getReferenceFromResourceIdentifier<StateReference>(
 						draft.state,
 						context.projectKey,
-						this._storage
+						this._storage,
 					)
 				: undefined,
 			target: draft.target
@@ -46,21 +45,9 @@ export class ReviewRepository extends AbstractResourceRepository<'review'> {
 			custom: createCustomFields(
 				draft.custom,
 				context.projectKey,
-				this._storage
+				this._storage,
 			),
-		}
-		this.saveNew(context, resource)
-		return resource
+		};
+		return this.saveNew(context, resource);
 	}
-
-	actions: Partial<
-		Record<
-			ReviewUpdateAction['action'],
-			(
-				context: RepositoryContext,
-				resource: Writable<Review>,
-				action: any
-			) => void
-		>
-	> = {}
 }

package/src/repositories/shipping-method/actions.ts

@@ -0,0 +1,198 @@
+import {
+	ShippingMethodChangeTaxCategoryAction,
+	ShippingMethodRemoveShippingRateAction,
+	type ShippingMethod,
+	type ShippingMethodAddShippingRateAction,
+	type ShippingMethodAddZoneAction,
+	type ShippingMethodChangeIsDefaultAction,
+	type ShippingMethodChangeNameAction,
+	type ShippingMethodRemoveZoneAction,
+	type ShippingMethodSetCustomFieldAction,
+	type ShippingMethodSetCustomTypeAction,
+	type ShippingMethodSetDescriptionAction,
+	type ShippingMethodSetKeyAction,
+	type ShippingMethodSetLocalizedDescriptionAction,
+	type ShippingMethodSetLocalizedNameAction,
+	type ShippingMethodSetPredicateAction,
+	type ShippingMethodUpdateAction,
+	type ZoneReference,
+} from "@commercetools/platform-sdk";
+import deepEqual from "deep-equal";
+import type { Writable } from "../../types";
+import {
+	AbstractUpdateHandler,
+	RepositoryContext,
+	UpdateHandlerInterface,
+} from "../abstract";
+import {
+	createCustomFields,
+	getReferenceFromResourceIdentifier,
+} from "../helpers";
+import { transformShippingRate } from "./helpers";
+
+export class ShippingMethodUpdateHandler
+	extends AbstractUpdateHandler
+	implements UpdateHandlerInterface<ShippingMethod, ShippingMethodUpdateAction>
+{
+	changeTaxCategory: (
+		context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		action: ShippingMethodChangeTaxCategoryAction,
+	) => void;
+
+	addShippingRate(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ shippingRate, zone }: ShippingMethodAddShippingRateAction,
+	) {
+		const rate = transformShippingRate(shippingRate);
+
+		resource.zoneRates.forEach((zoneRate) => {
+			if (zoneRate.zone.id === zone.id) {
+				zoneRate.shippingRates.push(rate);
+				return;
+			}
+		});
+		resource.zoneRates.push({
+			zone: {
+				typeId: "zone",
+				id: zone.id!,
+			},
+			shippingRates: [rate],
+		});
+	}
+
+	addZone(
+		context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ zone }: ShippingMethodAddZoneAction,
+	) {
+		const zoneReference = getReferenceFromResourceIdentifier<ZoneReference>(
+			zone,
+			context.projectKey,
+			this._storage,
+		);
+
+		if (resource.zoneRates === undefined) {
+			resource.zoneRates = [];
+		}
+
+		resource.zoneRates.push({
+			zone: zoneReference,
+			shippingRates: [],
+		});
+	}
+
+	changeIsDefault(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ isDefault }: ShippingMethodChangeIsDefaultAction,
+	) {
+		resource.isDefault = isDefault;
+	}
+
+	changeName(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ name }: ShippingMethodChangeNameAction,
+	) {
+		resource.name = name;
+	}
+
+	removeShippingRate(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ shippingRate, zone }: ShippingMethodRemoveShippingRateAction,
+	) {
+		const rate = transformShippingRate(shippingRate);
+
+		resource.zoneRates.forEach((zoneRate) => {
+			if (zoneRate.zone.id === zone.id) {
+				zoneRate.shippingRates = zoneRate.shippingRates.filter(
+					(otherRate) => !deepEqual(rate, otherRate),
+				);
+			}
+		});
+	}
+
+	removeZone(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ zone }: ShippingMethodRemoveZoneAction,
+	) {
+		resource.zoneRates = resource.zoneRates.filter(
+			(zoneRate) => zoneRate.zone.id !== zone.id,
+		);
+	}
+
+	setCustomField(
+		context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ name, value }: ShippingMethodSetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			return;
+		}
+		if (value === null) {
+			delete resource.custom.fields[name];
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
+
+	setCustomType(
+		context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ type, fields }: ShippingMethodSetCustomTypeAction,
+	) {
+		if (type) {
+			resource.custom = createCustomFields(
+				{ type, fields },
+				context.projectKey,
+				this._storage,
+			);
+		} else {
+			resource.custom = undefined;
+		}
+	}
+
+	setDescription(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ description }: ShippingMethodSetDescriptionAction,
+	) {
+		resource.description = description;
+	}
+
+	setKey(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ key }: ShippingMethodSetKeyAction,
+	) {
+		resource.key = key;
+	}
+
+	setLocalizedDescription(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ localizedDescription }: ShippingMethodSetLocalizedDescriptionAction,
+	) {
+		resource.localizedDescription = localizedDescription;
+	}
+
+	setLocalizedName(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ localizedName }: ShippingMethodSetLocalizedNameAction,
+	) {
+		resource.localizedName = localizedName;
+	}
+
+	setPredicate(
+		_context: RepositoryContext,
+		resource: Writable<ShippingMethod>,
+		{ predicate }: ShippingMethodSetPredicateAction,
+	) {
+		resource.predicate = predicate;
+	}
+}

package/src/repositories/shipping-method/helpers.ts

@@ -0,0 +1,10 @@
+import { ShippingRate, ShippingRateDraft } from "@commercetools/platform-sdk";
+import { createTypedMoney } from "../helpers";
+
+export const transformShippingRate = (
+	rate: ShippingRateDraft,
+): ShippingRate => ({
+	price: createTypedMoney(rate.price),
+	freeAbove: rate.freeAbove && createTypedMoney(rate.freeAbove),
+	tiers: rate.tiers || [],
+});

package/src/repositories/shipping-method/index.ts

@@ -0,0 +1,138 @@
+import {
+	InvalidOperationError,
+	type ShippingMethod,
+	type ShippingMethodDraft,
+	type ZoneRate,
+	type ZoneRateDraft,
+	type ZoneReference,
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "~src/exceptions";
+import { getBaseResourceProperties } from "../../helpers";
+import { markMatchingShippingRate } from "../../shippingCalculator";
+import { AbstractStorage } from "../../storage/abstract";
+import {
+	AbstractResourceRepository,
+	GetParams,
+	RepositoryContext,
+} from "../abstract";
+import {
+	createCustomFields,
+	getReferenceFromResourceIdentifier,
+} from "../helpers";
+import { ShippingMethodUpdateHandler } from "./actions";
+import { transformShippingRate } from "./helpers";
+
+export class ShippingMethodRepository extends AbstractResourceRepository<"shipping-method"> {
+	constructor(storage: AbstractStorage) {
+		super("shipping-method", storage);
+		this.actions = new ShippingMethodUpdateHandler(storage);
+	}
+
+	create(
+		context: RepositoryContext,
+		draft: ShippingMethodDraft,
+	): ShippingMethod {
+		const resource: ShippingMethod = {
+			...getBaseResourceProperties(),
+			...draft,
+			taxCategory: getReferenceFromResourceIdentifier(
+				draft.taxCategory,
+				context.projectKey,
+				this._storage,
+			),
+			zoneRates: draft.zoneRates?.map((z) =>
+				this._transformZoneRateDraft(context, z),
+			),
+			custom: createCustomFields(
+				draft.custom,
+				context.projectKey,
+				this._storage,
+			),
+		};
+		return this.saveNew(context, resource);
+	}
+
+	/*
+	 * Retrieves all the ShippingMethods that can ship to the shipping address of
+	 * the given Cart. Each ShippingMethod contains exactly one ShippingRate with
+	 * the flag isMatching set to true. This ShippingRate is used when the
+	 * ShippingMethod is added to the Cart.
+	 */
+	public matchingCart(
+		context: RepositoryContext,
+		cartId: string,
+		params: GetParams = {},
+	) {
+		const cart = this._storage.get(context.projectKey, "cart", cartId);
+		if (!cart) {
+			return undefined;
+		}
+
+		if (!cart.shippingAddress?.country) {
+			throw new CommercetoolsError<InvalidOperationError>({
+				code: "InvalidOperation",
+				message: `The cart with ID '${cart.id}' does not have a shipping address set.`,
+			});
+		}
+
+		// Get all shipping methods that have a zone that matches the shipping address
+		const zones = this._storage.query<"zone">(context.projectKey, "zone", {
+			where: [`locations(country="${cart.shippingAddress.country}"))`],
+			limit: 100,
+		});
+		const zoneIds = zones.results.map((zone) => zone.id);
+		const shippingMethods = this.query(context, {
+			"where": [
+				`zoneRates(zone(id in (:zoneIds)))`,
+				`zoneRates(shippingRates(price(currencyCode="${cart.totalPrice.currencyCode}")))`,
+			],
+			"var.zoneIds": zoneIds,
+			"expand": params.expand,
+		});
+
+		// Make sure that each shipping method has exactly one shipping rate and
+		// that the shipping rate is marked as matching
+		const results = shippingMethods.results
+			.map((shippingMethod) => {
+				// Iterate through the zoneRates, process the shipping rates and filter
+				// out all zoneRates which have no matching shipping rates left
+				const rates = shippingMethod.zoneRates
+					.map((zoneRate) => ({
+						zone: zoneRate.zone,
+
+						// Iterate through the shippingRates and mark the matching ones
+						// then we filter out the non-matching ones
+						shippingRates: zoneRate.shippingRates
+							.map((rate) => markMatchingShippingRate(cart, rate))
+							.filter((rate) => rate.isMatching),
+					}))
+					.filter((zoneRate) => zoneRate.shippingRates.length > 0);
+
+				return {
+					...shippingMethod,
+					zoneRates: rates,
+				};
+			})
+			.filter((shippingMethod) => shippingMethod.zoneRates.length > 0);
+
+		return {
+			...shippingMethods,
+			results: results,
+		};
+	}
+
+	private _transformZoneRateDraft(
+		context: RepositoryContext,
+		draft: ZoneRateDraft,
+	): ZoneRate {
+		return {
+			...draft,
+			zone: getReferenceFromResourceIdentifier<ZoneReference>(
+				draft.zone,
+				context.projectKey,
+				this._storage,
+			),
+			shippingRates: draft.shippingRates?.map(transformShippingRate),
+		};
+	}
+}