@unchainedshop/core 5.0.0-alpha.2 → 5.0.0-alpha.3

package/lib/factory/registerOrderPricing.js

@@ -0,0 +1,30 @@
+import { OrderPricingAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerOrderPricing({ adapterId, orderIndex, isActivatedFor, calculate, }) {
+    const adapter = {
+        ...OrderPricingAdapter,
+        key: `shop.unchained.pricing.order-${adapterId}`,
+        label: 'Order Pricing: ' + adapterId,
+        version: '1.0.0',
+        orderIndex: orderIndex ?? 0,
+        isActivatedFor: (context) => (isActivatedFor ? isActivatedFor(context) : true),
+        actions: (params) => {
+            const pricingAdapter = OrderPricingAdapter.actions(params);
+            return {
+                ...pricingAdapter,
+                calculate: async () => {
+                    await calculate(pricingAdapter.resultSheet(), params.context);
+                    return pricingAdapter.calculate();
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerPaymentPricing.d.ts

@@ -0,0 +1,7 @@
+import { type IPlugin, type IPaymentPricingSheet, type PaymentPricingAdapterContext } from '../core-index.ts';
+export default function registerPaymentPricing({ adapterId, orderIndex, isActivatedFor, calculate, }: {
+    adapterId: string;
+    orderIndex?: number;
+    isActivatedFor?: (context: PaymentPricingAdapterContext) => boolean;
+    calculate: (sheet: IPaymentPricingSheet, context: PaymentPricingAdapterContext) => Promise<void>;
+}): IPlugin;

package/lib/factory/registerPaymentPricing.js

@@ -0,0 +1,30 @@
+import { PaymentPricingAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerPaymentPricing({ adapterId, orderIndex, isActivatedFor, calculate, }) {
+    const adapter = {
+        ...PaymentPricingAdapter,
+        key: `shop.unchained.pricing.payment-${adapterId}`,
+        label: 'Payment Pricing: ' + adapterId,
+        version: '1.0.0',
+        orderIndex: orderIndex ?? 0,
+        isActivatedFor: (context) => (isActivatedFor ? isActivatedFor(context) : true),
+        actions: (params) => {
+            const pricingAdapter = PaymentPricingAdapter.actions(params);
+            return {
+                ...pricingAdapter,
+                calculate: async () => {
+                    await calculate(pricingAdapter.resultSheet(), params.context);
+                    return pricingAdapter.calculate();
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerPaymentProvider.d.ts

@@ -0,0 +1,15 @@
+import type { PaymentConfiguration } from '@unchainedshop/core-payment';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { type PaymentContext, type PaymentChargeActionResult, type PaymentError, type IPlugin } from '../core-index.ts';
+export default function registerPaymentProvider({ adapterId, type, charge, sign, validate, isActive, isPayLaterAllowed, configurationError, cancel, confirm, }: {
+    adapterId: string;
+    type?: PaymentProviderType;
+    charge: false | ((configuration: PaymentConfiguration, context: PaymentContext) => Promise<PaymentChargeActionResult | false>);
+    sign?: (configuration: PaymentConfiguration, context: PaymentContext) => Promise<string | null>;
+    validate?: (configuration: PaymentConfiguration, context: PaymentContext) => Promise<boolean>;
+    isActive?: boolean;
+    isPayLaterAllowed?: boolean;
+    configurationError?: PaymentError | null;
+    cancel?: (configuration: PaymentConfiguration, context: PaymentContext) => Promise<boolean>;
+    confirm?: (configuration: PaymentConfiguration, context: PaymentContext) => Promise<boolean>;
+}): IPlugin;

package/lib/factory/registerPaymentProvider.js

@@ -0,0 +1,53 @@
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { PaymentAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerPaymentProvider({ adapterId, type, charge, sign, validate, isActive, isPayLaterAllowed, configurationError, cancel, confirm, }) {
+    const providerType = type ?? PaymentProviderType.GENERIC;
+    const adapter = {
+        ...PaymentAdapter,
+        key: `shop.unchained.payment.${adapterId}`,
+        label: 'Payment: ' + adapterId,
+        version: '1.0.0',
+        initialConfiguration: [],
+        typeSupported: (t) => {
+            return t === providerType;
+        },
+        actions: (config, context) => {
+            return {
+                ...PaymentAdapter.actions(config, context),
+                isActive: () => {
+                    return isActive ?? true;
+                },
+                isPayLaterAllowed: () => {
+                    return isPayLaterAllowed ?? false;
+                },
+                configurationError: () => {
+                    return configurationError ?? null;
+                },
+                sign: async () => {
+                    return sign ? sign(config, context) : null;
+                },
+                validate: async () => {
+                    return validate ? validate(config, context) : false;
+                },
+                cancel: async () => {
+                    return cancel ? cancel(config, context) : false;
+                },
+                confirm: async () => {
+                    return confirm ? confirm(config, context) : false;
+                },
+                charge: async () => {
+                    return typeof charge === 'function' ? await charge(config, context) : charge;
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerProductDiscount.d.ts

@@ -0,0 +1,20 @@
+import { type IPlugin, type IPricingSheet, type ProductDiscountConfiguration } from '../core-index.ts';
+import type { PricingCalculation } from '@unchainedshop/utils';
+export default function registerProductDiscount({ adapterId, orderIndex, isManualAdditionAllowed, isManualRemovalAllowed, isValidForSystemTriggering, isValidForCodeTriggering, discountForPricingAdapterKey, reserve, release, }: {
+    adapterId: string;
+    orderIndex?: number;
+    isManualAdditionAllowed?: (code?: string) => Promise<boolean>;
+    isManualRemovalAllowed?: () => Promise<boolean>;
+    isValidForSystemTriggering?: () => Promise<boolean>;
+    isValidForCodeTriggering?: (params: {
+        code: string;
+    }) => Promise<boolean>;
+    discountForPricingAdapterKey: (params: {
+        pricingAdapterKey: string;
+        calculationSheet: IPricingSheet<PricingCalculation>;
+    }) => ProductDiscountConfiguration | null;
+    reserve?: (params: {
+        code?: string;
+    }) => Promise<any>;
+    release?: () => Promise<void>;
+}): IPlugin;

package/lib/factory/registerProductDiscount.js

@@ -0,0 +1,47 @@
+import { ProductDiscountAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerProductDiscount({ adapterId, orderIndex, isManualAdditionAllowed, isManualRemovalAllowed, isValidForSystemTriggering, isValidForCodeTriggering, discountForPricingAdapterKey, reserve, release, }) {
+    const adapter = {
+        ...ProductDiscountAdapter,
+        key: `shop.unchained.discount.product-${adapterId}`,
+        label: 'Product Discount: ' + adapterId,
+        version: '1.0.0',
+        orderIndex: orderIndex ?? 0,
+        isManualAdditionAllowed: async (code) => {
+            return isManualAdditionAllowed
+                ? isManualAdditionAllowed(code)
+                : ProductDiscountAdapter.isManualAdditionAllowed(code);
+        },
+        isManualRemovalAllowed: async () => {
+            return isManualRemovalAllowed
+                ? isManualRemovalAllowed()
+                : ProductDiscountAdapter.isManualRemovalAllowed();
+        },
+        actions: async (params) => {
+            return {
+                ...(await ProductDiscountAdapter.actions(params)),
+                isValidForSystemTriggering: async () => {
+                    return isValidForSystemTriggering ? isValidForSystemTriggering() : false;
+                },
+                isValidForCodeTriggering: async ({ code }) => {
+                    return isValidForCodeTriggering ? isValidForCodeTriggering({ code }) : false;
+                },
+                discountForPricingAdapterKey,
+                reserve: async ({ code }) => {
+                    return reserve ? reserve({ code }) : {};
+                },
+                release: async () => {
+                    return release ? release() : undefined;
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerProductDiscoverabilityFilter.d.ts

@@ -1,5 +1,6 @@
 import { type IPlugin } from '../core-index.ts';
-export default function registerProductDiscoverabilityFilter({ orderIndex, hiddenTagValue, }: {
+export default function registerProductDiscoverabilityFilter({ adapterId, orderIndex, hiddenTagValue, }: {
+    adapterId?: string;
     orderIndex?: number;
     hiddenTagValue?: string;
 }): IPlugin;

package/lib/factory/registerProductDiscoverabilityFilter.js

@@ -1,10 +1,13 @@
 import { FilterAdapter } from "../core-index.js";
 import { pluginRegistry } from "../plugins/PluginRegistry.js";
-export default function registerProductDiscoverabilityFilter({ orderIndex = 0, hiddenTagValue = 'hidden', }) {
+export default function registerProductDiscoverabilityFilter({ adapterId, orderIndex = 0, hiddenTagValue = 'hidden', }) {
+    const id = adapterId ?? crypto.randomUUID();
     const adapter = {
         ...FilterAdapter,
-        key: `shop.unchained.filters.product-discoverability-${crypto.randomUUID()}`,
-        label: 'Product Discoverability Filter (auto-generated)',
+        key: `shop.unchained.filters.product-discoverability-${id}`,
+        label: adapterId
+            ? `Product Discoverability Filter: ${adapterId}`
+            : 'Product Discoverability Filter (auto-generated)',
         version: '1.0.0',
         orderIndex,
         actions: (params) => {

package/lib/factory/registerProductPricing.d.ts

@@ -0,0 +1,7 @@
+import { type IPlugin, type IProductPricingSheet, type ProductPricingAdapterContext } from '../core-index.ts';
+export default function registerProductPricing({ adapterId, orderIndex, isActivatedFor, calculate, }: {
+    adapterId: string;
+    orderIndex?: number;
+    isActivatedFor?: (context: ProductPricingAdapterContext) => boolean;
+    calculate: (sheet: IProductPricingSheet, context: ProductPricingAdapterContext) => Promise<void>;
+}): IPlugin;

package/lib/factory/registerProductPricing.js

@@ -0,0 +1,30 @@
+import { ProductPricingAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerProductPricing({ adapterId, orderIndex, isActivatedFor, calculate, }) {
+    const adapter = {
+        ...ProductPricingAdapter,
+        key: `shop.unchained.pricing.product-${adapterId}`,
+        label: 'Product Pricing: ' + adapterId,
+        version: '1.0.0',
+        orderIndex: orderIndex ?? 0,
+        isActivatedFor: (context) => (isActivatedFor ? isActivatedFor(context) : true),
+        actions: (params) => {
+            const pricingAdapter = ProductPricingAdapter.actions(params);
+            return {
+                ...pricingAdapter,
+                calculate: async () => {
+                    await calculate(pricingAdapter.resultSheet(), params.context);
+                    return pricingAdapter.calculate();
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerProductSearchFilter.d.ts

@@ -1,6 +1,7 @@
 import type { SearchQuery } from '@unchainedshop/core-filters';
 import { type IPlugin } from '../core-index.ts';
-export default function registerProductSearchFilter({ orderIndex, search, }: {
+export default function registerProductSearchFilter({ adapterId, orderIndex, search, }: {
+    adapterId?: string;
     orderIndex?: number;
     search: (params: SearchQuery & {
         queryString: string;

package/lib/factory/registerProductSearchFilter.js

@@ -1,10 +1,11 @@
 import { FilterAdapter } from "../core-index.js";
 import { pluginRegistry } from "../plugins/PluginRegistry.js";
-export default function registerProductSearchFilter({ orderIndex = 0, search, }) {
+export default function registerProductSearchFilter({ adapterId, orderIndex = 0, search, }) {
+    const id = adapterId ?? crypto.randomUUID();
     const adapter = {
         ...FilterAdapter,
-        key: `shop.unchained.filters.product-search-${crypto.randomUUID()}`,
-        label: 'Product Search Filter (auto-generated)',
+        key: `shop.unchained.filters.product-search-${id}`,
+        label: adapterId ? `Product Search Filter: ${adapterId}` : 'Product Search Filter (auto-generated)',
         version: '1.0.0',
         orderIndex,
         actions: (params) => {

package/lib/factory/registerQuotation.d.ts

@@ -0,0 +1,12 @@
+import type { QuotationItemConfiguration, QuotationProposal } from '@unchainedshop/core-quotations';
+import { type QuotationContext, type IPlugin } from '../core-index.ts';
+export default function registerQuotation({ adapterId, isManualRequestVerificationRequired, isManualProposalRequired, quote, submitRequest, verifyRequest, rejectRequest, transformItemConfiguration, }: {
+    adapterId: string;
+    isManualRequestVerificationRequired?: boolean;
+    isManualProposalRequired?: boolean;
+    quote?: (context: QuotationContext) => Promise<QuotationProposal>;
+    submitRequest?: (context: QuotationContext) => Promise<boolean>;
+    verifyRequest?: (context: QuotationContext) => Promise<boolean>;
+    rejectRequest?: (context: QuotationContext) => Promise<boolean>;
+    transformItemConfiguration?: (params: QuotationItemConfiguration, context: QuotationContext) => Promise<QuotationItemConfiguration | null>;
+}): IPlugin;

package/lib/factory/registerQuotation.js

@@ -0,0 +1,52 @@
+import { QuotationAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerQuotation({ adapterId, isManualRequestVerificationRequired, isManualProposalRequired, quote, submitRequest, verifyRequest, rejectRequest, transformItemConfiguration, }) {
+    const adapter = {
+        ...QuotationAdapter,
+        key: `shop.unchained.quotation.${adapterId}`,
+        label: 'Quotation: ' + adapterId,
+        version: '1.0.0',
+        isActivatedFor: () => {
+            return true;
+        },
+        actions: (context) => {
+            return {
+                ...QuotationAdapter.actions(context),
+                configurationError: () => {
+                    return null;
+                },
+                isManualRequestVerificationRequired: async () => {
+                    return isManualRequestVerificationRequired ?? true;
+                },
+                isManualProposalRequired: async () => {
+                    return isManualProposalRequired ?? true;
+                },
+                quote: async () => {
+                    return quote ? quote(context) : {};
+                },
+                submitRequest: async () => {
+                    return submitRequest ? submitRequest(context) : true;
+                },
+                verifyRequest: async () => {
+                    return verifyRequest ? verifyRequest(context) : true;
+                },
+                rejectRequest: async () => {
+                    return rejectRequest ? rejectRequest(context) : true;
+                },
+                transformItemConfiguration: async (params) => {
+                    return transformItemConfiguration
+                        ? transformItemConfiguration(params, context)
+                        : { quantity: params.quantity, configuration: params.configuration };
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerWorker.js

@@ -5,7 +5,7 @@ export default function registerWorker({ type, external, maxParallelAllocations,
         ...WorkerAdapter,
         key: 'shop.unchained.worker.' + type.toLowerCase(),
         label: 'Worker: ' + type,
-        version: '1.0',
+        version: '1.0.0',
         external: external ?? false,
         maxParallelAllocations,
         type,

package/lib/services/addMultipleCartProducts.js

@@ -1,4 +1,5 @@
 import { ordersSettings } from '@unchainedshop/core-orders';
+import { createServiceError } from "../errors.js";
 export async function addMultipleCartProductsService({ orderId, items, context, }) {
     const order = await this.orders.findOrder({ orderId });
     if (!order)
@@ -6,10 +7,10 @@ export async function addMultipleCartProductsService({ orderId, items, context,
     for (const { productId, quantity, configuration } of items) {
         const originalProduct = await this.products.findProduct({ productId });
         if (!originalProduct) {
-            throw new Error(`Product not found: ${productId}`);
+            throw createServiceError('ProductNotFoundError', `Product not found: ${productId}`);
         }
         if (quantity < 1) {
-            throw new Error(`Invalid quantity for product: ${productId}`);
+            throw createServiceError('InvalidQuantityError', `Invalid quantity for product: ${productId}`);
         }
         const product = await this.products.resolveOrderableProduct(originalProduct, { configuration });
         await ordersSettings.validateOrderPosition({ order, product, configuration, quantityDiff: quantity }, { modules: this, ...context });

package/lib/services/createFilter.d.ts

@@ -0,0 +1,3 @@
+import type { Filter } from '@unchainedshop/core-filters';
+import type { Modules } from '../modules.ts';
+export declare function createFilterService(this: Modules, filter: Parameters<Modules['filters']['create']>[0]): Promise<Filter>;

package/lib/services/createFilter.js

@@ -0,0 +1,6 @@
+import { FilterDirector } from "../core-index.js";
+export async function createFilterService(filter) {
+    const newFilter = await this.filters.create(filter);
+    await FilterDirector.invalidateProductIdCache(newFilter, { modules: this });
+    return newFilter;
+}

package/lib/services/createFilterOption.d.ts

@@ -0,0 +1,5 @@
+import type { Filter } from '@unchainedshop/core-filters';
+import type { Modules } from '../modules.ts';
+export declare function createFilterOptionService(this: Modules, filterId: string, { value }: {
+    value: string;
+}): Promise<Filter | null>;

package/lib/services/createFilterOption.js

@@ -0,0 +1,8 @@
+import { FilterDirector } from "../core-index.js";
+export async function createFilterOptionService(filterId, { value }) {
+    const filter = await this.filters.createFilterOption(filterId, { value });
+    if (filter) {
+        await FilterDirector.invalidateProductIdCache(filter, { modules: this });
+    }
+    return filter;
+}

package/lib/services/createSignedURL.js

@@ -1,12 +1,13 @@
 import { getFileFromFileData } from '@unchainedshop/core-files';
 import { getFileAdapter } from "../utils/getFileAdapter.js";
+import { createServiceError } from "../errors.js";
 export async function createSignedURLService({ directoryName, fileName, meta }) {
     const fileUploadAdapter = getFileAdapter();
     const preparedFileData = await fileUploadAdapter.createSignedURL(directoryName, fileName, {
         modules: this,
     });
     if (!preparedFileData)
-        throw new Error('Could not prepare signed URL');
+        throw createServiceError('SignedURLPreparationError', 'Could not prepare signed URL');
     const fileData = getFileFromFileData(preparedFileData, meta);
     const fileId = await this.files.create(fileData);
     const file = await this.files.findFile({ fileId });

package/lib/services/deleteCart.d.ts

@@ -0,0 +1,2 @@
+import type { Modules } from '../modules.ts';
+export declare function deleteCartService(this: Modules, orderId: string): Promise<number>;

package/lib/services/deleteCart.js

@@ -0,0 +1,7 @@
+export async function deleteCartService(orderId) {
+    await this.orders.positions.deleteOrderPositions(orderId);
+    await this.orders.payments.deleteOrderPayments(orderId);
+    await this.orders.deliveries.deleteOrderDeliveries(orderId);
+    await this.orders.discounts.deleteOrderDiscounts(orderId);
+    return this.orders.delete(orderId);
+}

package/lib/services/deleteDeadCarts.d.ts

@@ -0,0 +1,2 @@
+import type { Modules } from '../modules.ts';
+export declare function deleteDeadCartsService(this: Modules): Promise<number>;

package/lib/services/deleteDeadCarts.js

@@ -0,0 +1,17 @@
+import { deleteCartService } from "./deleteCart.js";
+export async function deleteDeadCartsService() {
+    const cartUserIds = (await this.orders.findCartUserIds()).filter(Boolean);
+    if (!cartUserIds.length)
+        return 0;
+    const existingUserIds = new Set(await this.users.findExistingUserIds({ userIds: cartUserIds }));
+    const deadUserIds = cartUserIds.filter((userId) => !existingUserIds.has(userId));
+    if (!deadUserIds.length)
+        return 0;
+    const deadCarts = await this.orders.findCarts({ userIds: deadUserIds }, { projection: { _id: 1 } });
+    let deletedCount = 0;
+    await Array.fromAsync(deadCarts, async (cart) => {
+        await deleteCartService.bind(this)(cart._id);
+        deletedCount += 1;
+    });
+    return deletedCount;
+}

package/lib/services/deleteUser.js

@@ -1,3 +1,4 @@
+import { deleteCartService } from "./deleteCart.js";
 export async function deleteUserService({ userId }) {
     const user = await this.users.markDeleted(userId);
     if (!user)
@@ -11,11 +12,7 @@ export async function deleteUserService({ userId }) {
     }
     const carts = (await this.orders.findOrders({ userId, includeCarts: true })).filter((c) => c.status === null);
     await Array.fromAsync(carts, async (userCart) => {
-        await this.orders.positions.deleteOrderPositions(userCart?._id);
-        await this.orders.payments.deleteOrderPayments(userCart?._id);
-        await this.orders.deliveries.deleteOrderDeliveries(userCart?._id);
-        await this.orders.discounts.deleteOrderDiscounts(userCart?._id);
-        await this.orders.delete(userCart?._id);
+        await deleteCartService.bind(this)(userCart._id);
     });
     const ordersCount = await this.orders.count({ userId, includeCarts: true });
     const quotationsCount = await this.quotations.count({ userId });

package/lib/services/index.d.ts

@@ -15,6 +15,7 @@ import { initCartProvidersService } from './initCartProviders.ts';
 import { updateCalculationService } from './updateCalculation.ts';
 import { supportedDeliveryProvidersService } from './supportedDeliveryProviders.ts';
 import { deleteUserService } from './deleteUser.ts';
+import { deleteCartService } from './deleteCart.ts';
 import { supportedPaymentProvidersService } from './supportedPaymentProviders.ts';
 import { supportedWarehousingProvidersService } from './supportedWarehousingProviders.ts';
 import { createEnrollmentFromCheckoutService } from './createEnrollmentFromCheckout.ts';
@@ -40,6 +41,10 @@ import { verifyQuotationService } from './verifyQuotation.ts';
 import { loadFiltersService } from './loadFilters.ts';
 import { loadFilterOptionsService } from './loadFilterOptions.ts';
 import { removeFilterService } from './removeFilter.ts';
+import { createFilterService } from './createFilter.ts';
+import { updateFilterService } from './updateFilter.ts';
+import { createFilterOptionService } from './createFilterOption.ts';
+import { removeFilterOptionService } from './removeFilterOption.ts';
 import { removeCartDiscountService } from './removeCartDiscount.ts';
 import { addMultipleCartProductsService } from './addMultipleCartProducts.ts';
 import { ercMetadataService } from './ercMetadata.ts';
@@ -77,6 +82,7 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         registerPaymentCredentials: Bound<typeof registerPaymentCredentialsService>;
         calculateDiscountTotal: Bound<typeof calculateDiscountTotalService>;
         migrateOrderCarts: Bound<typeof migrateOrderCartsService>;
+        deleteCart: Bound<typeof deleteCartService>;
         nextUserCart: Bound<typeof nextUserCartService>;
         findOrInitCart: Bound<typeof findOrInitCartService>;
         initCartProviders: Bound<typeof initCartProvidersService>;
@@ -129,6 +135,10 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         loadFilters: Bound<typeof loadFiltersService>;
         loadFilterOptions: Bound<typeof loadFilterOptionsService>;
         removeFilter: Bound<typeof removeFilterService>;
+        createFilter: Bound<typeof createFilterService>;
+        updateFilter: Bound<typeof updateFilterService>;
+        createFilterOption: Bound<typeof createFilterOptionService>;
+        removeFilterOption: Bound<typeof removeFilterOptionService>;
     };
     warehousing: {
         ercMetadata: Bound<typeof ercMetadataService>;

package/lib/services/index.js

@@ -14,6 +14,7 @@ import { initCartProvidersService } from "./initCartProviders.js";
 import { updateCalculationService } from "./updateCalculation.js";
 import { supportedDeliveryProvidersService } from "./supportedDeliveryProviders.js";
 import { deleteUserService } from "./deleteUser.js";
+import { deleteCartService } from "./deleteCart.js";
 import { supportedPaymentProvidersService } from "./supportedPaymentProviders.js";
 import { supportedWarehousingProvidersService } from "./supportedWarehousingProviders.js";
 import { createEnrollmentFromCheckoutService } from "./createEnrollmentFromCheckout.js";
@@ -39,6 +40,10 @@ import { verifyQuotationService } from "./verifyQuotation.js";
 import { loadFiltersService } from "./loadFilters.js";
 import { loadFilterOptionsService } from "./loadFilterOptions.js";
 import { removeFilterService } from "./removeFilter.js";
+import { createFilterService } from "./createFilter.js";
+import { updateFilterService } from "./updateFilter.js";
+import { createFilterOptionService } from "./createFilterOption.js";
+import { removeFilterOptionService } from "./removeFilterOption.js";
 import { removeCartDiscountService } from "./removeCartDiscount.js";
 import { addMultipleCartProductsService } from "./addMultipleCartProducts.js";
 import { ercMetadataService } from "./ercMetadata.js";
@@ -88,6 +93,7 @@ export default function initServices(modules, customServices = {}) {
             registerPaymentCredentials: registerPaymentCredentialsService,
             calculateDiscountTotal: calculateDiscountTotalService,
             migrateOrderCarts: migrateOrderCartsService,
+            deleteCart: deleteCartService,
             nextUserCart: nextUserCartService,
             findOrInitCart: findOrInitCartService,
             initCartProviders: initCartProvidersService,
@@ -140,6 +146,10 @@ export default function initServices(modules, customServices = {}) {
             loadFilters: loadFiltersService,
             loadFilterOptions: loadFilterOptionsService,
             removeFilter: removeFilterService,
+            createFilter: createFilterService,
+            updateFilter: updateFilterService,
+            createFilterOption: createFilterOptionService,
+            removeFilterOption: removeFilterOptionService,
         },
         warehousing: {
             ercMetadata: ercMetadataService,

package/lib/services/loadFilterOptions.js

@@ -1,10 +1,10 @@
-import { FilterType } from '@unchainedshop/core-filters';
+import { filterOptionValues } from '@unchainedshop/core-filters';
 import { FilterDirector, parseQueryArray } from "../directors/FilterDirector.js";
 export async function loadFilterOptionsService(filter, params) {
     const { forceLiveCollection, productIdSet, searchQuery } = params;
     const filterQueryParsed = parseQueryArray(searchQuery?.filterQuery);
     const values = filterQueryParsed[filter.key];
-    const allOptions = (filter.type === FilterType.SWITCH && ['true', 'false']) || filter.options || [];
+    const allOptions = filterOptionValues(filter);
     const mappedOptions = await Promise.all(allOptions.map(async (value) => {
         const filterOptionProductIds = await FilterDirector.filterProductIds(filter, {
             values: [value],
@@ -12,7 +12,7 @@ export async function loadFilterOptionsService(filter, params) {
         }, { modules: this });
         const filteredProductIdSet = productIdSet.intersection(filterOptionProductIds);
         const normalizedValues = values && this.filters.parse(filter, values, [value]);
-        const isSelected = normalizedValues && normalizedValues.indexOf(value) !== -1;
+        const isSelected = Boolean(normalizedValues && normalizedValues.indexOf(value) !== -1);
         if (!filteredProductIdSet.size && !isSelected) {
             return null;
         }

package/lib/services/processEnrollment.js

@@ -1,12 +1,13 @@
 import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
 import { EnrollmentDirector } from "../core-index.js";
+import { createServiceError } from "../errors.js";
 const findNextStatus = async (enrollment, modules) => {
     let status = enrollment.status;
     const product = await modules.products.findProduct({
         productId: enrollment.productId,
     });
     if (!product)
-        throw new Error('Product not found for enrollment');
+        throw createServiceError('ProductNotFoundError', 'Product not found for enrollment');
     const director = await EnrollmentDirector.actions({ enrollment, product }, { modules });
     if (status === EnrollmentStatus.INITIAL || status === EnrollmentStatus.PAUSED) {
         if (await director.isValidForActivation()) {