@labdigital/commercetools-mock 2.17.0 → 2.18.0

package/src/repositories/state.ts

@@ -1,23 +1,33 @@
 import type {
 	State,
+	StateAddRolesAction,
 	StateChangeInitialAction,
 	StateChangeKeyAction,
+	StateChangeTypeAction,
 	StateDraft,
 	StateReference,
+	StateRemoveRolesAction,
 	StateSetDescriptionAction,
 	StateSetNameAction,
 	StateSetRolesAction,
 	StateSetTransitionsAction,
 	StateUpdateAction,
-} from '@commercetools/platform-sdk'
-import { getBaseResourceProperties } from '../helpers.js'
-import type { Writable } from '../types.js'
-import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
-import { getReferenceFromResourceIdentifier } 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 { getReferenceFromResourceIdentifier } from "./helpers";
 
-export class StateRepository extends AbstractResourceRepository<'state'> {
-	getTypeId() {
-		return 'state' as const
+export class StateRepository extends AbstractResourceRepository<"state"> {
+	constructor(storage: AbstractStorage) {
+		super("state", storage);
+		this.actions = new StateUpdateHandler(storage);
 	}
 
 	create(context: RepositoryContext, draft: StateDraft): State {
@@ -27,70 +37,105 @@ export class StateRepository extends AbstractResourceRepository<'state'> {
 			builtIn: false,
 			initial: draft.initial || false,
 			transitions: (draft.transitions || []).map((t) =>
-				getReferenceFromResourceIdentifier(t, context.projectKey, this._storage)
+				getReferenceFromResourceIdentifier(
+					t,
+					context.projectKey,
+					this._storage,
+				),
 			),
+		};
+
+		return this.saveNew(context, resource);
+	}
+}
+
+class StateUpdateHandler
+	extends AbstractUpdateHandler
+	implements UpdateHandlerInterface<State, StateUpdateAction>
+{
+	addRoles(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		action: StateAddRolesAction,
+	) {
+		if (!resource.roles) {
+			resource.roles = [];
+		}
+		for (const role of action.roles) {
+			if (!resource.roles.includes(role)) {
+				resource.roles.push(role);
+			}
 		}
+	}
+
+	changeInitial(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		{ initial }: StateChangeInitialAction,
+	) {
+		resource.initial = initial;
+	}
+
+	changeKey(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		{ key }: StateChangeKeyAction,
+	) {
+		resource.key = key;
+	}
+
+	changeType(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		action: StateChangeTypeAction,
+	) {
+		resource.type = action.type;
+	}
+
+	removeRoles(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		action: StateRemoveRolesAction,
+	) {
+		resource.roles = resource.roles?.filter(
+			(role) => !action.roles.includes(role),
+		);
+	}
+
+	setDescription(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		{ description }: StateSetDescriptionAction,
+	) {
+		resource.description = description;
+	}
+
+	setName(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		{ name }: StateSetNameAction,
+	) {
+		resource.name = name;
+	}
 
-		this.saveNew(context, resource)
-		return resource
+	setRoles(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		{ roles }: StateSetRolesAction,
+	) {
+		resource.roles = roles;
 	}
 
-	actions: Partial<
-		Record<
-			StateUpdateAction['action'],
-			(
-				context: RepositoryContext,
-				resource: Writable<State>,
-				action: any
-			) => void
-		>
-	> = {
-		changeKey: (
-			context: RepositoryContext,
-			resource: Writable<State>,
-			{ key }: StateChangeKeyAction
-		) => {
-			resource.key = key
-		},
-		changeInitial: (
-			context: RepositoryContext,
-			resource: Writable<State>,
-			{ initial }: StateChangeInitialAction
-		) => {
-			resource.initial = initial
-		},
-		setDescription: (
-			context: RepositoryContext,
-			resource: Writable<State>,
-			{ description }: StateSetDescriptionAction
-		) => {
-			resource.description = description
-		},
-		setName: (
-			context: RepositoryContext,
-			resource: Writable<State>,
-			{ name }: StateSetNameAction
-		) => {
-			resource.name = name
-		},
-		setRoles: (
-			context: RepositoryContext,
-			resource: Writable<State>,
-			{ roles }: StateSetRolesAction
-		) => {
-			resource.roles = roles
-		},
-		setTransitions: (
-			context: RepositoryContext,
-			resource: Writable<State>,
-			{ transitions }: StateSetTransitionsAction
-		) => {
-			resource.transitions = transitions?.map(
-				(resourceId): StateReference => ({
-					id: resourceId.id || '',
-					typeId: 'state',
-				})
-			)
-		},
+	setTransitions(
+		context: RepositoryContext,
+		resource: Writable<State>,
+		{ transitions }: StateSetTransitionsAction,
+	) {
+		resource.transitions = transitions?.map(
+			(resourceId): StateReference => ({
+				id: resourceId.id || "",
+				typeId: "state",
+			}),
+		);
 	}
 }

package/src/repositories/store.ts

@@ -10,18 +10,25 @@ import type {
 	StoreSetLanguagesAction,
 	StoreSetNameAction,
 	StoreUpdateAction,
-} 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 { getBaseResourceProperties } from "../helpers";
+import { AbstractStorage } from "../storage/abstract";
+import type { Writable } from "../types";
+import {
+	AbstractResourceRepository,
+	AbstractUpdateHandler,
+	RepositoryContext,
+	UpdateHandlerInterface,
+} from "./abstract";
 import {
 	createCustomFields,
 	getReferenceFromResourceIdentifier,
-} from './helpers.js'
+} from "./helpers";
 
-export class StoreRepository extends AbstractResourceRepository<'store'> {
-	getTypeId() {
-		return 'store' as const
+export class StoreRepository extends AbstractResourceRepository<"store"> {
+	constructor(storage: AbstractStorage) {
+		super("store", storage);
+		this.actions = new StoreUpdateHandler(this._storage);
 	}
 
 	create(context: RepositoryContext, draft: StoreDraft): Store {
@@ -31,106 +38,111 @@ export class StoreRepository extends AbstractResourceRepository<'store'> {
 			name: draft.name,
 			languages: draft.languages ?? [],
 			countries: draft.countries ?? [],
-			distributionChannels: this.transformChannels(
+			distributionChannels: transformChannels(
+				context,
+				this._storage,
+				draft.distributionChannels,
+			),
+			supplyChannels: transformChannels(
 				context,
-				draft.distributionChannels
+				this._storage,
+				draft.supplyChannels,
 			),
-			supplyChannels: this.transformChannels(context, draft.supplyChannels),
 			productSelections: [],
 			custom: createCustomFields(
 				draft.custom,
 				context.projectKey,
-				this._storage
+				this._storage,
 			),
-		}
-		this.saveNew(context, resource)
-		return resource
+		};
+		return this.saveNew(context, resource);
+	}
+}
+
+const transformChannels = (
+	context: RepositoryContext,
+	storage: AbstractStorage,
+	channels?: ChannelResourceIdentifier[],
+) => {
+	if (!channels) return [];
+
+	return channels.map((ref) =>
+		getReferenceFromResourceIdentifier<ChannelReference>(
+			ref,
+			context.projectKey,
+			storage,
+		),
+	);
+};
+
+class StoreUpdateHandler
+	extends AbstractUpdateHandler
+	implements Partial<UpdateHandlerInterface<Store, StoreUpdateAction>>
+{
+	setCountries(
+		context: RepositoryContext,
+		resource: Writable<Store>,
+		{ countries }: StoreSetCountriesAction,
+	) {
+		resource.countries = countries ?? [];
 	}
 
-	private transformChannels(
+	setCustomField(
 		context: RepositoryContext,
-		channels?: ChannelResourceIdentifier[]
+		resource: Writable<Store>,
+		{ name, value }: StoreSetCustomFieldAction,
 	) {
-		if (!channels) return []
+		if (!resource.custom) {
+			return;
+		}
+		if (value === null) {
+			delete resource.custom.fields[name];
+		} else {
+			resource.custom.fields[name] = value;
+		}
+	}
 
-		return channels.map((ref) =>
-			getReferenceFromResourceIdentifier<ChannelReference>(
-				ref,
+	setCustomType(
+		context: RepositoryContext,
+		resource: Writable<Store>,
+		{ type, fields }: StoreSetCustomTypeAction,
+	) {
+		if (type) {
+			resource.custom = createCustomFields(
+				{ type, fields },
 				context.projectKey,
-				this._storage
-			)
-		)
+				this._storage,
+			);
+		} else {
+			resource.custom = undefined;
+		}
 	}
 
-	actions: Partial<
-		Record<
-			StoreUpdateAction['action'],
-			(
-				context: RepositoryContext,
-				resource: Writable<Store>,
-				action: any
-			) => void
-		>
-	> = {
-		setName: (
-			context: RepositoryContext,
-			resource: Writable<Store>,
-			{ name }: StoreSetNameAction
-		) => {
-			resource.name = name
-		},
-		setDistributionChannels: (
-			context: RepositoryContext,
-			resource: Writable<Store>,
-			{ distributionChannels }: StoreSetDistributionChannelsAction
-		) => {
-			resource.distributionChannels = this.transformChannels(
-				context,
-				distributionChannels
-			)
-		},
-		setLanguages: (
-			context: RepositoryContext,
-			resource: Writable<Store>,
-			{ languages }: StoreSetLanguagesAction
-		) => {
-			resource.languages = languages ?? []
-		},
-		setCustomType: (
-			context: RepositoryContext,
-			resource: Writable<Store>,
-			{ type, fields }: StoreSetCustomTypeAction
-		) => {
-			if (type) {
-				resource.custom = createCustomFields(
-					{ type, fields },
-					context.projectKey,
-					this._storage
-				)
-			} else {
-				resource.custom = undefined
-			}
-		},
-		setCustomField: (
-			context: RepositoryContext,
-			resource: Writable<Store>,
-			{ name, value }: StoreSetCustomFieldAction
-		) => {
-			if (!resource.custom) {
-				return
-			}
-			if (value === null) {
-				delete resource.custom.fields[name]
-			} else {
-				resource.custom.fields[name] = value
-			}
-		},
-		setCountries: (
-			context: RepositoryContext,
-			resource: Writable<Store>,
-			{ countries }: StoreSetCountriesAction
-		) => {
-			resource.countries = countries ?? []
-		},
+	setDistributionChannels(
+		context: RepositoryContext,
+		resource: Writable<Store>,
+		{ distributionChannels }: StoreSetDistributionChannelsAction,
+	) {
+		resource.distributionChannels = transformChannels(
+			context,
+			this._storage,
+			distributionChannels,
+		);
+	}
+
+	setLanguages(
+		context: RepositoryContext,
+		resource: Writable<Store>,
+		{ languages }: StoreSetLanguagesAction,
+	) {
+		resource.languages = languages ?? [];
+	}
+
+	setName(
+		context: RepositoryContext,
+		resource: Writable<Store>,
+		{ name }: StoreSetNameAction,
+	) {
+		resource.name = name;
 	}
 }

package/src/repositories/subscription.ts

@@ -2,33 +2,44 @@ import type {
 	InvalidInputError,
 	Subscription,
 	SubscriptionDraft,
-} from '@commercetools/platform-sdk'
-import { CommercetoolsError } from '../exceptions.js'
-import { getBaseResourceProperties } from '../helpers.js'
-import { AbstractResourceRepository, RepositoryContext } from './abstract.js'
+	SubscriptionSetKeyAction,
+	SubscriptionUpdateAction,
+} from "@commercetools/platform-sdk";
+import { CommercetoolsError } from "~src/exceptions";
+import { getBaseResourceProperties } from "../helpers";
+import { AbstractStorage } from "../storage/abstract";
+import { Writable } from "../types";
+import {
+	AbstractResourceRepository,
+	AbstractUpdateHandler,
+	RepositoryContext,
+	UpdateHandlerInterface,
+} from "./abstract";
 
-export class SubscriptionRepository extends AbstractResourceRepository<'subscription'> {
-	getTypeId() {
-		return 'subscription' as const
+export class SubscriptionRepository extends AbstractResourceRepository<"subscription"> {
+	constructor(storage: AbstractStorage) {
+		super("subscription", storage);
+		this.actions = new SubscriptionUpdateHandler(storage);
 	}
+
 	create(context: RepositoryContext, draft: SubscriptionDraft): Subscription {
 		// TODO: We could actually test this here by using the aws sdk. For now
 		// hardcode a failed check when account id is 0000000000
-		if (draft.destination.type === 'SQS') {
-			const queueURL = new URL(draft.destination.queueUrl)
-			const accountId = queueURL.pathname.split('/')[1]
-			if (accountId === '0000000000') {
-				const dest = draft.destination
+		if (draft.destination.type === "SQS") {
+			const queueURL = new URL(draft.destination.queueUrl);
+			const accountId = queueURL.pathname.split("/")[1];
+			if (accountId === "0000000000") {
+				const dest = draft.destination;
 				throw new CommercetoolsError<InvalidInputError>(
 					{
-						code: 'InvalidInput',
+						code: "InvalidInput",
 						message:
-							'A test message could not be delivered to this destination: ' +
+							"A test message could not be delivered to this destination: " +
 							`SQS ${dest.queueUrl} in ${dest.region} for ${dest.accessKey}. ` +
-							'Please make sure your destination is correctly configured.',
+							"Please make sure your destination is correctly configured.",
 					},
-					400
-				)
+					400,
+				);
 			}
 		}
 
@@ -37,13 +48,26 @@ export class SubscriptionRepository extends AbstractResourceRepository<'subscrip
 			changes: draft.changes || [],
 			destination: draft.destination,
 			format: draft.format || {
-				type: 'Platform',
+				type: "Platform",
 			},
 			key: draft.key,
 			messages: draft.messages || [],
-			status: 'Healthy',
-		}
-		this.saveNew(context, resource)
-		return resource
+			status: "Healthy",
+		};
+		return this.saveNew(context, resource);
+	}
+}
+
+class SubscriptionUpdateHandler
+	extends AbstractUpdateHandler
+	implements
+		Partial<UpdateHandlerInterface<Subscription, SubscriptionUpdateAction>>
+{
+	setKey(
+		_context: RepositoryContext,
+		resource: Writable<Subscription>,
+		{ key }: SubscriptionSetKeyAction,
+	) {
+		resource.key = key;
 	}
 }

package/src/repositories/tax-category/actions.ts

@@ -0,0 +1,94 @@
+import type {
+	TaxCategory,
+	TaxCategoryAddTaxRateAction,
+	TaxCategoryChangeNameAction,
+	TaxCategoryRemoveTaxRateAction,
+	TaxCategoryReplaceTaxRateAction,
+	TaxCategorySetDescriptionAction,
+	TaxCategorySetKeyAction,
+	TaxCategoryUpdateAction,
+} from "@commercetools/platform-sdk";
+import type { Writable } from "~src/types";
+import { AbstractUpdateHandler, RepositoryContext } from "../abstract";
+import { taxRateFromTaxRateDraft } from "./helpers";
+
+type TaxCategoryUpdateHandlerMethod<T> = (
+	context: RepositoryContext,
+	resource: Writable<TaxCategory>,
+	action: T,
+) => void;
+
+type TaxCategoryUpdateActions = {
+	[P in TaxCategoryUpdateAction as P["action"]]: TaxCategoryUpdateHandlerMethod<P>;
+};
+
+export class TaxCategoryUpdateHandler
+	extends AbstractUpdateHandler
+	implements TaxCategoryUpdateActions
+{
+	addTaxRate(
+		context: RepositoryContext,
+		resource: Writable<TaxCategory>,
+		{ taxRate }: TaxCategoryAddTaxRateAction,
+	) {
+		if (resource.rates === undefined) {
+			resource.rates = [];
+		}
+		resource.rates.push(taxRateFromTaxRateDraft(taxRate));
+	}
+
+	changeName(
+		context: RepositoryContext,
+		resource: Writable<TaxCategory>,
+		{ name }: TaxCategoryChangeNameAction,
+	) {
+		resource.name = name;
+	}
+
+	removeTaxRate(
+		context: RepositoryContext,
+		resource: Writable<TaxCategory>,
+		{ taxRateId }: TaxCategoryRemoveTaxRateAction,
+	) {
+		if (resource.rates === undefined) {
+			resource.rates = [];
+		}
+		resource.rates = resource.rates.filter(
+			(taxRate) => taxRate.id !== taxRateId,
+		);
+	}
+
+	replaceTaxRate(
+		context: RepositoryContext,
+		resource: Writable<TaxCategory>,
+		{ taxRateId, taxRate }: TaxCategoryReplaceTaxRateAction,
+	) {
+		if (resource.rates === undefined) {
+			resource.rates = [];
+		}
+
+		const taxRateObj = taxRateFromTaxRateDraft(taxRate);
+		for (let i = 0; i < resource.rates.length; i++) {
+			const rate = resource.rates[i];
+			if (rate.id === taxRateId) {
+				resource.rates[i] = taxRateObj;
+			}
+		}
+	}
+
+	setDescription(
+		context: RepositoryContext,
+		resource: Writable<TaxCategory>,
+		{ description }: TaxCategorySetDescriptionAction,
+	) {
+		resource.description = description;
+	}
+
+	setKey(
+		context: RepositoryContext,
+		resource: Writable<TaxCategory>,
+		{ key }: TaxCategorySetKeyAction,
+	) {
+		resource.key = key;
+	}
+}

package/src/repositories/tax-category/helpers.ts

@@ -0,0 +1,8 @@
+import { TaxRate, TaxRateDraft } from "@commercetools/platform-sdk";
+import { v4 as uuidv4 } from "uuid";
+
+export const taxRateFromTaxRateDraft = (draft: TaxRateDraft): TaxRate => ({
+	...draft,
+	id: uuidv4(),
+	amount: draft.amount || 0,
+});

package/src/repositories/tax-category/index.ts

@@ -0,0 +1,25 @@
+import type {
+	TaxCategory,
+	TaxCategoryDraft,
+} from "@commercetools/platform-sdk";
+import { getBaseResourceProperties } from "~src/helpers";
+import { AbstractStorage } from "~src/storage/abstract";
+import { AbstractResourceRepository, RepositoryContext } from "../abstract";
+import { TaxCategoryUpdateHandler } from "./actions";
+import { taxRateFromTaxRateDraft } from "./helpers";
+
+export class TaxCategoryRepository extends AbstractResourceRepository<"tax-category"> {
+	constructor(storage: AbstractStorage) {
+		super("tax-category", storage);
+		this.actions = new TaxCategoryUpdateHandler(this._storage);
+	}
+
+	create(context: RepositoryContext, draft: TaxCategoryDraft): TaxCategory {
+		const resource: TaxCategory = {
+			...getBaseResourceProperties(),
+			...draft,
+			rates: draft.rates?.map(taxRateFromTaxRateDraft) || [],
+		};
+		return this.saveNew(context, resource);
+	}
+}