@unchainedshop/core 4.8.18 → 4.8.19

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/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/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/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/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.19",
   "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"
   }
 }