@labdigital/commercetools-mock 2.17.1 → 2.18.0

package/src/repositories/product/helpers.ts

@@ -0,0 +1,98 @@
+import {
+	ChannelReference,
+	Price,
+	PriceDraft,
+	Product,
+	ProductData,
+	ProductVariant,
+	ProductVariantDraft,
+} from "@commercetools/platform-sdk";
+import deepEqual from "deep-equal";
+import { v4 as uuidv4 } from "uuid";
+import { AbstractStorage } from "~src/storage";
+import { Writable } from "~src/types";
+import { RepositoryContext } from "../abstract";
+import {
+	createTypedMoney,
+	getReferenceFromResourceIdentifier,
+} from "../helpers";
+
+interface VariantResult {
+	variant: Writable<ProductVariant> | undefined;
+	isMasterVariant: boolean;
+	variantIndex: number;
+}
+
+export const getVariant = (
+	productData: ProductData,
+	variantId?: number,
+	sku?: string,
+): VariantResult => {
+	const variants = [productData.masterVariant, ...productData.variants];
+	const foundVariant = variants.find((variant: ProductVariant) => {
+		if (variantId) {
+			return variant.id === variantId;
+		}
+		if (sku) {
+			return variant.sku === sku;
+		}
+		return false;
+	});
+
+	const isMasterVariant = foundVariant === productData.masterVariant;
+	return {
+		variant: foundVariant,
+		isMasterVariant,
+		variantIndex:
+			!isMasterVariant && foundVariant
+				? productData.variants.indexOf(foundVariant)
+				: -1,
+	};
+};
+
+// Check if the product still has staged data that is different from the
+// current data.
+export const checkForStagedChanges = (product: Writable<Product>) => {
+	if (!product.masterData.staged) {
+		product.masterData.staged = product.masterData.current;
+	}
+
+	if (deepEqual(product.masterData.current, product.masterData.staged)) {
+		product.masterData.hasStagedChanges = false;
+	} else {
+		product.masterData.hasStagedChanges = true;
+	}
+};
+
+export const variantFromDraft = (
+	context: RepositoryContext,
+	storage: AbstractStorage,
+	variantId: number,
+	variant: ProductVariantDraft,
+): ProductVariant => ({
+	id: variantId,
+	sku: variant?.sku,
+	key: variant?.key,
+	attributes: variant?.attributes ?? [],
+	prices: variant?.prices?.map((p) => priceFromDraft(context, storage, p)),
+	assets: [],
+	images: [],
+});
+
+export const priceFromDraft = (
+	context: RepositoryContext,
+	storage: AbstractStorage,
+	draft: PriceDraft,
+): Price => ({
+	id: uuidv4(),
+	key: draft.key,
+	country: draft.country,
+	value: createTypedMoney(draft.value),
+	channel: draft.channel
+		? getReferenceFromResourceIdentifier<ChannelReference>(
+				draft.channel,
+				context.projectKey,
+				storage,
+			)
+		: undefined,
+});

package/src/repositories/product/index.ts

@@ -0,0 +1,130 @@
+import type {
+	CategoryReference,
+	InvalidJsonInputError,
+	Product,
+	ProductData,
+	ProductDraft,
+	ProductTypeReference,
+	StateReference,
+	TaxCategoryReference,
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "~src/exceptions";
+import { getBaseResourceProperties } from "~src/helpers";
+import { AbstractStorage } from "~src/storage/abstract";
+import { AbstractResourceRepository, RepositoryContext } from "../abstract";
+import { getReferenceFromResourceIdentifier } from "../helpers";
+import { ProductUpdateHandler } from "./actions";
+import { variantFromDraft } from "./helpers";
+
+export class ProductRepository extends AbstractResourceRepository<"product"> {
+	constructor(storage: AbstractStorage) {
+		super("product", storage);
+		this.actions = new ProductUpdateHandler(storage);
+	}
+
+	create(context: RepositoryContext, draft: ProductDraft): Product {
+		if (!draft.masterVariant) {
+			throw new Error("Missing master variant");
+		}
+
+		let productType: ProductTypeReference | undefined = undefined;
+		try {
+			productType = getReferenceFromResourceIdentifier<ProductTypeReference>(
+				draft.productType,
+				context.projectKey,
+				this._storage,
+			);
+		} catch (err) {
+			// For now accept missing product types (but warn)
+			console.warn(
+				`Error resolving product-type '${draft.productType.id}'. This will be throw an error in later releases.`,
+			);
+			productType = {
+				typeId: "product-type",
+				id: draft.productType.id || "",
+			};
+		}
+
+		// Resolve Product categories
+		const categoryReferences: CategoryReference[] = [];
+		draft.categories?.forEach((category) => {
+			if (category) {
+				categoryReferences.push(
+					getReferenceFromResourceIdentifier<CategoryReference>(
+						category,
+						context.projectKey,
+						this._storage,
+					),
+				);
+			} else {
+				throw new CommercetoolsError<InvalidJsonInputError>(
+					{
+						code: "InvalidJsonInput",
+						message: "Request body does not contain valid JSON.",
+						detailedErrorMessage: "categories: JSON object expected.",
+					},
+					400,
+				);
+			}
+		});
+
+		// Resolve Tax category
+		let taxCategoryReference: TaxCategoryReference | undefined = undefined;
+		if (draft.taxCategory) {
+			taxCategoryReference =
+				getReferenceFromResourceIdentifier<TaxCategoryReference>(
+					draft.taxCategory,
+					context.projectKey,
+					this._storage,
+				);
+		}
+
+		// Resolve Product State
+		let productStateReference: StateReference | undefined = undefined;
+		if (draft.state) {
+			productStateReference =
+				getReferenceFromResourceIdentifier<StateReference>(
+					draft.state,
+					context.projectKey,
+					this._storage,
+				);
+		}
+
+		const productData: ProductData = {
+			name: draft.name,
+			slug: draft.slug,
+			description: draft.description,
+			categories: categoryReferences,
+			masterVariant: variantFromDraft(
+				context,
+				this._storage,
+				1,
+				draft.masterVariant,
+			),
+			variants:
+				draft.variants?.map((variant, index) =>
+					variantFromDraft(context, this._storage, index + 2, variant),
+				) ?? [],
+			metaTitle: draft.metaTitle,
+			metaDescription: draft.metaDescription,
+			metaKeywords: draft.metaKeywords,
+			searchKeywords: draft.searchKeywords ?? {},
+		};
+
+		const resource: Product = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			productType: productType,
+			taxCategory: taxCategoryReference,
+			state: productStateReference,
+			masterData: {
+				current: productData,
+				staged: productData,
+				hasStagedChanges: false,
+				published: draft.publish ?? false,
+			},
+		};
+
+		return this.saveNew(context, resource);
+	}
+}

package/src/repositories/product-discount.ts

@@ -17,145 +17,155 @@ import type {
 	ProductDiscountValueDraft,
 	ProductDiscountValueExternal,
 	ProductDiscountValueRelative,
-} from '@commercetools/platform-sdk'
-import { getBaseResourceProperties } from '../helpers.js'
-import type { Writable } from '../types.js'
-import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
-import { createTypedMoney } from './helpers.js'
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "../helpers";
+import { AbstractStorage } from "../storage/abstract";
+import type { Writable } from "../types";
+import {
+	AbstractResourceRepository,
+	AbstractUpdateHandler,
+	RepositoryContext,
+	UpdateHandlerInterface,
+} from "./abstract";
+import { createTypedMoney } from "./helpers";
 
-export class ProductDiscountRepository extends AbstractResourceRepository<'product-discount'> {
-	getTypeId() {
-		return 'product-discount' as const
+export class ProductDiscountRepository extends AbstractResourceRepository<"product-discount"> {
+	constructor(storage: AbstractStorage) {
+		super("product-discount", storage);
+		this.actions = new ProductDiscountUpdateHandler(this._storage);
 	}
 
 	create(
 		context: RepositoryContext,
-		draft: ProductDiscountDraft
+		draft: ProductDiscountDraft,
 	): ProductDiscount {
 		const resource: ProductDiscount = {
 			...getBaseResourceProperties(),
 			key: draft.key,
 			name: draft.name,
 			description: draft.description,
-			value: this.transformValueDraft(draft.value),
+			value: transformValueDraft(draft.value),
 			predicate: draft.predicate,
 			sortOrder: draft.sortOrder,
 			isActive: draft.isActive || false,
 			validFrom: draft.validFrom,
 			validUntil: draft.validUntil,
 			references: [],
+		};
+		return this.saveNew(context, resource);
+	}
+}
+
+const transformValueDraft = (
+	value: ProductDiscountValueDraft,
+): ProductDiscountValue => {
+	switch (value.type) {
+		case "absolute": {
+			return {
+				type: "absolute",
+				money: value.money.map(createTypedMoney),
+			} as ProductDiscountValueAbsolute;
+		}
+		case "external": {
+			return {
+				type: "external",
+			} as ProductDiscountValueExternal;
 		}
-		this.saveNew(context, resource)
-		return resource
+		case "relative": {
+			return {
+				...value,
+			} as ProductDiscountValueRelative;
+		}
+	}
+};
+
+export class ProductDiscountUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		UpdateHandlerInterface<ProductDiscount, ProductDiscountUpdateAction>
+{
+	changeIsActive(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ isActive }: ProductDiscountChangeIsActiveAction,
+	) {
+		resource.isActive = isActive;
 	}
 
-	private transformValueDraft(
-		value: ProductDiscountValueDraft
-	): ProductDiscountValue {
-		switch (value.type) {
-			case 'absolute': {
-				return {
-					type: 'absolute',
-					money: value.money.map(createTypedMoney),
-				} as ProductDiscountValueAbsolute
-			}
-			case 'external': {
-				return {
-					type: 'external',
-				} as ProductDiscountValueExternal
-			}
-			case 'relative': {
-				return {
-					...value,
-				} as ProductDiscountValueRelative
-			}
+	changeName(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ name }: ProductDiscountChangeNameAction,
+	) {
+		resource.name = name;
+	}
+
+	changePredicate(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ predicate }: ProductDiscountChangePredicateAction,
+	) {
+		resource.predicate = predicate;
+	}
+
+	changeSortOrder(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ sortOrder }: ProductDiscountChangeSortOrderAction,
+	) {
+		resource.sortOrder = sortOrder;
+	}
+
+	changeValue(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ value }: ProductDiscountChangeValueAction,
+	) {
+		resource.value = transformValueDraft(value);
+	}
+
+	setDescription(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ description }: ProductDiscountSetDescriptionAction,
+	) {
+		if (description && Object.keys(description).length > 0) {
+			resource.description = description;
+		} else {
+			resource.description = undefined;
 		}
 	}
 
-	actions: Partial<
-		Record<
-			ProductDiscountUpdateAction['action'],
-			(
-				context: RepositoryContext,
-				resource: Writable<ProductDiscount>,
-				action: any
-			) => void
-		>
-	> = {
-		setKey: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ key }: ProductDiscountSetKeyAction
-		) => {
-			resource.key = key
-		},
-		setDescription: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ description }: ProductDiscountSetDescriptionAction
-		) => {
-			if (description && Object.keys(description).length > 0) {
-				resource.description = description
-			} else {
-				resource.description = undefined
-			}
-		},
-		changeName: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ name }: ProductDiscountChangeNameAction
-		) => {
-			resource.name = name
-		},
-		changeValue: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ value }: ProductDiscountChangeValueAction
-		) => {
-			resource.value = this.transformValueDraft(value)
-		},
-		changePredicate: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ predicate }: ProductDiscountChangePredicateAction
-		) => {
-			resource.predicate = predicate
-		},
-		changeSortOrder: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ sortOrder }: ProductDiscountChangeSortOrderAction
-		) => {
-			resource.sortOrder = sortOrder
-		},
-		changeIsActive: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ isActive }: ProductDiscountChangeIsActiveAction
-		) => {
-			resource.isActive = isActive
-		},
-		setValidFrom: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ validFrom }: ProductDiscountSetValidFromAction
-		) => {
-			resource.validFrom = validFrom
-		},
-		setValidUntil: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ validUntil }: ProductDiscountSetValidUntilAction
-		) => {
-			resource.validUntil = validUntil
-		},
-		setValidFromAndUntil: (
-			context: RepositoryContext,
-			resource: Writable<ProductDiscount>,
-			{ validFrom, validUntil }: ProductDiscountSetValidFromAndUntilAction
-		) => {
-			resource.validFrom = validFrom
-			resource.validUntil = validUntil
-		},
+	setKey(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ key }: ProductDiscountSetKeyAction,
+	) {
+		resource.key = key;
+	}
+
+	setValidFrom(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ validFrom }: ProductDiscountSetValidFromAction,
+	) {
+		resource.validFrom = validFrom;
+	}
+
+	setValidFromAndUntil(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ validFrom, validUntil }: ProductDiscountSetValidFromAndUntilAction,
+	) {
+		resource.validFrom = validFrom;
+		resource.validUntil = validUntil;
+	}
+
+	setValidUntil(
+		context: RepositoryContext,
+		resource: Writable<ProductDiscount>,
+		{ validUntil }: ProductDiscountSetValidUntilAction,
+	) {
+		resource.validUntil = validUntil;
 	}
 }

package/src/repositories/product-projection.ts

@@ -3,101 +3,97 @@ import type {
 	ProductDraft,
 	ProductProjection,
 	QueryParam,
-} from '@commercetools/platform-sdk'
-import { CommercetoolsError } from '../exceptions.js'
-import { parseQueryExpression } from '../lib/predicateParser.js'
-import { ProductProjectionSearch } from '../product-projection-search.js'
-import { type AbstractStorage } from '../storage/index.js'
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "~src/exceptions";
+import { parseQueryExpression } from "../lib/predicateParser";
+import { applyPriceSelector } from "../priceSelector";
+import { ProductProjectionSearch } from "../product-projection-search";
+import { type AbstractStorage } from "../storage";
 import {
 	AbstractResourceRepository,
 	GetParams,
 	RepositoryContext,
-} from './abstract.js'
-import { applyPriceSelector } from '../priceSelector.js'
+} from "./abstract";
 
 export type ProductProjectionQueryParams = {
-	staged?: boolean
-	priceCurrency?: string
-	priceCountry?: string
-	priceCustomerGroup?: string
-	priceChannel?: string
-	localeProjection?: string
-	storeProjection?: string
-	expand?: string | string[]
-	sort?: string | string[]
-	limit?: number
-	offset?: number
-	withTotal?: boolean
-	where?: string | string[]
-	[key: string]: QueryParam
-}
+	staged?: boolean;
+	priceCurrency?: string;
+	priceCountry?: string;
+	priceCustomerGroup?: string;
+	priceChannel?: string;
+	localeProjection?: string;
+	storeProjection?: string;
+	expand?: string | string[];
+	sort?: string | string[];
+	limit?: number;
+	offset?: number;
+	withTotal?: boolean;
+	where?: string | string[];
+	[key: string]: QueryParam;
+};
 
-export class ProductProjectionRepository extends AbstractResourceRepository<'product-projection'> {
-	protected _searchService: ProductProjectionSearch
+export class ProductProjectionRepository extends AbstractResourceRepository<"product-projection"> {
+	protected _searchService: ProductProjectionSearch;
 
 	constructor(storage: AbstractStorage) {
-		super(storage)
-		this._searchService = new ProductProjectionSearch(storage)
-	}
-
-	getTypeId() {
-		return 'product-projection' as const
+		super("product-projection", storage);
+		this._searchService = new ProductProjectionSearch(storage);
 	}
 
 	create(context: RepositoryContext, draft: ProductDraft): ProductProjection {
-		throw new Error('No valid action')
+		throw new Error("No valid action");
 	}
 
 	get(
 		context: RepositoryContext,
 		id: string,
-		params: GetParams = {}
+		params: GetParams = {},
 	): ProductProjection | null {
 		const resource = this._storage.get(
 			context.projectKey,
-			'product',
+			"product",
 			id,
-			params
-		)
+			params,
+		);
 		if (resource) {
-			return this._searchService.transform(resource, false)
+			return this._searchService.transform(resource, false);
 		}
-		return null
+		return null;
 	}
 
 	query(context: RepositoryContext, params: ProductProjectionQueryParams = {}) {
 		let resources = this._storage
-			.all(context.projectKey, 'product')
+			.all(context.projectKey, "product")
 			.map((r) => this._searchService.transform(r, params.staged ?? false))
 			.filter((p) => {
 				if (!params.staged ?? false) {
-					return p.published
+					return p.published;
 				}
-				return true
-			})
+				return true;
+			});
 
 		// Apply predicates
 		if (params.where) {
-			const variableMap: Record<string, QueryParam> = {}
+			const variableMap: Record<string, QueryParam> = {};
 			for (const [k, v] of Object.entries(params)) {
-				if (k.startsWith('var.')) {
-					variableMap[k.substring(4)] = v
+				if (k.startsWith("var.")) {
+					variableMap[k.substring(4)] = v;
 				}
 			}
 
 			try {
-				const filterFunc = parseQueryExpression(params.where)
+				const filterFunc = parseQueryExpression(params.where);
 				resources = resources.filter((resource) =>
-					filterFunc(resource, variableMap)
-				)
+					filterFunc(resource, variableMap),
+				);
 			} catch (err) {
 				throw new CommercetoolsError<InvalidInputError>(
 					{
-						code: 'InvalidInput',
+						code: "InvalidInput",
 						message: (err as any).message,
 					},
-					400
-				)
+					400,
+				);
 			}
 		}
 
@@ -112,23 +108,23 @@ export class ProductProjectionRepository extends AbstractResourceRepository<'pro
 				customerGroup: params.priceCustomerGroup,
 				currency: params.priceCurrency,
 			},
-			true
-		)
+			true,
+		);
 
 		// Expand the resources
 		if (params.expand !== undefined) {
 			resources = resources.map((resource) =>
-				this._storage.expand(context.projectKey, resource, params.expand)
-			)
+				this._storage.expand(context.projectKey, resource, params.expand),
+			);
 		}
 
 		// Create a slice for the pagination. If we were working with large datasets
 		// then we should have done this before transforming. But that isn't the
 		// goal of this library. So lets keep it simple.
-		const totalResults = resources.length
-		const offset = params.offset || 0
-		const limit = params.limit || 20
-		const results = resources.slice(offset, offset + limit)
+		const totalResults = resources.length;
+		const offset = params.offset || 0;
+		const limit = params.limit || 20;
+		const results = resources.slice(offset, offset + limit);
 
 		return {
 			count: totalResults,
@@ -136,12 +132,10 @@ export class ProductProjectionRepository extends AbstractResourceRepository<'pro
 			offset: offset,
 			limit: limit,
 			results: results,
-		}
+		};
 	}
 
 	search(context: RepositoryContext, query: ProductProjectionQueryParams) {
-		return this._searchService.search(context.projectKey, query)
+		return this._searchService.search(context.projectKey, query);
 	}
-
-	actions = {}
 }