@unchainedshop/core 4.6.1 → 4.7.2

package/lib/errors/index.d.ts

@@ -0,0 +1 @@
+export * from './common.ts';

package/lib/errors/index.js

@@ -0,0 +1 @@
+export * from "./common.js";

package/lib/factory/registerAssortmentSearchFilter.d.ts

@@ -1,8 +1,9 @@
 import type { SearchQuery } from '@unchainedshop/core-filters';
+import { type IPlugin } from '../core-index.ts';
 export default function registerAssortmentSearchFilter({ orderIndex, search, }: {
     orderIndex?: number;
     search: (params: SearchQuery & {
         queryString: string;
         locale: Intl.Locale;
     }) => Promise<string[]>;
-}): void;
+}): IPlugin;

package/lib/factory/registerAssortmentSearchFilter.js

@@ -1,6 +1,7 @@
-import { FilterAdapter, FilterDirector } from "../core-index.js";
+import { FilterAdapter } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 export default function registerAssortmentSearchFilter({ orderIndex = 0, search, }) {
-    FilterDirector.registerAdapter({
+    const adapter = {
         ...FilterAdapter,
         key: `shop.unchained.filters.assortment-search-${crypto.randomUUID()}`,
         label: 'Assortment Search Filter (auto-generated)',
@@ -19,5 +20,13 @@ export default function registerAssortmentSearchFilter({ orderIndex = 0, search,
                 },
             };
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/factory/registerInvoicePayment.d.ts

@@ -1,8 +1,8 @@
 import type { PaymentConfiguration } from '@unchainedshop/core-payment';
-import { type PaymentContext, type PaymentChargeActionResult } from '../core-index.ts';
+import { type PaymentContext, type PaymentChargeActionResult, type IPlugin } from '../core-index.ts';
 export default function registerInvoicePayment({ adapterId, active, payLaterAllowed, charge, }: {
     adapterId: string;
     active?: boolean;
     payLaterAllowed?: boolean;
     charge: false | ((configuration: PaymentConfiguration, context: PaymentContext) => Promise<PaymentChargeActionResult | false>);
-}): void;
+}): IPlugin;

package/lib/factory/registerInvoicePayment.js

@@ -1,7 +1,8 @@
-import { PaymentAdapter, PaymentDirector, } from "../core-index.js";
+import { PaymentAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 import { PaymentProviderType } from '@unchainedshop/core-payment';
 export default function registerInvoicePayment({ adapterId, active, payLaterAllowed, charge, }) {
-    PaymentDirector.registerAdapter({
+    const adapter = {
         ...PaymentAdapter,
         key: `shop.unchained.payment.invoice-${adapterId}`,
         label: 'Invoice Payment: ' + adapterId,
@@ -27,5 +28,13 @@ export default function registerInvoicePayment({ adapterId, active, payLaterAllo
                 },
             };
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/factory/registerPhysicalWarehousing.d.ts

@@ -1,9 +1,9 @@
 import type { WarehousingConfiguration } from '@unchainedshop/core-warehousing';
-import { type WarehousingContext } from '../core-index.ts';
+import { type WarehousingContext, type IPlugin } from '../core-index.ts';
 export default function registerPhysicalWarehousing({ adapterId, orderIndex, stock, productionTime, commissioningTime, }: {
     adapterId: string;
     orderIndex?: number;
     stock?: number | ((referenceDate: Date, configuration: WarehousingConfiguration, context: WarehousingContext) => Promise<number>);
     productionTime?: number | ((quantityToProduct: number, configuration: WarehousingConfiguration, context: WarehousingContext) => Promise<number>);
     commissioningTime?: number | ((quantity: number, configuration: WarehousingConfiguration, context: WarehousingContext) => Promise<number>);
-}): void;
+}): IPlugin;

package/lib/factory/registerPhysicalWarehousing.js

@@ -1,7 +1,8 @@
 import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
-import { WarehousingAdapter, WarehousingDirector } from "../core-index.js";
+import { WarehousingAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 export default function registerPhysicalWarehousing({ adapterId, orderIndex = 0, stock, productionTime, commissioningTime, }) {
-    WarehousingDirector.registerAdapter({
+    const adapter = {
         ...WarehousingAdapter,
         key: 'shop.unchained.warehousing.physical.' + adapterId,
         label: 'Physical Warehousing: ' + adapterId,
@@ -49,5 +50,13 @@ export default function registerPhysicalWarehousing({ adapterId, orderIndex = 0,
                 },
             };
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/factory/registerPickUpDelivery.d.ts

@@ -1,5 +1,5 @@
 import { type DeliveryConfiguration, type DeliveryLocation } from '@unchainedshop/core-delivery';
-import { type DeliveryContext } from '../core-index.ts';
+import { type DeliveryContext, type IPlugin } from '../core-index.ts';
 import type { Work } from '@unchainedshop/core-worker';
 export default function registerPickUpDelivery({ adapterId, locations, active, autoReleaseAllowed, estimatedDeliveryThroughput, send, }: {
     adapterId: string;
@@ -8,4 +8,4 @@ export default function registerPickUpDelivery({ adapterId, locations, active, a
     estimatedDeliveryThroughput?: (warehousingThroughputTime: number, context: DeliveryContext) => Promise<number | null>;
     send: boolean | ((configuration: DeliveryConfiguration, context: DeliveryContext) => Promise<boolean | Work>);
     locations: DeliveryLocation[] | ((context: DeliveryContext) => Promise<DeliveryLocation[]>);
-}): void;
+}): IPlugin;

package/lib/factory/registerPickUpDelivery.js

@@ -1,7 +1,8 @@
 import { DeliveryProviderType, } from '@unchainedshop/core-delivery';
-import { DeliveryAdapter, DeliveryDirector } from "../core-index.js";
+import { DeliveryAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 export default function registerPickUpDelivery({ adapterId, locations, active, autoReleaseAllowed, estimatedDeliveryThroughput, send, }) {
-    DeliveryDirector.registerAdapter({
+    const adapter = {
         ...DeliveryAdapter,
         key: `shop.unchained.delivery.pickup-${adapterId}`,
         label: 'PickUp Delivery: ' + adapterId,
@@ -41,5 +42,13 @@ export default function registerPickUpDelivery({ adapterId, locations, active, a
                 },
             };
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/factory/registerProductDiscoverabilityFilter.d.ts

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

package/lib/factory/registerProductDiscoverabilityFilter.js

@@ -1,6 +1,7 @@
-import { FilterAdapter, FilterDirector } from "../core-index.js";
+import { FilterAdapter } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 export default function registerProductDiscoverabilityFilter({ orderIndex = 0, hiddenTagValue = 'hidden', }) {
-    FilterDirector.registerAdapter({
+    const adapter = {
         ...FilterAdapter,
         key: `shop.unchained.filters.product-discoverability-${crypto.randomUUID()}`,
         label: 'Product Discoverability Filter (auto-generated)',
@@ -22,5 +23,13 @@ export default function registerProductDiscoverabilityFilter({ orderIndex = 0, h
                 },
             };
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/factory/registerProductSearchFilter.d.ts

@@ -1,8 +1,9 @@
 import type { SearchQuery } from '@unchainedshop/core-filters';
+import { type IPlugin } from '../core-index.ts';
 export default function registerProductSearchFilter({ orderIndex, search, }: {
     orderIndex?: number;
     search: (params: SearchQuery & {
         queryString: string;
         locale: Intl.Locale;
     }) => Promise<string[]>;
-}): void;
+}): IPlugin;

package/lib/factory/registerProductSearchFilter.js

@@ -1,6 +1,7 @@
-import { FilterAdapter, FilterDirector } from "../core-index.js";
+import { FilterAdapter } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 export default function registerProductSearchFilter({ orderIndex = 0, search, }) {
-    FilterDirector.registerAdapter({
+    const adapter = {
         ...FilterAdapter,
         key: `shop.unchained.filters.product-search-${crypto.randomUUID()}`,
         label: 'Product Search Filter (auto-generated)',
@@ -19,5 +20,13 @@ export default function registerProductSearchFilter({ orderIndex = 0, search, })
                 },
             };
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/factory/registerShippingDelivery.d.ts

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

package/lib/factory/registerShippingDelivery.js

@@ -1,7 +1,8 @@
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
-import { DeliveryAdapter, DeliveryDirector } from "../core-index.js";
+import { DeliveryAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 export default function registerShippingDelivery({ adapterId, active, autoReleaseAllowed, estimatedDeliveryThroughput, send, }) {
-    DeliveryDirector.registerAdapter({
+    const adapter = {
         ...DeliveryAdapter,
         key: `shop.unchained.delivery.shipping-${adapterId}`,
         label: 'Shipping Delivery: ' + adapterId,
@@ -33,5 +34,13 @@ export default function registerShippingDelivery({ adapterId, active, autoReleas
                 },
             };
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/factory/registerVirtualWarehousing.d.ts

@@ -1,5 +1,5 @@
 import { type TokenSurrogate, type WarehousingConfiguration } from '@unchainedshop/core-warehousing';
-import { type WarehousingContext } from '../core-index.ts';
+import { type WarehousingContext, type IPlugin } from '../core-index.ts';
 export default function registerVirtualWarehousing<Metadata = Record<string, any>>({ adapterId, orderIndex, stock, tokenize, tokenMetadata, isInvalidateable, }: {
     adapterId: string;
     orderIndex?: number;
@@ -7,4 +7,4 @@ export default function registerVirtualWarehousing<Metadata = Record<string, any
     tokenize: (configuration: WarehousingConfiguration, context: WarehousingContext) => Promise<Omit<TokenSurrogate, 'userId' | 'productId' | 'orderPositionId'>[]>;
     tokenMetadata?: (serialNumber: string, referenceDate: Date, configuration: WarehousingConfiguration, context: WarehousingContext) => Promise<Metadata>;
     isInvalidateable?: (serialNumber: string, referenceDate: Date, configuration: WarehousingConfiguration, context: WarehousingContext) => Promise<boolean>;
-}): void;
+}): IPlugin;

package/lib/factory/registerVirtualWarehousing.js

@@ -1,7 +1,8 @@
 import { WarehousingProviderType, } from '@unchainedshop/core-warehousing';
-import { WarehousingAdapter, WarehousingDirector } from "../core-index.js";
+import { WarehousingAdapter, } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 export default function registerVirtualWarehousing({ adapterId, orderIndex = 0, stock, tokenize, tokenMetadata, isInvalidateable, }) {
-    WarehousingDirector.registerAdapter({
+    const adapter = {
         ...WarehousingAdapter,
         key: 'shop.unchained.warehousing.virtual.' + adapterId,
         label: 'Virtual Wareshousing: ' + adapterId,
@@ -46,5 +47,13 @@ export default function registerVirtualWarehousing({ adapterId, orderIndex = 0,
                 },
             };
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/factory/registerWorker.d.ts

@@ -1,6 +1,7 @@
+import { type IPlugin } from '../core-index.ts';
 export default function registerWorker<Input = any, Result = any>({ type, external, maxParallelAllocations, process, }: {
     type: string;
     external?: boolean;
     maxParallelAllocations?: number;
     process?: (input: Input, workId: string) => Promise<Result>;
-}): void;
+}): IPlugin;

package/lib/factory/registerWorker.js

@@ -1,6 +1,7 @@
-import { WorkerAdapter, WorkerDirector } from "../core-index.js";
+import { WorkerAdapter } from "../core-index.js";
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
 export default function registerWorker({ type, external, maxParallelAllocations, process, }) {
-    WorkerDirector.registerAdapter({
+    const adapter = {
         ...WorkerAdapter,
         key: 'shop.unchained.worker.' + type.toLowerCase(),
         label: 'Worker: ' + type,
@@ -30,5 +31,13 @@ export default function registerWorker({ type, external, maxParallelAllocations,
                 };
             }
         },
-    });
+    };
+    const plugin = {
+        key: adapter.key,
+        label: adapter.label,
+        version: adapter.version,
+        adapters: [adapter],
+    };
+    pluginRegistry.register(plugin);
+    return plugin;
 }

package/lib/plugins/PluginRegistry.d.ts

@@ -0,0 +1,42 @@
+import type { UnchainedCore } from '../core-index.ts';
+import type { IBaseAdapter } from '@unchainedshop/utils';
+import type { mongodb } from '@unchainedshop/mongodb';
+export interface PluginHttpRoute {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'ALL';
+    handler: (request: Request, context: UnchainedCore & {
+        params: Record<string, string>;
+        userId?: string;
+        impersonatorId?: string;
+    }) => Response | Promise<Response>;
+}
+export type PluginModuleFactory = (options: {
+    db: mongodb.Db;
+}) => Record<string, any>;
+export interface IPlugin {
+    key: string;
+    label: string;
+    version: string;
+    adapters?: IBaseAdapter[];
+    module?: PluginModuleFactory;
+    routes?: PluginHttpRoute[];
+    onRegister?: (unchainedAPI: UnchainedCore) => void | boolean | Promise<void | boolean>;
+    onShutdown?: (unchainedAPI: UnchainedCore) => void | Promise<void>;
+}
+declare class PluginRegistry {
+    private plugins;
+    private moduleFactories;
+    private skippedPlugins;
+    register(plugin: IPlugin): void;
+    initialize(unchainedAPI: UnchainedCore): Promise<void>;
+    getModuleFactories(): PluginModuleFactory[];
+    getRoutes(): PluginHttpRoute[];
+    shutdown(unchainedAPI: UnchainedCore): Promise<void>;
+    getPlugin(key: string): IPlugin | undefined;
+    getAllPlugins(): IPlugin[];
+    getAdapters(adapterType: symbol): IBaseAdapter[];
+    hasPlugin(key: string): boolean;
+    clear(): void;
+}
+export declare const pluginRegistry: PluginRegistry;
+export {};

package/lib/plugins/PluginRegistry.js

@@ -0,0 +1,113 @@
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:core');
+class PluginRegistry {
+    plugins = new Map();
+    moduleFactories = [];
+    skippedPlugins = new Set();
+    register(plugin) {
+        if (this.plugins.has(plugin.key)) {
+            logger.warn(`Plugin ${plugin.key} already registered, skipping`, {
+                label: plugin.label,
+            });
+            return;
+        }
+        logger.info(`Registering plugin: ${plugin.label} (${plugin.key})`, {
+            version: plugin.version,
+        });
+        this.plugins.set(plugin.key, plugin);
+        if (plugin.module) {
+            this.moduleFactories.push(plugin.module);
+        }
+    }
+    async initialize(unchainedAPI) {
+        logger.info(`Initializing ${this.plugins.size} plugins`);
+        const skippedPlugins = new Set();
+        for (const plugin of this.plugins.values()) {
+            if (plugin.onRegister) {
+                try {
+                    const result = await plugin.onRegister(unchainedAPI);
+                    if (result === false) {
+                        skippedPlugins.add(plugin.key);
+                        logger.warn(`Plugin ${plugin.key} skipped adapter registration`, {
+                            label: plugin.label,
+                        });
+                    }
+                    else {
+                        logger.debug(`Plugin ${plugin.key} initialized`, {
+                            label: plugin.label,
+                        });
+                    }
+                }
+                catch (error) {
+                    skippedPlugins.add(plugin.key);
+                    const reason = error instanceof Error ? error.message : String(error);
+                    logger.warn(`Plugin ${plugin.key} skipped adapter registration - ${reason}`, {
+                        label: plugin.label,
+                    });
+                }
+            }
+        }
+        this.skippedPlugins = skippedPlugins;
+    }
+    getModuleFactories() {
+        return this.moduleFactories;
+    }
+    getRoutes() {
+        const routes = [];
+        for (const plugin of this.plugins.values()) {
+            if (this.skippedPlugins.has(plugin.key)) {
+                continue;
+            }
+            if (plugin.routes) {
+                routes.push(...plugin.routes);
+            }
+        }
+        return routes;
+    }
+    async shutdown(unchainedAPI) {
+        logger.info('Shutting down plugins');
+        for (const plugin of this.plugins.values()) {
+            if (plugin.onShutdown) {
+                try {
+                    await plugin.onShutdown(unchainedAPI);
+                    logger.debug(`Plugin ${plugin.key} shutdown complete`, {
+                        label: plugin.label,
+                    });
+                }
+                catch (error) {
+                    logger.error(`Error shutting down plugin ${plugin.key}`, {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+    }
+    getPlugin(key) {
+        return this.plugins.get(key);
+    }
+    getAllPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    getAdapters(adapterType) {
+        const result = [];
+        for (const plugin of this.plugins.values()) {
+            if (!plugin.adapters)
+                continue;
+            for (const adapter of plugin.adapters) {
+                if (adapter.adapterType === adapterType) {
+                    result.push(adapter);
+                }
+            }
+        }
+        return result;
+    }
+    hasPlugin(key) {
+        return this.plugins.has(key);
+    }
+    clear() {
+        this.plugins.clear();
+        this.moduleFactories = [];
+        this.skippedPlugins.clear();
+    }
+}
+export const pluginRegistry = new PluginRegistry();

package/lib/services/addCartDiscount.d.ts

@@ -0,0 +1,10 @@
+import type { OrderDiscount } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+import type { User } from '@unchainedshop/core-users';
+export interface AddCartDiscountParams {
+    orderId?: string;
+    code: string;
+    user: User;
+    countryCode: string;
+}
+export declare function addCartDiscountService(this: Modules, params: AddCartDiscountParams): Promise<OrderDiscount>;

package/lib/services/addCartDiscount.js

@@ -0,0 +1,27 @@
+import { createManualOrderDiscountService } from "./createManualOrderDiscount.js";
+import { updateCalculationService } from "./updateCalculation.js";
+import { findOrInitCartService } from "./findOrInitCart.js";
+import { OrderNotFoundError, OrderWrongStatusError, OrderDiscountCodeAlreadyPresentError, OrderDiscountCodeNotValidError, } from "../errors/index.js";
+export async function addCartDiscountService(params) {
+    const { orderId, code, user, countryCode } = params;
+    const order = await findOrInitCartService.bind(this)({
+        orderId,
+        user,
+        countryCode,
+    });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId: orderId || null });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    if (await this.orders.discounts.isDiscountCodeUsed({ code, orderId: order._id })) {
+        throw new OrderDiscountCodeAlreadyPresentError({ orderId: order._id, code });
+    }
+    const discount = await createManualOrderDiscountService.bind(this)({ order, code });
+    if (!discount) {
+        throw new OrderDiscountCodeNotValidError({ code });
+    }
+    await updateCalculationService.bind(this)(order._id);
+    return discount;
+}

package/lib/services/addCartItem.d.ts

@@ -0,0 +1,15 @@
+import { type OrderPosition } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface AddCartItemParams {
+    orderId?: string;
+    productId: string;
+    quantity: number;
+    configuration?: {
+        key: string;
+        value: string;
+    }[];
+    user: User;
+    countryCode: string;
+}
+export declare function addCartItemService(this: Modules, params: AddCartItemParams, context: any): Promise<OrderPosition>;

package/lib/services/addCartItem.js

@@ -0,0 +1,41 @@
+import { ordersSettings } from '@unchainedshop/core-orders';
+import { findOrInitCartService } from "./findOrInitCart.js";
+import { updateCalculationService } from "./updateCalculation.js";
+import { ProductNotFoundError, OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, } from "../errors/index.js";
+export async function addCartItemService(params, context) {
+    const { orderId, productId: originalProductId, quantity, configuration, user, countryCode } = params;
+    if (quantity < 1) {
+        throw new OrderQuantityTooLowError({ quantity });
+    }
+    const originalProduct = await this.products.findProduct({ productId: originalProductId });
+    if (!originalProduct) {
+        throw new ProductNotFoundError({ productId: originalProductId });
+    }
+    const order = await findOrInitCartService.bind(this)({
+        orderId,
+        user,
+        countryCode,
+    });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    const product = await this.products.resolveOrderableProduct(originalProduct, { configuration });
+    await ordersSettings.validateOrderPosition({
+        order,
+        product,
+        configuration,
+        quantityDiff: quantity,
+    }, context);
+    const orderPosition = await this.orders.positions.addProductItem({
+        quantity,
+        configuration,
+        productId: product._id,
+        originalProductId,
+        orderId: order._id,
+    });
+    await updateCalculationService.bind(this)(order._id);
+    return (await this.orders.positions.findOrderPosition({ itemId: orderPosition._id }));
+}

package/lib/services/addCartQuotation.d.ts

@@ -0,0 +1,16 @@
+import type { OrderPosition } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface AddCartQuotationParams {
+    orderId?: string;
+    quotationId: string;
+    quantity: number;
+    configuration: {
+        key: string;
+        value: string;
+    }[];
+    user: User;
+    countryCode: string;
+    context: unknown;
+}
+export declare function addCartQuotationService(this: Modules, params: AddCartQuotationParams): Promise<OrderPosition>;