@unchainedshop/core 4.8.18 → 4.8.20

package/lib/bulk-importer/handlers/product/create.d.ts

@@ -10,7 +10,11 @@ export declare const ProductCreateSpecificationSchema: z.ZodMiniObject<{
         readonly TOKENIZED_PRODUCT: "TOKENIZED_PRODUCT";
     }>;
     sequence: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+        readonly DRAFT: "DRAFT";
+        readonly ACTIVE: "ACTIVE";
+        readonly DELETED: "DELETED";
+    }>>>;
     published: z.ZodMiniOptional<z.ZodMiniNullable<z.iso.ZodMiniISODateTime>>;
     tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     commerce: z.ZodMiniOptional<z.ZodMiniObject<{
@@ -67,7 +71,11 @@ export declare const ProductCreatePayloadSchema: z.ZodMiniObject<{
             readonly TOKENIZED_PRODUCT: "TOKENIZED_PRODUCT";
         }>;
         sequence: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-        status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+        status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+            readonly DRAFT: "DRAFT";
+            readonly ACTIVE: "ACTIVE";
+            readonly DELETED: "DELETED";
+        }>>>;
         published: z.ZodMiniOptional<z.ZodMiniNullable<z.iso.ZodMiniISODateTime>>;
         tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
         commerce: z.ZodMiniOptional<z.ZodMiniObject<{
@@ -170,7 +178,11 @@ declare namespace createProduct {
                 readonly TOKENIZED_PRODUCT: "TOKENIZED_PRODUCT";
             }>;
             sequence: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-            status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+            status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+                readonly DRAFT: "DRAFT";
+                readonly ACTIVE: "ACTIVE";
+                readonly DELETED: "DELETED";
+            }>>>;
             published: z.ZodMiniOptional<z.ZodMiniNullable<z.iso.ZodMiniISODateTime>>;
             tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
             commerce: z.ZodMiniOptional<z.ZodMiniObject<{

package/lib/bulk-importer/handlers/product/create.js

@@ -3,11 +3,11 @@ import upsertVariations, { ProductVariationSchema } from "./upsertVariations.js"
 import upsertMedia from "./upsertMedia.js";
 import { MediaSchema } from "../assortment/upsertMedia.js";
 import convertTagsToLowerCase from "../utils/convertTagsToLowerCase.js";
-import { ProductType } from '@unchainedshop/core-products';
+import { ProductStatus, ProductType } from '@unchainedshop/core-products';
 export const ProductCreateSpecificationSchema = z.object({
     type: z.enum(ProductType),
     sequence: z.optional(z.number()),
-    status: z.nullish(z.string()),
+    status: z.nullish(z.enum(ProductStatus)),
     published: z.nullish(z.iso.datetime()),
     tags: z.optional(z.array(z.string())),
     commerce: z.optional(z.object({
@@ -59,6 +59,7 @@ export const ProductCreatePayloadSchema = z.object({
     media: z.optional(z.array(MediaSchema)),
     variations: z.optional(z.array(ProductVariationSchema)),
 });
+const normalizeStatus = (status) => (status === ProductStatus.DRAFT ? null : status);
 const transformSpecification = (specification) => {
     const { variationResolvers: assignments, content, supply, warehousing, sequence, ...productData } = specification;
     const tags = productData?.tags ? convertTagsToLowerCase(productData.tags) : [];
@@ -66,6 +67,7 @@ const transformSpecification = (specification) => {
     return {
         ...productData,
         published: productData.published ? new Date(productData.published) : undefined,
+        ...(productData.status !== undefined && { status: normalizeStatus(productData.status) }),
         tags,
         warehousing,
         supply,

package/lib/bulk-importer/handlers/product/update.d.ts

@@ -4,7 +4,11 @@ import type { Services } from '../../../services/index.ts';
 export declare const ProductUpdateSpecificationSchema: z.ZodMiniObject<{
     type: z.ZodMiniOptional<z.ZodMiniString<string>>;
     sequence: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-    status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+        readonly DRAFT: "DRAFT";
+        readonly ACTIVE: "ACTIVE";
+        readonly DELETED: "DELETED";
+    }>>>;
     published: z.ZodMiniOptional<z.ZodMiniNullable<z.iso.ZodMiniISODateTime>>;
     tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
     commerce: z.ZodMiniOptional<z.ZodMiniObject<{
@@ -55,7 +59,11 @@ export declare const ProductUpdatePayloadSchema: z.ZodMiniObject<{
     specification: z.ZodMiniOptional<z.ZodMiniObject<{
         type: z.ZodMiniOptional<z.ZodMiniString<string>>;
         sequence: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-        status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+        status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+            readonly DRAFT: "DRAFT";
+            readonly ACTIVE: "ACTIVE";
+            readonly DELETED: "DELETED";
+        }>>>;
         published: z.ZodMiniOptional<z.ZodMiniNullable<z.iso.ZodMiniISODateTime>>;
         tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
         commerce: z.ZodMiniOptional<z.ZodMiniObject<{
@@ -152,7 +160,11 @@ declare namespace updateProduct {
         specification: z.ZodMiniOptional<z.ZodMiniObject<{
             type: z.ZodMiniOptional<z.ZodMiniString<string>>;
             sequence: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-            status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+            status: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniEnum<{
+                readonly DRAFT: "DRAFT";
+                readonly ACTIVE: "ACTIVE";
+                readonly DELETED: "DELETED";
+            }>>>;
             published: z.ZodMiniOptional<z.ZodMiniNullable<z.iso.ZodMiniISODateTime>>;
             tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
             commerce: z.ZodMiniOptional<z.ZodMiniObject<{

package/lib/bulk-importer/handlers/product/update.js

@@ -3,10 +3,11 @@ import upsertVariations, { ProductVariationSchema } from "./upsertVariations.js"
 import upsertMedia, { MediaSchema } from "./upsertMedia.js";
 import createProduct, { ProductCreatePayloadSchema } from "./create.js";
 import convertTagsToLowerCase from "../utils/convertTagsToLowerCase.js";
+import { ProductStatus } from '@unchainedshop/core-products';
 export const ProductUpdateSpecificationSchema = z.object({
     type: z.optional(z.string()),
     sequence: z.optional(z.number()),
-    status: z.nullish(z.string()),
+    status: z.nullish(z.enum(ProductStatus)),
     published: z.nullish(z.iso.datetime()),
     tags: z.optional(z.array(z.string())),
     commerce: z.optional(z.object({
@@ -58,6 +59,7 @@ export const ProductUpdatePayloadSchema = z.object({
     media: z.optional(z.array(MediaSchema)),
     variations: z.optional(z.array(ProductVariationSchema)),
 });
+const normalizeStatus = (status) => (status === ProductStatus.DRAFT ? null : status);
 const transformSpecification = (specification) => {
     const { variationResolvers: assignments, content, supply, warehousing, ...productData } = specification;
     const tags = productData?.tags ? convertTagsToLowerCase(productData.tags) : [];
@@ -65,6 +67,7 @@ const transformSpecification = (specification) => {
     return {
         ...productData,
         published: productData.published ? new Date(productData.published) : undefined,
+        ...(productData.status !== undefined && { status: normalizeStatus(productData.status) }),
         tags,
         warehousing,
         supply,

package/lib/directors/FilterDirector.js

@@ -1,6 +1,6 @@
 import { mongodb } from '@unchainedshop/mongodb';
 import { BaseDirector } from '@unchainedshop/utils';
-import { filtersSettings, FilterType, } from '@unchainedshop/core-filters';
+import { filterCacheGeneration, filtersSettings, FilterType, } from '@unchainedshop/core-filters';
 export const parseQueryArray = (query) => (query || []).reduce((accumulator, { key, value }) => ({
     ...accumulator,
     [key]: accumulator[key] ? accumulator[key].concat(value) : [value],
@@ -70,18 +70,19 @@ export const FilterDirector = {
     },
     async buildProductIdMap(filter, unchainedAPI) {
         const allProductIds = await this.findProductIds(filter, {}, unchainedAPI);
-        const productIdsMap = filter.type === FilterType.SWITCH
-            ? {
-                true: await this.findProductIds(filter, { value: true }, unchainedAPI),
-                false: await this.findProductIds(filter, { value: { $in: [null, false] } }, unchainedAPI),
-            }
-            : await (filter.options || []).reduce(async (accumulatorPromise, option) => {
-                const accumulator = await accumulatorPromise;
-                return {
-                    ...accumulator,
-                    [option]: await this.findProductIds(filter, { value: option }, unchainedAPI),
-                };
-            }, Promise.resolve({}));
+        if (filter.type === FilterType.SWITCH) {
+            return [
+                allProductIds,
+                {
+                    true: await this.findProductIds(filter, { value: true }, unchainedAPI),
+                    false: await this.findProductIds(filter, { value: { $in: [null, false] } }, unchainedAPI),
+                },
+            ];
+        }
+        const productIdsMap = Object.create(null);
+        for (const option of filter.options || []) {
+            productIdsMap[option] = await this.findProductIds(filter, { value: option }, unchainedAPI);
+        }
         return [allProductIds, productIdsMap];
     },
     async filterProductIds(filter, { values, forceLiveCollection }, unchainedAPI) {
@@ -92,11 +93,13 @@ export const FilterDirector = {
             return new Set(allProductIds);
         const result = new Set();
         for (const key of filteredKeys) {
+            if (!Object.hasOwn(keyToProductIdMap, key))
+                continue;
             const additionalValues = keyToProductIdMap[key];
-            if (additionalValues) {
-                for (const val of additionalValues)
-                    result.add(val);
-            }
+            if (!additionalValues)
+                continue;
+            for (const val of additionalValues)
+                result.add(val);
         }
         return result;
     },
@@ -165,6 +168,8 @@ export const FilterDirector = {
         if (!filter)
             return;
         const [productIds, productIdMap] = await this.buildProductIdMap(filter, unchainedAPI);
-        await filtersSettings.setCachedProductIds(filter._id, productIds, productIdMap);
+        if (!(await unchainedAPI.modules.filters.filterExists({ filterId: filter._id })))
+            return;
+        await filtersSettings.setCachedProductIds(filter._id, productIds, productIdMap, filterCacheGeneration(filter));
     },
 };

package/lib/directors/WorkerDirector.js

@@ -54,7 +54,7 @@ export const WorkerDirector = {
             logger.warn(`WorkerDirector: No registered adapter for type: ${type}`);
         }
         try {
-            const output = await adapter.doWork(input, unchainedAPI, workId);
+            const output = await adapter.doWork(input ?? {}, unchainedAPI, workId);
             return output;
         }
         catch (error) {

package/lib/errors.d.ts

@@ -0,0 +1 @@
+export declare const createServiceError: (name: string, message: string) => Error;

package/lib/errors.js

@@ -0,0 +1,5 @@
+export const createServiceError = (name, message) => {
+    const error = new Error(message);
+    error.name = name;
+    return error;
+};

package/lib/factory/registerDeliveryPricing.d.ts

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

package/lib/factory/registerDeliveryPricing.js

@@ -0,0 +1,30 @@
+import { DeliveryPricingAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerDeliveryPricing({ adapterId, orderIndex, isActivatedFor, calculate, }) {
+    const adapter = {
+        ...DeliveryPricingAdapter,
+        key: `shop.unchained.pricing.delivery-${adapterId}`,
+        label: 'Delivery Pricing: ' + adapterId,
+        version: '1.0.0',
+        orderIndex: orderIndex ?? 0,
+        isActivatedFor: (context) => (isActivatedFor ? isActivatedFor(context) : true),
+        actions: (params) => {
+            const pricingAdapter = DeliveryPricingAdapter.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/registerDeliveryProvider.d.ts

@@ -0,0 +1,12 @@
+import type { DeliveryConfiguration } from '@unchainedshop/core-delivery';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { type DeliveryContext, type IPlugin } from '../core-index.ts';
+import type { Work } from '@unchainedshop/core-worker';
+export default function registerDeliveryProvider({ adapterId, type, active, autoReleaseAllowed, estimatedDeliveryThroughput, send, }: {
+    adapterId: string;
+    type?: DeliveryProviderType;
+    active?: boolean;
+    autoReleaseAllowed?: boolean;
+    estimatedDeliveryThroughput?: (warehousingThroughputTime: number, context: DeliveryContext) => Promise<number | null>;
+    send: boolean | ((configuration: DeliveryConfiguration, context: DeliveryContext) => Promise<boolean | Work>);
+}): IPlugin;

package/lib/factory/registerDeliveryProvider.js

@@ -0,0 +1,46 @@
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { DeliveryAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerDeliveryProvider({ adapterId, type = DeliveryProviderType.SHIPPING, active, autoReleaseAllowed, estimatedDeliveryThroughput, send, }) {
+    const adapter = {
+        ...DeliveryAdapter,
+        key: `shop.unchained.delivery.${adapterId}`,
+        label: 'Delivery: ' + adapterId,
+        version: '1.0.0',
+        initialConfiguration: [],
+        typeSupported: (deliveryType) => {
+            return deliveryType === type;
+        },
+        actions: (config, context) => {
+            return {
+                ...DeliveryAdapter.actions(config, context),
+                isActive: () => {
+                    return active ?? true;
+                },
+                isAutoReleaseAllowed: () => {
+                    return autoReleaseAllowed ?? true;
+                },
+                configurationError: () => {
+                    return null;
+                },
+                estimatedDeliveryThroughput: async (warehousingThroughputTime) => {
+                    if (estimatedDeliveryThroughput) {
+                        return estimatedDeliveryThroughput(warehousingThroughputTime, context);
+                    }
+                    return 0;
+                },
+                send: async () => {
+                    return typeof send === 'function' ? await send(config, context) : send;
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerEnrollment.d.ts

@@ -0,0 +1,18 @@
+import type { EnrollmentOrderPositionTemplate, EnrollmentPeriod, EnrollmentPlan } from '@unchainedshop/core-enrollments';
+import type { ProductPlan } from '@unchainedshop/core-products';
+import type { OrderPosition } from '@unchainedshop/core-orders';
+import { type EnrollmentContext, type IPlugin } from '../core-index.ts';
+export default function registerEnrollment({ adapterId, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, }: {
+    adapterId: string;
+    isActivatedFor?: (productPlan?: ProductPlan) => boolean;
+    transformOrderItem?: (orderPosition: OrderPosition, unchainedAPI: any) => Promise<EnrollmentPlan>;
+    configurationForOrder: (params: {
+        period: EnrollmentPeriod;
+    }, context: EnrollmentContext) => Promise<{
+        orderContext?: Record<string, any>;
+        orderPositionTemplates: EnrollmentOrderPositionTemplate[];
+    } | null>;
+    isOverdue?: (context: EnrollmentContext) => Promise<boolean>;
+    isValidForActivation?: (context: EnrollmentContext) => Promise<boolean>;
+    nextPeriod?: (context: EnrollmentContext) => Promise<EnrollmentPeriod | null>;
+}): IPlugin;

package/lib/factory/registerEnrollment.js

@@ -0,0 +1,43 @@
+import { EnrollmentAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerEnrollment({ adapterId, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, }) {
+    const adapter = {
+        ...EnrollmentAdapter,
+        key: `shop.unchained.enrollment.${adapterId}`,
+        label: 'Enrollment: ' + adapterId,
+        version: '1.0.0',
+        isActivatedFor: (productPlan) => {
+            return isActivatedFor ? isActivatedFor(productPlan) : true;
+        },
+        transformOrderItemToEnrollmentPlan: async (orderPosition, unchainedAPI) => {
+            return transformOrderItem
+                ? transformOrderItem(orderPosition, unchainedAPI)
+                : EnrollmentAdapter.transformOrderItemToEnrollmentPlan(orderPosition, unchainedAPI);
+        },
+        actions: (context) => {
+            return {
+                ...EnrollmentAdapter.actions(context),
+                configurationForOrder: async (params) => {
+                    return configurationForOrder(params, context);
+                },
+                isOverdue: async () => {
+                    return isOverdue ? isOverdue(context) : false;
+                },
+                isValidForActivation: async () => {
+                    return isValidForActivation ? isValidForActivation(context) : false;
+                },
+                nextPeriod: async () => {
+                    return nextPeriod ? nextPeriod(context) : EnrollmentAdapter.actions(context).nextPeriod();
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerFileAdapter.d.ts

@@ -0,0 +1,17 @@
+import { type UploadedFile, type UploadFileData } from '@unchainedshop/core-files';
+import { type IPlugin } from '../core-index.ts';
+export default function registerFileAdapter<Context = unknown>({ adapterId, createSignedURL, uploadFileFromStream, createDownloadURL, removeFiles, uploadFileFromURL, }: {
+    adapterId: string;
+    createSignedURL: (directoryName: string, fileName: string, unchainedAPI: Context) => Promise<(UploadFileData & {
+        putURL: string;
+    }) | null>;
+    uploadFileFromStream: (directoryName: string, rawFile: any, unchainedAPI: Context, options?: Record<string, any>) => Promise<UploadFileData>;
+    createDownloadURL?: (file: UploadedFile, expiry?: number) => Promise<string | null>;
+    removeFiles?: (files: UploadedFile[], unchainedContext: Context) => Promise<void>;
+    uploadFileFromURL?: (directoryName: string, fileInput: {
+        fileLink: string;
+        fileName: string;
+        fileId?: string;
+        headers?: Record<string, unknown>;
+    }, unchainedAPI: Context) => Promise<UploadFileData>;
+}): IPlugin;

package/lib/factory/registerFileAdapter.js

@@ -0,0 +1,24 @@
+import { FileAdapter, } from '@unchainedshop/core-files';
+import {} from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerFileAdapter({ adapterId, createSignedURL, uploadFileFromStream, createDownloadURL, removeFiles, uploadFileFromURL, }) {
+    const adapter = {
+        ...FileAdapter,
+        key: `shop.unchained.file-upload.${adapterId}`,
+        label: 'File Adapter: ' + adapterId,
+        version: '1.0.0',
+        createSignedURL,
+        uploadFileFromStream,
+        ...(createDownloadURL ? { createDownloadURL } : {}),
+        ...(removeFiles ? { removeFiles } : {}),
+        ...(uploadFileFromURL ? { uploadFileFromURL } : {}),
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerOrderDiscount.d.ts

@@ -0,0 +1,13 @@
+import type { PricingCalculation } from '@unchainedshop/utils';
+import { type DiscountContext, type IPricingSheet, type OrderDiscountConfiguration, type IPlugin } from '../core-index.ts';
+export default function registerOrderDiscount({ adapterId, isValidForSystemTriggering, isValidForCodeTriggering, discountForPricingAdapterKey, reserve, release, }: {
+    adapterId: string;
+    isValidForSystemTriggering?: (context: DiscountContext) => Promise<boolean>;
+    isValidForCodeTriggering?: (code: string, context: DiscountContext) => Promise<boolean>;
+    discountForPricingAdapterKey: (params: {
+        pricingAdapterKey: string;
+        calculationSheet: IPricingSheet<PricingCalculation>;
+    }, context: DiscountContext) => OrderDiscountConfiguration | null;
+    reserve?: (code: string | undefined, context: DiscountContext) => Promise<any>;
+    release?: (context: DiscountContext) => Promise<void>;
+}): IPlugin;

package/lib/factory/registerOrderDiscount.js

@@ -0,0 +1,39 @@
+import { OrderDiscountAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export default function registerOrderDiscount({ adapterId, isValidForSystemTriggering, isValidForCodeTriggering, discountForPricingAdapterKey, reserve, release, }) {
+    const adapter = {
+        ...OrderDiscountAdapter,
+        key: `shop.unchained.discount.order-${adapterId}`,
+        label: 'Order Discount: ' + adapterId,
+        version: '1.0.0',
+        actions: async ({ context }) => {
+            return {
+                ...(await OrderDiscountAdapter.actions({ context })),
+                isValidForSystemTriggering: async () => {
+                    return isValidForSystemTriggering ? isValidForSystemTriggering(context) : false;
+                },
+                isValidForCodeTriggering: async ({ code }) => {
+                    return isValidForCodeTriggering ? isValidForCodeTriggering(code, context) : false;
+                },
+                discountForPricingAdapterKey: (params) => {
+                    return discountForPricingAdapterKey(params, context);
+                },
+                reserve: async ({ code }) => {
+                    return reserve ? reserve(code, context) : {};
+                },
+                release: async () => {
+                    if (release)
+                        await release(context);
+                },
+            };
+        },
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
+}

package/lib/factory/registerOrderPricing.d.ts

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

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/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/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/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,11 +1,12 @@
 import { getFileFromFileData, getFileAdapter } from '@unchainedshop/core-files';
+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/index.d.ts

@@ -41,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';
@@ -131,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

@@ -40,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";
@@ -142,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],

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()) {

package/lib/services/processOrder.js

@@ -5,6 +5,7 @@ import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
 import { WarehousingDirector, DeliveryDirector, PaymentDirector } from "../directors/index.js";
 import { fulfillQuotationService } from "./fulfillQuotation.js";
 import { createLogger } from '@unchainedshop/logger';
+import { createServiceError } from "../errors.js";
 const logger = createLogger('unchained:core:processOrder');
 const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modules) => {
     if (orderPayment.status !== OrderPaymentStatus.PAID) {
@@ -12,7 +13,7 @@ const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modul
             paymentProviderId: orderPayment.paymentProviderId,
         });
         if (!paymentProvider)
-            throw new Error(`Payment provider not found: ${orderPayment.paymentProviderId}`);
+            throw createServiceError('PaymentProviderNotFoundError', `Payment provider not found: ${orderPayment.paymentProviderId}`);
         const actions = await PaymentDirector.actions(paymentProvider, {}, { modules });
         if (!actions.isPayLaterAllowed())
             return false;
@@ -22,7 +23,7 @@ const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modul
             deliveryProviderId: orderDelivery.deliveryProviderId,
         });
         if (!deliveryProvider)
-            throw new Error(`Delivery provider not found: ${orderDelivery.deliveryProviderId}`);
+            throw createServiceError('DeliveryProviderNotFoundError', `Delivery provider not found: ${orderDelivery.deliveryProviderId}`);
         const director = await DeliveryDirector.actions(deliveryProvider, {}, { modules });
         if (!director.isAutoReleaseAllowed())
             return false;

package/lib/services/processQuotation.js

@@ -1,9 +1,8 @@
 import { QuotationStatus } from '@unchainedshop/core-quotations';
 import { QuotationDirector } from "../core-index.js";
 import { addMessageService } from "./addMessage.js";
-const findNextStatus = async (quotation, modules) => {
+const findNextStatus = async (director, quotation) => {
     let status = quotation.status;
-    const director = await QuotationDirector.actions({ quotation }, { modules });
     if (status === QuotationStatus.REQUESTED) {
         if (!(await director.isManualRequestVerificationRequired())) {
             status = QuotationStatus.PROCESSING;
@@ -19,27 +18,26 @@ const findNextStatus = async (quotation, modules) => {
 export async function processQuotationService(initialQuotation, params) {
     const quotationId = initialQuotation._id;
     let quotation = initialQuotation;
-    let nextStatus = await findNextStatus(quotation, this);
     const director = await QuotationDirector.actions({ quotation }, { modules: this });
+    const runHook = async (hook) => {
+        await hook(params.quotationContext);
+        quotation = (await this.quotations.findQuotation({ quotationId }));
+        return findNextStatus(director, quotation);
+    };
+    let nextStatus = await findNextStatus(director, quotation);
     if (quotation.status === QuotationStatus.REQUESTED && nextStatus !== QuotationStatus.REQUESTED) {
-        await director.submitRequest(params.quotationContext);
+        nextStatus = await runHook(director.submitRequest);
     }
-    quotation = (await this.quotations.findQuotation({ quotationId }));
-    nextStatus = await findNextStatus(quotation, this);
     if (nextStatus !== QuotationStatus.PROCESSING) {
-        await director.verifyRequest(params.quotationContext);
+        nextStatus = await runHook(director.verifyRequest);
     }
-    quotation = (await this.quotations.findQuotation({ quotationId }));
-    nextStatus = await findNextStatus(quotation, this);
     if (nextStatus === QuotationStatus.REJECTED) {
-        await director.rejectRequest(params.quotationContext);
+        nextStatus = await runHook(director.rejectRequest);
     }
-    quotation = (await this.quotations.findQuotation({ quotationId }));
-    nextStatus = await findNextStatus(quotation, this);
     if (nextStatus === QuotationStatus.PROPOSED) {
         const proposal = await director.quote();
         quotation = (await this.quotations.updateProposal(quotation._id, proposal));
-        nextStatus = await findNextStatus(quotation, this);
+        nextStatus = await findNextStatus(director, quotation);
     }
     const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
         status: nextStatus,

package/lib/services/proposeQuotation.js

@@ -3,6 +3,9 @@ import { processQuotationService } from "./processQuotation.js";
 export async function proposeQuotationService(quotation, { quotationContext }) {
     if (quotation.status !== QuotationStatus.PROCESSING)
         return quotation;
+    if (quotationContext) {
+        await this.quotations.updateContext(quotation._id, { context: quotationContext });
+    }
     const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
         status: QuotationStatus.PROPOSED,
         info: 'proposed manually',

package/lib/services/removeFilterOption.d.ts

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

package/lib/services/removeFilterOption.js

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

package/lib/services/removeProduct.js

@@ -1,5 +1,6 @@
 import { ProductStatus } from '@unchainedshop/core-products';
 import { updateCalculationService } from "./updateCalculation.js";
+import { createServiceError } from "../errors.js";
 export async function removeProductService({ productId }) {
     const product = await this.products.findProduct({ productId });
     switch (product?.status) {
@@ -21,7 +22,7 @@ export async function removeProductService({ productId }) {
         case ProductStatus.DELETED:
             return false;
         default:
-            throw new Error(`Invalid status: ${product?.status}`);
+            throw createServiceError('ProductWrongStatusError', `Invalid status: ${product?.status}`);
     }
     return true;
 }

package/lib/services/updateCalculation.js

@@ -1,11 +1,12 @@
 import { OrderDiscountTrigger, } from '@unchainedshop/core-orders';
 import { initCartProvidersService } from "./initCartProviders.js";
 import { updateSchedulingService } from "./updateScheduling.js";
+import { createServiceError } from "../errors.js";
 import { OrderDiscountDirector, OrderPricingDirector, DeliveryPricingDirector, ProductPricingDirector, PaymentPricingDirector, } from "../directors/index.js";
 export async function updateCalculationService(orderId) {
     let order = await this.orders.findOrder({ orderId });
     if (!order)
-        throw new Error('Order not found');
+        throw createServiceError('OrderNotFoundError', 'Order not found');
     if (order.status !== null)
         return order;
     const discounts = await this.orders.discounts.findOrderDiscounts({

package/lib/services/updateFilter.d.ts

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

package/lib/services/updateFilter.js

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

package/lib/services/uploadFileFromStream.js

@@ -1,4 +1,5 @@
 import { getFileFromFileData, getFileAdapter } from '@unchainedshop/core-files';
+import { createServiceError } from "../errors.js";
 export async function uploadFileFromStreamService({ directoryName, rawFile, meta, ...options }) {
     const fileUploadAdapter = getFileAdapter();
     const uploadFileData = await fileUploadAdapter.uploadFileFromStream(directoryName, rawFile, {
@@ -8,6 +9,6 @@ export async function uploadFileFromStreamService({ directoryName, rawFile, meta
     const fileId = await this.files.create(fileData);
     const file = await this.files.findFile({ fileId });
     if (!file)
-        throw new Error('File not found after upload');
+        throw createServiceError('FileNotFoundError', 'File not found after upload');
     return file;
 }

package/lib/services/validateOrder.js

@@ -1,20 +1,19 @@
 import { ordersSettings } from '@unchainedshop/core-orders';
+import { createServiceError } from "../errors.js";
 export async function validateOrderService(order) {
     if (!order.contact)
-        throw new Error('Contact data not provided');
+        throw createServiceError('ContactMissingError', 'Contact data not provided');
     if (!order.billingAddress)
-        throw new Error('Billing address not provided');
+        throw createServiceError('BillingAddressMissingError', 'Billing address not provided');
     if (!order.deliveryId ||
         !(await this.orders.deliveries.findDelivery({ orderDeliveryId: order.deliveryId })))
-        throw new Error('No delivery provider selected');
+        throw createServiceError('NoDeliveryProviderError', 'No delivery provider selected');
     if (!order.paymentId ||
         !(await this.orders.payments.findOrderPayment({ orderPaymentId: order.paymentId })))
-        throw new Error('No payment provider selected');
+        throw createServiceError('NoPaymentProviderError', 'No payment provider selected');
     const orderPositions = await this.orders.positions.findOrderPositions({ orderId: order._id });
     if (orderPositions.length === 0) {
-        const NoItemsError = new Error('No items to checkout');
-        NoItemsError.name = 'NoItemsError';
-        throw NoItemsError;
+        throw createServiceError('NoItemsError', 'No items to checkout');
     }
     for (const orderPosition of orderPositions) {
         const product = await this.products.findProduct({
@@ -31,7 +30,7 @@ export async function validateOrderService(order) {
                 quotationId: orderPosition.quotationId,
             }));
         if (quotation && !this.quotations.isProposalValid(quotation)) {
-            throw new Error('Quotation expired or fullfiled, please request a new offer');
+            throw createServiceError('QuotationInvalidError', 'Quotation expired or fulfilled, please request a new offer');
         }
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/core",
   "description": "Core orchestration package for the Unchained Engine with business services and directors",
-  "version": "4.8.18",
+  "version": "4.8.20",
   "main": "lib/core-index.js",
   "types": "lib/core-index.d.ts",
   "type": "module",
@@ -57,7 +57,7 @@
     "minipass-json-stream": "^1.0.2"
   },
   "devDependencies": {
-    "@types/node": "^25.0.0",
+    "@types/node": "^26.2.0",
     "typescript": "^5.8.3"
   }
 }