@labdigital/commercetools-mock 2.17.1 → 2.18.0

package/src/repositories/helpers.ts

@@ -1,5 +1,8 @@
 import {
 	AssociateRoleReference,
+	BusinessUnitKeyReference,
+	BusinessUnitReference,
+	BusinessUnitResourceIdentifier,
 	type Address,
 	type Associate,
 	type AssociateDraft,
@@ -26,50 +29,47 @@ import {
 	type Type,
 	type TypedMoney,
 	type _Money,
-	BusinessUnitResourceIdentifier,
-	BusinessUnitKeyReference,
-	BusinessUnitReference,
-} from '@commercetools/platform-sdk'
-import type { Request } from 'express'
-import { v4 as uuidv4 } from 'uuid'
-import { CommercetoolsError } from '../exceptions.js'
-import { AbstractStorage } from '../storage/index.js'
-import { type RepositoryContext } from './abstract.js'
+} from "@commercetools/platform-sdk";
+import type { Request } from "express";
+import { v4 as uuidv4 } from "uuid";
+import { CommercetoolsError } from "~src/exceptions";
+import { AbstractStorage } from "../storage";
+import { type RepositoryContext } from "./abstract";
 
 export const createAddress = (
 	base: BaseAddress | undefined,
 	projectKey: string,
-	storage: AbstractStorage
+	storage: AbstractStorage,
 ): Address | undefined => {
-	if (!base) return undefined
+	if (!base) return undefined;
 
 	if (!base?.country) {
-		throw new Error('Country is required')
+		throw new Error("Country is required");
 	}
 
 	return {
 		...base,
-	}
-}
+	};
+};
 
 export const createCustomFields = (
 	draft: CustomFieldsDraft | undefined,
 	projectKey: string,
-	storage: AbstractStorage
+	storage: AbstractStorage,
 ): CustomFields | undefined => {
-	if (!draft) return undefined
-	if (!draft.type) return undefined
-	if (!draft.type.typeId) return undefined
-	if (!draft.fields) return undefined
+	if (!draft) return undefined;
+	if (!draft.type) return undefined;
+	if (!draft.type.typeId) return undefined;
+	if (!draft.fields) return undefined;
 	const typeResource = storage.getByResourceIdentifier(
 		projectKey,
-		draft.type
-	) as Type
+		draft.type,
+	) as Type;
 
 	if (!typeResource) {
 		throw new Error(
-			`No type '${draft.type.typeId}' with id=${draft.type.id} or key=${draft.type.key}`
-		)
+			`No type '${draft.type.typeId}' with id=${draft.type.id} or key=${draft.type.key}`,
+		);
 	}
 
 	return {
@@ -78,241 +78,240 @@ export const createCustomFields = (
 			id: typeResource.id,
 		},
 		fields: draft.fields,
-	}
-}
+	};
+};
 
 export const createPrice = (draft: PriceDraft): Price => ({
 	id: uuidv4(),
 	value: createTypedMoney(draft.value),
-})
+});
 
 export const createCentPrecisionMoney = (value: _Money): CentPrecisionMoney => {
 	// Taken from https://docs.adyen.com/development-resources/currency-codes
-	let fractionDigits = 2
+	let fractionDigits = 2;
 	switch (value.currencyCode.toUpperCase()) {
-		case 'BHD':
-		case 'IQD':
-		case 'JOD':
-		case 'KWD':
-		case 'LYD':
-		case 'OMR':
-		case 'TND':
-			fractionDigits = 3
-			break
-		case 'CVE':
-		case 'DJF':
-		case 'GNF':
-		case 'IDR':
-		case 'JPY':
-		case 'KMF':
-		case 'KRW':
-		case 'PYG':
-		case 'RWF':
-		case 'UGX':
-		case 'VND':
-		case 'VUV':
-		case 'XAF':
-		case 'XOF':
-		case 'XPF':
-			fractionDigits = 0
-			break
+		case "BHD":
+		case "IQD":
+		case "JOD":
+		case "KWD":
+		case "LYD":
+		case "OMR":
+		case "TND":
+			fractionDigits = 3;
+			break;
+		case "CVE":
+		case "DJF":
+		case "GNF":
+		case "IDR":
+		case "JPY":
+		case "KMF":
+		case "KRW":
+		case "PYG":
+		case "RWF":
+		case "UGX":
+		case "VND":
+		case "VUV":
+		case "XAF":
+		case "XOF":
+		case "XPF":
+			fractionDigits = 0;
+			break;
 		default:
-			fractionDigits = 2
+			fractionDigits = 2;
 	}
 
 	if ((value as HighPrecisionMoney & HighPrecisionMoneyDraft).preciseAmount) {
-		throw new Error('HighPrecisionMoney not supported')
+		throw new Error("HighPrecisionMoney not supported");
 	}
 
 	return {
-		type: 'centPrecision',
+		type: "centPrecision",
 		// centAmont is only optional on HighPrecisionMoney, so this should never
 		// fallback to 0
 		centAmount: value.centAmount ?? 0,
 		currencyCode: value.currencyCode,
 		fractionDigits: fractionDigits,
-	}
-}
+	};
+};
 
 export const createTypedMoney = (value: _Money): TypedMoney => {
-	const result = createCentPrecisionMoney(value)
-	return result
-}
+	const result = createCentPrecisionMoney(value);
+	return result;
+};
 
 export const resolveStoreReference = (
 	ref: StoreResourceIdentifier | undefined,
 	projectKey: string,
-	storage: AbstractStorage
+	storage: AbstractStorage,
 ): StoreKeyReference | undefined => {
-	if (!ref) return undefined
-	const resource = storage.getByResourceIdentifier(projectKey, ref)
+	if (!ref) return undefined;
+	const resource = storage.getByResourceIdentifier(projectKey, ref);
 	if (!resource) {
-		throw new Error('No such store')
+		throw new Error("No such store");
 	}
 
-	const store = resource as Store
+	const store = resource as Store;
 	return {
-		typeId: 'store',
+		typeId: "store",
 		key: store.key,
-	}
-}
+	};
+};
 
 export const getReferenceFromResourceIdentifier = <T extends Reference>(
 	resourceIdentifier: ResourceIdentifier,
 	projectKey: string,
-	storage: AbstractStorage
+	storage: AbstractStorage,
 ): T => {
 	if (!resourceIdentifier.id && !resourceIdentifier.key) {
 		throw new CommercetoolsError<InvalidJsonInputError>(
 			{
-				code: 'InvalidJsonInput',
+				code: "InvalidJsonInput",
 				message: `${resourceIdentifier.typeId}: ResourceIdentifier requires an 'id' xor a 'key'`,
 				detailedErrorMessage: `ResourceIdentifier requires an 'id' xor a 'key'`,
 			},
-			400
-		)
+			400,
+		);
 	}
 
 	const resource = storage.getByResourceIdentifier(
 		projectKey,
-		resourceIdentifier
-	)
+		resourceIdentifier,
+	);
 	if (!resource) {
 		const errIdentifier = resourceIdentifier.key
 			? `key '${resourceIdentifier.key}'`
-			: `identifier '${resourceIdentifier.id}'`
+			: `identifier '${resourceIdentifier.id}'`;
 
 		throw new CommercetoolsError<ReferencedResourceNotFoundError>(
 			{
-				code: 'ReferencedResourceNotFound',
+				code: "ReferencedResourceNotFound",
 				// @ts-ignore
 				typeId: resourceIdentifier.typeId,
 				message: `The referenced object of type '${resourceIdentifier.typeId}' with '${errIdentifier}' was not found. It either doesn't exist, or it can't be accessed from this endpoint (e.g., if the endpoint filters by store or customer account).`,
 			},
-			400
-		)
+			400,
+		);
 	}
 
 	return {
 		typeId: resourceIdentifier.typeId,
 		id: resource?.id,
-	} as unknown as T
-}
+	} as unknown as T;
+};
 
 export const getStoreKeyReference = (
 	id: StoreResourceIdentifier,
 	projectKey: string,
-	storage: AbstractStorage
+	storage: AbstractStorage,
 ): StoreKeyReference => {
 	if (id.key) {
 		return {
-			typeId: 'store',
+			typeId: "store",
 			key: id.key,
-		}
+		};
 	}
 	const value = getReferenceFromResourceIdentifier<StoreReference>(
 		id,
 		projectKey,
-		storage
-	)
+		storage,
+	);
 
 	if (!value.obj?.key) {
-		throw new Error('No store found for reference')
+		throw new Error("No store found for reference");
 	}
 	return {
-		typeId: 'store',
+		typeId: "store",
 		key: value.obj?.key,
-	}
-}
+	};
+};
 
 export const getRepositoryContext = (request: Request): RepositoryContext => ({
 	projectKey: request.params.projectKey,
 	storeKey: request.params.storeKey,
-})
+});
 
 export const createAssociate = (
 	a: AssociateDraft,
 	projectKey: string,
-	storage: AbstractStorage
+	storage: AbstractStorage,
 ): Associate | undefined => {
-	if (!a) return undefined
+	if (!a) return undefined;
 
 	if (!a.associateRoleAssignments) {
-		throw new Error('AssociateRoleAssignments is required')
+		throw new Error("AssociateRoleAssignments is required");
 	}
 
 	return {
 		customer: getReferenceFromResourceIdentifier(
 			a.customer,
 			projectKey,
-			storage
+			storage,
 		),
 		associateRoleAssignments: a.associateRoleAssignments?.map(
 			(a: AssociateRoleAssignmentDraft): AssociateRoleAssignment => ({
 				associateRole: getAssociateRoleKeyReference(
 					a.associateRole,
 					projectKey,
-					storage
+					storage,
 				),
 				inheritance: a.inheritance as string,
-			})
+			}),
 		),
-		roles: a.roles as string[],
-	}
-}
+	};
+};
 
 export const getAssociateRoleKeyReference = (
 	id: AssociateRoleResourceIdentifier,
 	projectKey: string,
-	storage: AbstractStorage
+	storage: AbstractStorage,
 ): AssociateRoleKeyReference => {
 	if (id.key) {
 		return {
-			typeId: 'associate-role',
+			typeId: "associate-role",
 			key: id.key,
-		}
+		};
 	}
 
 	const value = getReferenceFromResourceIdentifier<AssociateRoleReference>(
 		id,
 		projectKey,
-		storage
-	)
+		storage,
+	);
 
 	if (!value.obj?.key) {
-		throw new Error('No associate-role found for reference')
+		throw new Error("No associate-role found for reference");
 	}
 
 	return {
-		typeId: 'associate-role',
+		typeId: "associate-role",
 		key: value.obj?.key,
-	}
-}
+	};
+};
 
 export const getBusinessUnitKeyReference = (
 	id: BusinessUnitResourceIdentifier,
 	projectKey: string,
-	storage: AbstractStorage
+	storage: AbstractStorage,
 ): BusinessUnitKeyReference => {
 	if (id.key) {
 		return {
-			typeId: 'business-unit',
+			typeId: "business-unit",
 			key: id.key,
-		}
+		};
 	}
 
 	const value = getReferenceFromResourceIdentifier<BusinessUnitReference>(
 		id,
 		projectKey,
-		storage
-	)
+		storage,
+	);
 
 	if (!value.obj?.key) {
-		throw new Error('No business-unit found for reference')
+		throw new Error("No business-unit found for reference");
 	}
 
 	return {
-		typeId: 'business-unit',
+		typeId: "business-unit",
 		key: value.obj?.key,
-	}
-}
+	};
+};

package/src/repositories/index.ts

@@ -1,82 +1,83 @@
-import { AbstractStorage } from '../storage/index.js'
-import { AssociateRoleRepository } from './associate-role.js'
-import { AttributeGroupRepository } from './attribute-group.js'
-import { BusinessUnitRepository } from './business-unit.js'
-import { CartRepository } from './cart.js'
-import { CartDiscountRepository } from './cart-discount.js'
-import { CategoryRepository } from './category.js'
-import { ChannelRepository } from './channel.js'
-import { CustomObjectRepository } from './custom-object.js'
-import { CustomerRepository } from './customer.js'
-import { CustomerGroupRepository } from './customer-group.js'
-import { DiscountCodeRepository } from './discount-code.js'
-import { ExtensionRepository } from './extension.js'
-import { InventoryEntryRepository } from './inventory-entry.js'
-import { MyOrderRepository } from './my-order.js'
-import { OrderRepository } from './order.js'
-import { OrderEditRepository } from './order-edit.js'
-import { PaymentRepository } from './payment.js'
-import { ProductRepository } from './product.js'
-import { ProductDiscountRepository } from './product-discount.js'
-import { ProductProjectionRepository } from './product-projection.js'
-import { ProductSelectionRepository } from './product-selection.js'
-import { ProductTypeRepository } from './product-type.js'
-import { ProjectRepository } from './project.js'
-import { QuoteRepository } from './quote.js'
-import { QuoteRequestRepository } from './quote-request.js'
-import { ReviewRepository } from './review.js'
-import { ShippingMethodRepository } from './shipping-method.js'
-import { ShoppingListRepository } from './shopping-list.js'
-import { StagedQuoteRepository } from './staged-quote.js'
-import { StandAlonePriceRepository } from './standalone-price.js'
-import { StateRepository } from './state.js'
-import { StoreRepository } from './store.js'
-import { SubscriptionRepository } from './subscription.js'
-import { TaxCategoryRepository } from './tax-category.js'
-import { TypeRepository } from './type.js'
-import { ZoneRepository } from './zone.js'
+import { AbstractStorage } from "../storage";
+import { AssociateRoleRepository } from "./associate-role";
+import { AttributeGroupRepository } from "./attribute-group";
+import { BusinessUnitRepository } from "./business-unit";
+import { CartRepository } from "./cart";
+import { CartDiscountRepository } from "./cart-discount";
+import { CategoryRepository } from "./category";
+import { ChannelRepository } from "./channel";
+import { CustomObjectRepository } from "./custom-object";
+import { CustomerRepository } from "./customer";
+import { CustomerGroupRepository } from "./customer-group";
+import { DiscountCodeRepository } from "./discount-code";
+import { ExtensionRepository } from "./extension";
+import { InventoryEntryRepository } from "./inventory-entry";
+import { MyCustomerRepository } from "./my-customer";
+import { MyOrderRepository } from "./my-order";
+import { OrderRepository } from "./order";
+import { OrderEditRepository } from "./order-edit";
+import { PaymentRepository } from "./payment";
+import { ProductRepository } from "./product";
+import { ProductDiscountRepository } from "./product-discount";
+import { ProductProjectionRepository } from "./product-projection";
+import { ProductSelectionRepository } from "./product-selection";
+import { ProductTypeRepository } from "./product-type";
+import { ProjectRepository } from "./project";
+import { QuoteRepository } from "./quote";
+import { QuoteRequestRepository } from "./quote-request";
+import { ReviewRepository } from "./review";
+import { ShippingMethodRepository } from "./shipping-method";
+import { ShoppingListRepository } from "./shopping-list";
+import { StagedQuoteRepository } from "./staged-quote";
+import { StandAlonePriceRepository } from "./standalone-price";
+import { StateRepository } from "./state";
+import { StoreRepository } from "./store";
+import { SubscriptionRepository } from "./subscription";
+import { TaxCategoryRepository } from "./tax-category";
+import { TypeRepository } from "./type";
+import { ZoneRepository } from "./zone";
 
-export type RepositoryMap = ReturnType<typeof createRepositories>
+export type RepositoryMap = ReturnType<typeof createRepositories>;
 
 export const createRepositories = (storage: AbstractStorage) => ({
-	'associate-role': new AssociateRoleRepository(storage),
-	'attribute-group': new AttributeGroupRepository(storage),
-	'business-unit': new BusinessUnitRepository(storage),
-	category: new CategoryRepository(storage),
-	cart: new CartRepository(storage),
-	'cart-discount': new CartDiscountRepository(storage),
-	customer: new CustomerRepository(storage),
-	channel: new ChannelRepository(storage),
-	'customer-group': new CustomerGroupRepository(storage),
-	'discount-code': new DiscountCodeRepository(storage),
-	extension: new ExtensionRepository(storage),
-	'inventory-entry': new InventoryEntryRepository(storage),
-	'key-value-document': new CustomObjectRepository(storage),
-	order: new OrderRepository(storage),
-	'order-edit': new OrderEditRepository(storage),
-	payment: new PaymentRepository(storage),
-	'my-cart': new CartRepository(storage),
-	'my-order': new MyOrderRepository(storage),
-	'my-customer': new CustomerRepository(storage),
-	'my-payment': new PaymentRepository(storage),
-	'my-shopping-list': new ShoppingListRepository(storage),
-	product: new ProductRepository(storage),
-	'product-type': new ProductTypeRepository(storage),
-	'product-discount': new ProductDiscountRepository(storage),
-	'product-projection': new ProductProjectionRepository(storage),
-	'product-selection': new ProductSelectionRepository(storage),
-	project: new ProjectRepository(storage),
-	review: new ReviewRepository(storage),
-	quote: new QuoteRepository(storage),
-	'quote-request': new QuoteRequestRepository(storage),
-	'shipping-method': new ShippingMethodRepository(storage),
-	'shopping-list': new ShoppingListRepository(storage),
-	'staged-quote': new StagedQuoteRepository(storage),
-	'standalone-price': new StandAlonePriceRepository(storage),
-	state: new StateRepository(storage),
-	store: new StoreRepository(storage),
-	subscription: new SubscriptionRepository(storage),
-	'tax-category': new TaxCategoryRepository(storage),
-	type: new TypeRepository(storage),
-	zone: new ZoneRepository(storage),
-})
+	"associate-role": new AssociateRoleRepository(storage),
+	"attribute-group": new AttributeGroupRepository(storage),
+	"business-unit": new BusinessUnitRepository(storage),
+	"category": new CategoryRepository(storage),
+	"cart": new CartRepository(storage),
+	"cart-discount": new CartDiscountRepository(storage),
+	"customer": new CustomerRepository(storage),
+	"channel": new ChannelRepository(storage),
+	"customer-group": new CustomerGroupRepository(storage),
+	"discount-code": new DiscountCodeRepository(storage),
+	"extension": new ExtensionRepository(storage),
+	"inventory-entry": new InventoryEntryRepository(storage),
+	"key-value-document": new CustomObjectRepository(storage),
+	"order": new OrderRepository(storage),
+	"order-edit": new OrderEditRepository(storage),
+	"payment": new PaymentRepository(storage),
+	"my-cart": new CartRepository(storage),
+	"my-order": new MyOrderRepository(storage),
+	"my-customer": new MyCustomerRepository(storage),
+	"my-payment": new PaymentRepository(storage),
+	"my-shopping-list": new ShoppingListRepository(storage),
+	"product": new ProductRepository(storage),
+	"product-type": new ProductTypeRepository(storage),
+	"product-discount": new ProductDiscountRepository(storage),
+	"product-projection": new ProductProjectionRepository(storage),
+	"product-selection": new ProductSelectionRepository(storage),
+	"project": new ProjectRepository(storage),
+	"review": new ReviewRepository(storage),
+	"quote": new QuoteRepository(storage),
+	"quote-request": new QuoteRequestRepository(storage),
+	"shipping-method": new ShippingMethodRepository(storage),
+	"shopping-list": new ShoppingListRepository(storage),
+	"staged-quote": new StagedQuoteRepository(storage),
+	"standalone-price": new StandAlonePriceRepository(storage),
+	"state": new StateRepository(storage),
+	"store": new StoreRepository(storage),
+	"subscription": new SubscriptionRepository(storage),
+	"tax-category": new TaxCategoryRepository(storage),
+	"type": new TypeRepository(storage),
+	"zone": new ZoneRepository(storage),
+});

package/src/repositories/inventory-entry/actions.ts

@@ -0,0 +1,84 @@
+import type {
+	InventoryEntry,
+	InventoryEntryChangeQuantityAction,
+	InventoryEntrySetCustomFieldAction,
+	InventoryEntrySetCustomTypeAction,
+	InventoryEntrySetExpectedDeliveryAction,
+	InventoryEntrySetRestockableInDaysAction,
+	InventoryEntryUpdateAction,
+} from "@commercetools/platform-sdk";
+import type { Writable } from "~src/types";
+import {
+	AbstractUpdateHandler,
+	UpdateHandlerInterface,
+	type RepositoryContext,
+} from "../abstract";
+
+export class InventoryEntryUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		Partial<UpdateHandlerInterface<InventoryEntry, InventoryEntryUpdateAction>>
+{
+	changeQuantity(
+		context: RepositoryContext,
+		resource: Writable<InventoryEntry>,
+		{ quantity }: InventoryEntryChangeQuantityAction,
+	) {
+		resource.quantityOnStock = quantity;
+		// don't know active reservations so just set to same value
+		resource.availableQuantity = quantity;
+	}
+
+	setCustomField(
+		context: RepositoryContext,
+		resource: InventoryEntry,
+		{ name, value }: InventoryEntrySetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			throw new Error("Resource has no custom field");
+		}
+		resource.custom.fields[name] = value;
+	}
+
+	setCustomType(
+		context: RepositoryContext,
+		resource: Writable<InventoryEntry>,
+		{ type, fields }: InventoryEntrySetCustomTypeAction,
+	) {
+		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 || {},
+			};
+		}
+	}
+
+	setExpectedDelivery(
+		context: RepositoryContext,
+		resource: Writable<InventoryEntry>,
+		{ expectedDelivery }: InventoryEntrySetExpectedDeliveryAction,
+	) {
+		resource.expectedDelivery = new Date(expectedDelivery!).toISOString();
+	}
+
+	setRestockableInDays(
+		context: RepositoryContext,
+		resource: Writable<InventoryEntry>,
+		{ restockableInDays }: InventoryEntrySetRestockableInDaysAction,
+	) {
+		resource.restockableInDays = restockableInDays;
+	}
+}