@labdigital/commercetools-mock 2.17.1 → 2.18.1

package/src/repositories/cart-discount/actions.ts

@@ -0,0 +1,148 @@
+import type {
+	CartDiscount,
+	CartDiscountChangeIsActiveAction,
+	CartDiscountChangeSortOrderAction,
+	CartDiscountChangeTargetAction,
+	CartDiscountSetCustomFieldAction,
+	CartDiscountSetCustomTypeAction,
+	CartDiscountSetDescriptionAction,
+	CartDiscountSetKeyAction,
+	CartDiscountSetValidFromAction,
+	CartDiscountSetValidFromAndUntilAction,
+	CartDiscountSetValidUntilAction,
+	CartDiscountUpdateAction,
+	InvalidOperationError,
+} from "@commercetools/platform-sdk";
+import type { Writable } from "~src/types";
+import {
+	AbstractUpdateHandler,
+	UpdateHandlerInterface,
+	type RepositoryContext,
+} from "../abstract";
+
+import { CommercetoolsError } from "~src/exceptions";
+
+export class CartDiscountUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		Partial<UpdateHandlerInterface<CartDiscount, CartDiscountUpdateAction>>
+{
+	changeIsActive(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ isActive }: CartDiscountChangeIsActiveAction,
+	) {
+		resource.isActive = isActive;
+	}
+
+	changeSortOrder(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ sortOrder }: CartDiscountChangeSortOrderAction,
+	) {
+		resource.sortOrder = sortOrder;
+	}
+
+	changeTarget(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ target }: CartDiscountChangeTargetAction,
+	) {
+		resource.target = target;
+	}
+
+	setCustomField(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ name, value }: CartDiscountSetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			return;
+		}
+		if (value === null) {
+			if (name in resource.custom.fields) {
+				delete resource.custom.fields[name];
+			} else {
+				throw new CommercetoolsError<InvalidOperationError>(
+					{
+						code: "InvalidOperation",
+						message:
+							"Cannot remove custom field " +
+							name +
+							" because it does not exist.",
+					},
+					400,
+				);
+			}
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
+
+	setCustomType(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ type, fields }: CartDiscountSetCustomTypeAction,
+	) {
+		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 || {},
+			};
+		}
+	}
+
+	setDescription(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ description }: CartDiscountSetDescriptionAction,
+	) {
+		resource.description = description;
+	}
+
+	setKey(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ key }: CartDiscountSetKeyAction,
+	) {
+		resource.key = key;
+	}
+
+	setValidFrom(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ validFrom }: CartDiscountSetValidFromAction,
+	) {
+		resource.validFrom = validFrom;
+	}
+
+	setValidFromAndUntil(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ validFrom, validUntil }: CartDiscountSetValidFromAndUntilAction,
+	) {
+		resource.validFrom = validFrom;
+		resource.validUntil = validUntil;
+	}
+
+	setValidUntil(
+		context: RepositoryContext,
+		resource: Writable<CartDiscount>,
+		{ validUntil }: CartDiscountSetValidUntilAction,
+	) {
+		resource.validUntil = validUntil;
+	}
+}

package/src/repositories/cart-discount/index.ts

@@ -0,0 +1,86 @@
+import type {
+	CartDiscount,
+	CartDiscountDraft,
+	CartDiscountValueAbsolute,
+	CartDiscountValueDraft,
+	CartDiscountValueFixed,
+	CartDiscountValueGiftLineItem,
+	CartDiscountValueRelative,
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "~src/helpers";
+import { AbstractStorage } from "~src/storage/abstract";
+import {
+	AbstractResourceRepository,
+	type RepositoryContext,
+} from "../abstract";
+import {
+	createCustomFields,
+	createTypedMoney,
+	getStoreKeyReference,
+} from "../helpers";
+import { CartDiscountUpdateHandler } from "./actions";
+
+export class CartDiscountRepository extends AbstractResourceRepository<"cart-discount"> {
+	constructor(storage: AbstractStorage) {
+		super("cart-discount", storage);
+		this.actions = new CartDiscountUpdateHandler(storage);
+	}
+
+	create(context: RepositoryContext, draft: CartDiscountDraft): CartDiscount {
+		const resource: CartDiscount = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			description: draft.description,
+			cartPredicate: draft.cartPredicate,
+			isActive: draft.isActive || false,
+			name: draft.name,
+			stores:
+				draft.stores?.map((s) =>
+					getStoreKeyReference(s, context.projectKey, this._storage),
+				) ?? [],
+			references: [],
+			target: draft.target,
+			requiresDiscountCode: draft.requiresDiscountCode || false,
+			sortOrder: draft.sortOrder,
+			stackingMode: draft.stackingMode || "Stacking",
+			validFrom: draft.validFrom,
+			validUntil: draft.validUntil,
+			value: this.transformValueDraft(draft.value),
+			custom: createCustomFields(
+				draft.custom,
+				context.projectKey,
+				this._storage,
+			),
+		};
+		return this.saveNew(context, resource);
+	}
+
+	private transformValueDraft(value: CartDiscountValueDraft) {
+		switch (value.type) {
+			case "absolute": {
+				return {
+					type: "absolute",
+					money: value.money.map(createTypedMoney),
+				} as CartDiscountValueAbsolute;
+			}
+			case "fixed": {
+				return {
+					type: "fixed",
+					money: value.money.map(createTypedMoney),
+				} as CartDiscountValueFixed;
+			}
+			case "giftLineItem": {
+				return {
+					...value,
+				} as CartDiscountValueGiftLineItem;
+			}
+			case "relative": {
+				return {
+					...value,
+				} as CartDiscountValueRelative;
+			}
+		}
+
+		return value;
+	}
+}

package/src/repositories/category/actions.ts

@@ -0,0 +1,231 @@
+import {
+	Asset,
+	AssetDraft,
+	Category,
+	CategoryAddAssetAction,
+	CategoryChangeAssetNameAction,
+	CategoryChangeNameAction,
+	CategoryChangeParentAction,
+	CategoryChangeSlugAction,
+	CategoryRemoveAssetAction,
+	CategorySetAssetDescriptionAction,
+	CategorySetAssetSourcesAction,
+	CategorySetCustomFieldAction,
+	CategorySetCustomTypeAction,
+	CategorySetDescriptionAction,
+	CategorySetKeyAction,
+	CategorySetMetaDescriptionAction,
+	CategorySetMetaKeywordsAction,
+	CategorySetMetaTitleAction,
+	CategoryUpdateAction,
+} from "@commercetools/platform-sdk";
+import { v4 as uuidv4 } from "uuid";
+import { Writable } from "~src/types";
+import {
+	AbstractUpdateHandler,
+	RepositoryContext,
+	UpdateHandlerInterface,
+} from "../abstract";
+import { createCustomFields } from "../helpers";
+
+export class CategoryUpdateHandler
+	extends AbstractUpdateHandler
+	implements Partial<UpdateHandlerInterface<Category, CategoryUpdateAction>>
+{
+	addAsset(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ asset }: CategoryAddAssetAction,
+	) {
+		if (!resource.assets) {
+			resource.assets = [this.assetFromAssetDraft(asset, context)];
+		} else {
+			resource.assets.push(this.assetFromAssetDraft(asset, context));
+		}
+	}
+
+	changeAssetName(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ assetId, assetKey, name }: CategoryChangeAssetNameAction,
+	) {
+		resource.assets?.forEach((asset) => {
+			if (assetId && assetId === asset.id) {
+				asset.name = name;
+			}
+			if (assetKey && assetKey === asset.key) {
+				asset.name = name;
+			}
+		});
+	}
+
+	changeName(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ name }: CategoryChangeNameAction,
+	) {
+		resource.name = name;
+	}
+
+	changeParent(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ parent }: CategoryChangeParentAction,
+	) {
+		const category = this._storage.getByResourceIdentifier(
+			context.projectKey,
+			parent,
+		);
+		if (!category) {
+			throw new Error("No category found for reference");
+		}
+		resource.parent = {
+			typeId: "category",
+			id: category.id,
+		};
+	}
+
+	changeSlug(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ slug }: CategoryChangeSlugAction,
+	) {
+		resource.slug = slug;
+	}
+
+	removeAsset(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ assetId, assetKey }: CategoryRemoveAssetAction,
+	) {
+		if (!resource.assets) {
+			return;
+		}
+
+		if (assetId) {
+			resource.assets = resource.assets.filter(function (obj) {
+				return obj.id !== assetId;
+			});
+
+			return;
+		}
+
+		if (assetKey) {
+			resource.assets = resource.assets.filter(function (obj) {
+				return obj.key !== assetKey;
+			});
+
+			return;
+		}
+	}
+
+	setAssetDescription(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ assetId, assetKey, description }: CategorySetAssetDescriptionAction,
+	) {
+		resource.assets?.forEach((asset) => {
+			if (assetId && assetId === asset.id) {
+				asset.description = description;
+			}
+			if (assetKey && assetKey === asset.key) {
+				asset.description = description;
+			}
+		});
+	}
+
+	setAssetSources(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ assetId, assetKey, sources }: CategorySetAssetSourcesAction,
+	) {
+		resource.assets?.forEach((asset) => {
+			if (assetId && assetId === asset.id) {
+				asset.sources = sources;
+			}
+			if (assetKey && assetKey === asset.key) {
+				asset.sources = sources;
+			}
+		});
+	}
+
+	setCustomField(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ name, value }: CategorySetCustomFieldAction,
+	) {
+		if (!resource.custom) {
+			return;
+		}
+		if (value === null) {
+			delete resource.custom.fields[name];
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
+
+	setCustomType(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ type, fields }: CategorySetCustomTypeAction,
+	) {
+		if (type) {
+			resource.custom = createCustomFields(
+				{ type, fields },
+				context.projectKey,
+				this._storage,
+			);
+		} else {
+			resource.custom = undefined;
+		}
+	}
+
+	setDescription(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ description }: CategorySetDescriptionAction,
+	) {
+		resource.description = description;
+	}
+
+	setKey(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ key }: CategorySetKeyAction,
+	) {
+		resource.key = key;
+	}
+
+	setMetaDescription(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ metaDescription }: CategorySetMetaDescriptionAction,
+	) {
+		resource.metaDescription = metaDescription;
+	}
+
+	setMetaKeywords(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ metaKeywords }: CategorySetMetaKeywordsAction,
+	) {
+		resource.metaKeywords = metaKeywords;
+	}
+
+	setMetaTitle(
+		context: RepositoryContext,
+		resource: Writable<Category>,
+		{ metaTitle }: CategorySetMetaTitleAction,
+	) {
+		resource.metaTitle = metaTitle;
+	}
+
+	assetFromAssetDraft = (
+		draft: AssetDraft,
+		context: RepositoryContext,
+	): Asset => ({
+		...draft,
+		id: uuidv4(),
+		custom: createCustomFields(draft.custom, context.projectKey, this._storage),
+	});
+}

package/src/repositories/category/index.ts

@@ -0,0 +1,52 @@
+import type { Category, CategoryDraft } from "@commercetools/platform-sdk";
+import { v4 as uuidv4 } from "uuid";
+import { getBaseResourceProperties } from "~src/helpers";
+import { AbstractStorage } from "~src/storage/abstract";
+import {
+	AbstractResourceRepository,
+	type RepositoryContext,
+} from "../abstract";
+import { createCustomFields } from "../helpers";
+import { CategoryUpdateHandler } from "./actions";
+
+export class CategoryRepository extends AbstractResourceRepository<"category"> {
+	constructor(storage: AbstractStorage) {
+		super("category", storage);
+		this.actions = new CategoryUpdateHandler(this._storage);
+	}
+
+	create(context: RepositoryContext, draft: CategoryDraft): Category {
+		const resource: Category = {
+			...getBaseResourceProperties(),
+			key: draft.key,
+			name: draft.name,
+			slug: draft.slug,
+			orderHint: draft.orderHint || "",
+			externalId: draft.externalId || "",
+			parent: draft.parent
+				? { typeId: "category", id: draft.parent.id! }
+				: undefined,
+			ancestors: [], // TODO
+			assets:
+				draft.assets?.map((d) => ({
+					id: uuidv4(),
+					name: d.name,
+					description: d.description,
+					sources: d.sources,
+					tags: d.tags,
+					key: d.key,
+					custom: createCustomFields(
+						draft.custom,
+						context.projectKey,
+						this._storage,
+					),
+				})) || [],
+			custom: createCustomFields(
+				draft.custom,
+				context.projectKey,
+				this._storage,
+			),
+		};
+		return this.saveNew(context, resource);
+	}
+}