@unchainedshop/core 4.8.28 → 4.8.30

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

@@ -28,11 +28,13 @@ const upsert = async (productVariation, unchainedAPI) => {
 };
 export default async function upsertVariations({ variations, productId }, unchainedAPI) {
     const { modules } = unchainedAPI;
-    const upsertedProductVariationIds = await Promise.all(variations.map(async ({ content, options, ...variationsRest }) => {
+    const upsertedProductVariationIds = [];
+    for (const [index, { content, options, ...variationsRest }] of variations.entries()) {
         const variation = await upsert({
             ...variationsRest,
             options: options.map((option) => option.value),
             productId,
+            sortKey: index + 1,
         }, unchainedAPI);
         await Promise.all(options.map(async ({ content: optionContent, value: optionValue }) => {
             if (optionContent) {
@@ -52,8 +54,8 @@ export default async function upsertVariations({ variations, productId }, unchai
                 };
             }));
         }
-        return variation._id;
-    }));
+        upsertedProductVariationIds.push(variation._id);
+    }
     const allVariations = await modules.products.variations.findProductVariations({
         productId,
     });

package/lib/directors/FileDirector.d.ts

@@ -1,10 +1,10 @@
 import type { IFileAdapter, UploadedFile } from '@unchainedshop/core-files';
 export type UploadFileCallback<UnchainedAPI = unknown> = (file: UploadedFile, unchainedAPI: UnchainedAPI) => Promise<void>;
 export declare const FileDirector: {
-    getAdapter: (key: string) => IFileAdapter<unknown> | null;
-    getAdapters: (options?: {
-        adapterFilter?: (adapter: IFileAdapter) => boolean;
-    }) => IFileAdapter<unknown>[];
     registerFileUploadCallback<UnchainedAPI>(directoryName: string, fn: UploadFileCallback<UnchainedAPI>): void;
     getFileUploadCallback(directoryName: string): UploadFileCallback<unknown> | null;
+    getAdapters: (options?: {
+        adapterFilter?: ((adapter: IFileAdapter<unknown>) => boolean) | undefined;
+    } | undefined) => IFileAdapter<unknown>[];
+    getAdapter: (key: string) => IFileAdapter<unknown> | null;
 };

package/lib/directors/FileDirector.js

@@ -1,19 +1,8 @@
-import { BaseDirector } from '@unchainedshop/utils';
 import { FileAdapter } from '@unchainedshop/core-files';
-import { pluginRegistry } from "../plugins/PluginRegistry.js";
+import { registryDirector } from "./registryDirector.js";
 const FileUploadRegistry = new Map();
-const baseDirector = BaseDirector('FileDirector');
 export const FileDirector = {
-    ...baseDirector,
-    getAdapter: (key) => {
-        const adapters = pluginRegistry.getAdapters(FileAdapter.adapterType);
-        return adapters.find((adapter) => adapter.key === key) || null;
-    },
-    getAdapters: (options) => {
-        const { adapterFilter } = options || {};
-        const adapters = pluginRegistry.getAdapters(FileAdapter.adapterType);
-        return adapters.filter(adapterFilter || (() => true));
-    },
+    ...registryDirector(FileAdapter.adapterType),
     registerFileUploadCallback(directoryName, fn) {
         if (!FileUploadRegistry.has(directoryName)) {
             FileUploadRegistry.set(directoryName, fn);

package/lib/directors/FilterDirector.js

@@ -116,7 +116,7 @@ export const FilterDirector = {
                 includeInactive: true,
             })
             : [];
-        const intersectedProductIds = await filters.reduce(async (productIdSetPromise, filter) => {
+        const intersected = await filters.reduce(async (productIdSetPromise, filter) => {
             const productIdSet = await productIdSetPromise;
             if (!parsedFilterQuery[filter.key])
                 return productIdSet;
@@ -127,7 +127,7 @@ export const FilterDirector = {
             }, unchainedAPI);
             return productIdSet.intersection(filterOptionProductIds);
         }, Promise.resolve(new Set(productIds)));
-        return [...intersectedProductIds];
+        return productIds.filter((id) => intersected.has(id));
     },
     async filterFacets(filter, params, unchainedAPI) {
         const { allProductIdSet, searchQuery, forceLiveCollection, otherFilters } = params;

package/lib/directors/registryDirector.d.ts

@@ -0,0 +1,2 @@
+import type { IBaseAdapter, IBaseDirector } from '@unchainedshop/utils';
+export declare const registryDirector: <Adapter extends IBaseAdapter>(adapterType: symbol) => IBaseDirector<Adapter>;

package/lib/directors/registryDirector.js

@@ -0,0 +1,6 @@
+import { pluginRegistry } from "../plugins/PluginRegistry.js";
+export const registryDirector = (adapterType) => ({
+    getAdapter: (key) => pluginRegistry.getAdapters(adapterType).find((adapter) => adapter.key === key) ||
+        null,
+    getAdapters: ({ adapterFilter } = {}) => pluginRegistry.getAdapters(adapterType).filter(adapterFilter || (() => true)),
+});

package/lib/factory/registerEnrollment.d.ts

@@ -2,8 +2,9 @@ import type { EnrollmentOrderPositionTemplate, EnrollmentPeriod, EnrollmentPlan
 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, }: {
+export default function registerEnrollment({ adapterId, orderIndex, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, terminationDate, transformPlanToNewPlan, }: {
     adapterId: string;
+    orderIndex?: number;
     isActivatedFor?: (productPlan?: ProductPlan) => boolean;
     transformOrderItem?: (orderPosition: OrderPosition, unchainedAPI: any) => Promise<EnrollmentPlan>;
     configurationForOrder: (params: {
@@ -15,4 +16,10 @@ export default function registerEnrollment({ adapterId, isActivatedFor, transfor
     isOverdue?: (context: EnrollmentContext) => Promise<boolean>;
     isValidForActivation?: (context: EnrollmentContext) => Promise<boolean>;
     nextPeriod?: (context: EnrollmentContext) => Promise<EnrollmentPeriod | null>;
+    terminationDate?: (context: EnrollmentContext, params: {
+        referenceDate: Date;
+    }) => Promise<Date | null>;
+    transformPlanToNewPlan?: (context: EnrollmentContext, params: {
+        plan: EnrollmentPlan;
+    }) => Promise<EnrollmentPlan | null>;
 }): IPlugin;

package/lib/factory/registerEnrollment.js

@@ -1,11 +1,12 @@
 import { EnrollmentAdapter, } from "../core-index.js";
 import { pluginRegistry } from "../plugins/PluginRegistry.js";
-export default function registerEnrollment({ adapterId, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, }) {
+export default function registerEnrollment({ adapterId, orderIndex, isActivatedFor, transformOrderItem, configurationForOrder, isOverdue, isValidForActivation, nextPeriod, terminationDate, transformPlanToNewPlan, }) {
     const adapter = {
         ...EnrollmentAdapter,
         key: `shop.unchained.enrollment.${adapterId}`,
         label: 'Enrollment: ' + adapterId,
         version: '1.0.0',
+        orderIndex: orderIndex ?? 0,
         isActivatedFor: (productPlan) => {
             return isActivatedFor ? isActivatedFor(productPlan) : true;
         },
@@ -15,20 +16,17 @@ export default function registerEnrollment({ adapterId, isActivatedFor, transfor
                 : EnrollmentAdapter.transformOrderItemToEnrollmentPlan(orderPosition, unchainedAPI);
         },
         actions: (context) => {
+            const base = EnrollmentAdapter.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();
-                },
+                ...base,
+                configurationForOrder: (params) => configurationForOrder(params, context),
+                isOverdue: () => (isOverdue ? isOverdue(context) : base.isOverdue()),
+                isValidForActivation: () => isValidForActivation ? isValidForActivation(context) : base.isValidForActivation(),
+                nextPeriod: () => (nextPeriod ? nextPeriod(context) : base.nextPeriod()),
+                terminationDate: (params) => terminationDate ? terminationDate(context, params) : base.terminationDate(params),
+                transformPlanToNewPlan: (params) => transformPlanToNewPlan
+                    ? transformPlanToNewPlan(context, params)
+                    : base.transformPlanToNewPlan(params),
             };
         },
     };

package/lib/factory/registerQuotation.d.ts

@@ -1,7 +1,8 @@
 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, }: {
+export default function registerQuotation({ adapterId, orderIndex, isManualRequestVerificationRequired, isManualProposalRequired, quote, submitRequest, verifyRequest, rejectRequest, transformItemConfiguration, }: {
     adapterId: string;
+    orderIndex?: number;
     isManualRequestVerificationRequired?: boolean;
     isManualProposalRequired?: boolean;
     quote?: (context: QuotationContext) => Promise<QuotationProposal>;

package/lib/factory/registerQuotation.js

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

package/lib/plugins/PluginRegistry.d.ts

@@ -35,8 +35,9 @@ declare class PluginRegistry {
     getPlugin(key: string): IPlugin | undefined;
     getAllPlugins(): IPlugin[];
     getAdapters(adapterType: symbol): IBaseAdapter[];
+    getAllAdapters(): IBaseAdapter[];
     hasPlugin(key: string): boolean;
-    clear(): void;
+    clear(): () => void;
 }
 export declare const pluginRegistry: PluginRegistry;
 export {};

package/lib/plugins/PluginRegistry.js

@@ -5,9 +5,11 @@ class PluginRegistry {
     moduleFactories = [];
     skippedPlugins = new Set();
     register(plugin) {
-        if (this.plugins.has(plugin.key)) {
+        const registered = this.plugins.get(plugin.key);
+        if (registered) {
             logger.warn(`Plugin ${plugin.key} already registered, skipping`, {
                 label: plugin.label,
+                registeredLabel: registered.label,
             });
             return;
         }
@@ -103,13 +105,24 @@ class PluginRegistry {
         }
         return result.toSorted((left, right) => (left.orderIndex ?? 0) - (right.orderIndex ?? 0));
     }
+    getAllAdapters() {
+        return this.getAllPlugins()
+            .filter((plugin) => !this.skippedPlugins.has(plugin.key))
+            .flatMap((plugin) => plugin.adapters ?? []);
+    }
     hasPlugin(key) {
         return this.plugins.has(key);
     }
     clear() {
-        this.plugins.clear();
+        const { plugins, moduleFactories, skippedPlugins } = this;
+        this.plugins = new Map();
         this.moduleFactories = [];
-        this.skippedPlugins.clear();
+        this.skippedPlugins = new Set();
+        return () => {
+            this.plugins = plugins;
+            this.moduleFactories = moduleFactories;
+            this.skippedPlugins = skippedPlugins;
+        };
     }
 }
 export const pluginRegistry = new PluginRegistry();

package/lib/services/addCartQuotation.d.ts

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

package/lib/services/addCartQuotation.js

@@ -1,52 +1,57 @@
+import { ordersSettings } from '@unchainedshop/core-orders';
 import { QuotationStatus } from '@unchainedshop/core-quotations';
 import { QuotationDirector } from "../directors/QuotationDirector.js";
-import { updateCalculationService } from "./updateCalculation.js";
-import { findOrInitCartService } from "./findOrInitCart.js";
-import { OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, ProductNotFoundError, QuotationNotFoundError, QuotationWrongStatusError, QuotationItemConfigurationError, } from "../errors/index.js";
-export async function addCartQuotationService(params) {
-    const { orderId, quotationId, quantity, configuration, user, countryCode, context } = params;
-    if (quantity < 1) {
-        throw new OrderQuantityTooLowError({ quantity });
-    }
-    const quotation = await this.quotations.findQuotation({ quotationId });
-    if (!quotation) {
-        throw new QuotationNotFoundError({ quotationId });
-    }
+import { createServiceError } from "../errors.js";
+import { isQuotationReserved } from "./reserveOrderQuotationsForCheckout.js";
+export async function addCartQuotationService({ order, quotation, quantity, configuration, }, unchainedAPI = {}) {
+    const context = { ...unchainedAPI, modules: this };
     if (quotation.status !== QuotationStatus.PROPOSED) {
-        throw new QuotationWrongStatusError({ status: quotation.status });
+        throw createServiceError('QuotationWrongStatusError', `Quotation ${quotation._id} is ${quotation.status}, not PROPOSED`);
     }
-    const order = await findOrInitCartService.bind(this)({
-        orderId,
-        user,
-        countryCode,
-    });
-    if (!order) {
-        throw new OrderNotFoundError({ orderId: orderId || null });
+    if (quotation.currencyCode !== order.currencyCode) {
+        throw createServiceError('QuotationInvalidError', `Quotation ${quotation._id} is not in the currency of order ${order._id}`);
     }
-    if (!this.orders.isCart(order)) {
-        throw new OrderWrongStatusError({ status: order.status });
+    if (await isQuotationReserved.call(this, quotation._id, { exceptOrderId: order._id })) {
+        throw createServiceError('QuotationInvalidError', `Quotation ${quotation._id} is reserved by another order`);
     }
-    if (!(await this.products.productExists({ productId: quotation.productId }))) {
-        throw new ProductNotFoundError({ productId: quotation.productId });
+    const product = await this.products.findProduct({ productId: quotation.productId });
+    if (!product) {
+        throw createServiceError('ProductNotFoundError', `Product not found: ${quotation.productId}`);
     }
+    const existingPosition = (await this.orders.positions.findOrderPositions({ orderId: order._id })).find((position) => position.quotationId === quotation._id);
+    const existingQuantity = existingPosition?.quantity || 0;
+    const requestedQuantity = existingQuantity + (quantity ?? quotation.quantity ?? 1);
     const director = await QuotationDirector.actions({ quotation }, context);
     const quotationConfiguration = await director.transformItemConfiguration({
-        quantity,
-        configuration,
+        quantity: requestedQuantity,
+        configuration: configuration ?? existingPosition?.configuration ?? [],
     });
     if (!quotationConfiguration) {
-        throw new QuotationItemConfigurationError({ configuration });
+        throw createServiceError('QuotationItemConfigurationError', `Quotation ${quotation._id} does not take quantity ${requestedQuantity}`);
     }
-    const updatedOrderPosition = await this.orders.positions.addProductItem({
-        quantity: quotationConfiguration.quantity || 1,
+    const lineQuantity = quotationConfiguration.quantity || requestedQuantity;
+    await ordersSettings.validateOrderPosition({
+        order,
+        product,
         configuration: quotationConfiguration.configuration,
-        quotationId,
-        productId: quotation.productId,
-        originalProductId: quotation.productId,
-        orderId: order._id,
-    });
-    await updateCalculationService.bind(this)(order._id);
-    return (await this.orders.positions.findOrderPosition({
-        itemId: updatedOrderPosition._id,
-    }));
+        quantityDiff: lineQuantity - existingQuantity,
+    }, context);
+    const position = existingPosition
+        ? await this.orders.positions.updateProductItem({
+            orderPositionId: existingPosition._id,
+            quantity: lineQuantity,
+            configuration: quotationConfiguration.configuration ?? null,
+        })
+        : await this.orders.positions.addProductItem({
+            quantity: lineQuantity,
+            configuration: quotationConfiguration.configuration,
+            quotationId: quotation._id,
+            productId: quotation.productId,
+            originalProductId: quotation.productId,
+            orderId: order._id,
+        });
+    if (!position) {
+        throw createServiceError('OrderItemNotFoundError', `Order item not found: ${existingPosition?._id}`);
+    }
+    return position;
 }

package/lib/services/reserveOrderDiscountsForCheckout.d.ts

@@ -0,0 +1,5 @@
+import type { Order } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export declare function reserveOrderDiscountsForCheckout(this: Modules, order: Order): Promise<{
+    release: () => Promise<void>;
+}>;

package/lib/services/reserveOrderDiscountsForCheckout.js

@@ -0,0 +1,34 @@
+import { createLogger } from '@unchainedshop/logger';
+import { OrderDiscountDirector } from "../directors/OrderDiscountDirector.js";
+const logger = createLogger('unchained:core:checkoutOrder');
+export async function reserveOrderDiscountsForCheckout(order) {
+    const reservations = [];
+    const release = async () => {
+        const results = await Promise.allSettled(reservations.map((reservation) => reservation.release()));
+        for (const result of results) {
+            if (result.status === 'rejected') {
+                logger.error(`Could not release a discount reservation of order ${order._id}`, {
+                    error: result.reason,
+                });
+            }
+        }
+    };
+    try {
+        const discounts = await this.orders.discounts.findOrderDiscounts({ orderId: order._id });
+        for (const orderDiscount of discounts) {
+            const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+            if (!Adapter)
+                continue;
+            const adapter = await Adapter.actions({
+                context: { order, orderDiscount, code: orderDiscount.code, modules: this },
+            });
+            if (adapter.reserveForCheckout)
+                reservations.push(await adapter.reserveForCheckout());
+        }
+        return { release };
+    }
+    catch (error) {
+        await release();
+        throw error;
+    }
+}

package/lib/services/reserveOrderQuotationsForCheckout.d.ts

@@ -0,0 +1,8 @@
+import { type Order } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export declare function isQuotationReserved(this: Modules, quotationId: string, { exceptOrderId }?: {
+    exceptOrderId?: string;
+}): Promise<boolean>;
+export declare function reserveOrderQuotationsForCheckout(this: Modules, order: Order): Promise<{
+    release: () => Promise<void>;
+}>;

package/lib/services/reserveOrderQuotationsForCheckout.js

@@ -0,0 +1,49 @@
+import { OrderStatus } from '@unchainedshop/core-orders';
+import { createServiceError } from "../errors.js";
+const RESERVATION_LOCK_TTL = 60000;
+export async function isQuotationReserved(quotationId, { exceptOrderId } = {}) {
+    const orderIds = (await this.orders.positions.findOrderPositions({ quotationId }))
+        .map(({ orderId }) => orderId)
+        .filter((orderId) => orderId !== exceptOrderId);
+    if (!orderIds.length)
+        return false;
+    const count = await this.orders.count({
+        orderIds,
+        status: [OrderStatus.PENDING, OrderStatus.CONFIRMED, OrderStatus.FULFILLED],
+    });
+    return count > 0;
+}
+export async function reserveOrderQuotationsForCheckout(order) {
+    const locks = [];
+    const release = async () => {
+        await Promise.all(locks.map((lock) => lock.release()));
+    };
+    try {
+        const positions = await this.orders.positions.findOrderPositions({ orderId: order._id });
+        const quotationIds = [
+            ...new Set(positions.map(({ quotationId }) => quotationId).filter(Boolean)),
+        ].sort();
+        for (const quotationId of quotationIds) {
+            try {
+                locks.push(await this.orders.acquireLock(quotationId, 'quotation', RESERVATION_LOCK_TTL));
+            }
+            catch (error) {
+                if (!error?.message?.startsWith('Could not acquire lock'))
+                    throw error;
+                throw createServiceError('QuotationInvalidError', 'Quotation is being ordered by another order');
+            }
+            const quotation = await this.quotations.findQuotation({ quotationId });
+            if (!quotation || !this.quotations.isProposalValid(quotation)) {
+                throw createServiceError('QuotationInvalidError', 'Quotation expired, fulfilled or not valid for this order, please request a new offer');
+            }
+            if (await isQuotationReserved.call(this, quotationId, { exceptOrderId: order._id })) {
+                throw createServiceError('QuotationInvalidError', 'Quotation is reserved by another order');
+            }
+        }
+        return { release };
+    }
+    catch (error) {
+        await release();
+        throw error;
+    }
+}

package/lib/services/simulateProductDispatching.d.ts

@@ -3,10 +3,12 @@ import type { Product } from '@unchainedshop/core-products';
 import { type EstimatedDispatch } from '../directors/WarehousingDirector.ts';
 import type { WarehousingContext } from '../directors/WarehousingAdapter.ts';
 import type { WarehousingProvider } from '@unchainedshop/core-warehousing';
-export declare function simulateProductDispatchingService(this: Modules, { product, quantity, referenceDate, }: {
+import type { DeliveryProviderType } from '@unchainedshop/core-delivery';
+export declare function simulateProductDispatchingService(this: Modules, { product, quantity, referenceDate, deliveryProviderType, }: {
     product: Product;
     quantity: number;
     referenceDate?: Date;
+    deliveryProviderType?: DeliveryProviderType | null;
 }): Promise<(WarehousingContext & EstimatedDispatch & {
     warehousingProvider: WarehousingProvider;
 })[]>;

package/lib/services/simulateProductDispatching.js

@@ -1,7 +1,7 @@
 import { supportedWarehousingProvidersService } from "./supportedWarehousingProviders.js";
 import { WarehousingDirector } from "../directors/WarehousingDirector.js";
-export async function simulateProductDispatchingService({ product, quantity, referenceDate, }) {
-    const deliveryProviders = await this.delivery.allProviders();
+export async function simulateProductDispatchingService({ product, quantity, referenceDate, deliveryProviderType, }) {
+    const deliveryProviders = (await this.delivery.allProviders()).filter(({ type }) => !deliveryProviderType || type === deliveryProviderType);
     return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
         const result = await oldResult;
         const warehousingProviders = await supportedWarehousingProvidersService.bind(this)({
@@ -25,6 +25,6 @@ export async function simulateProductDispatchingService({ product, quantity, ref
                 ...dispatch,
             };
         }));
-        return result.concat(result, mappedWarehousingProviders);
+        return result.concat(mappedWarehousingProviders);
     }, Promise.resolve([]));
 }

package/lib/services/simulateProductInventory.d.ts

@@ -2,9 +2,11 @@ import type { Modules } from '../modules.ts';
 import type { Product } from '@unchainedshop/core-products';
 import type { WarehousingContext } from '../directors/WarehousingAdapter.ts';
 import type { WarehousingProvider } from '@unchainedshop/core-warehousing';
-export declare function simulateProductInventoryService(this: Modules, { product, referenceDate, }: {
+import type { DeliveryProviderType } from '@unchainedshop/core-delivery';
+export declare function simulateProductInventoryService(this: Modules, { product, referenceDate, deliveryProviderType, }: {
     product: Product;
     referenceDate?: Date;
+    deliveryProviderType?: DeliveryProviderType | null;
 }): Promise<(WarehousingContext & {
     quantity?: number;
 } & {

package/lib/services/simulateProductInventory.js

@@ -1,7 +1,7 @@
 import { supportedWarehousingProvidersService } from "./supportedWarehousingProviders.js";
 import { WarehousingDirector } from "../directors/WarehousingDirector.js";
-export async function simulateProductInventoryService({ product, referenceDate, }) {
-    const deliveryProviders = await this.delivery.allProviders();
+export async function simulateProductInventoryService({ product, referenceDate, deliveryProviderType, }) {
+    const deliveryProviders = (await this.delivery.allProviders()).filter(({ type }) => !deliveryProviderType || type === deliveryProviderType);
     return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
         const result = await oldResult;
         const warehousingProviders = await supportedWarehousingProvidersService.bind(this)({
@@ -24,6 +24,6 @@ export async function simulateProductInventoryService({ product, referenceDate,
                 ...stock,
             };
         }));
-        return result.concat(result, mappedWarehousingProviders);
+        return result.concat(mappedWarehousingProviders);
     }, Promise.resolve([]));
 }

package/lib/services/supportedDeliveryProviders.js

@@ -1,8 +1,17 @@
 import { deliverySettings } from '@unchainedshop/core-delivery';
+import { createLogger } from '@unchainedshop/logger';
 import { DeliveryDirector } from "../directors/index.js";
+const logger = createLogger('unchained:core');
 export async function supportedDeliveryProvidersService(params) {
     const allProviders = await this.delivery.allProviders();
     const providers = (await Promise.all(allProviders.map(async (provider) => {
+        if (!DeliveryDirector.getAdapter(provider.adapterKey)) {
+            logger.warn('Delivery provider skipped, its adapter is not registered', {
+                deliveryProviderId: provider._id,
+                adapterKey: provider.adapterKey,
+            });
+            return [];
+        }
         const adapter = await DeliveryDirector.actions(provider, params, { modules: this });
         return adapter.isActive() ? [provider] : [];
     }))).flat();

package/lib/services/supportedPaymentProviders.js

@@ -1,8 +1,17 @@
 import { paymentSettings } from '@unchainedshop/core-payment';
+import { createLogger } from '@unchainedshop/logger';
 import { PaymentDirector } from "../directors/PaymentDirector.js";
+const logger = createLogger('unchained:core');
 export async function supportedPaymentProvidersService(params) {
     const allProviders = await this.payment.paymentProviders.allProviders();
     const providers = (await Promise.all(allProviders.map(async (provider) => {
+        if (!PaymentDirector.getAdapter(provider.adapterKey)) {
+            logger.warn('Payment provider skipped, its adapter is not registered', {
+                paymentProviderId: provider._id,
+                adapterKey: provider.adapterKey,
+            });
+            return [];
+        }
         const adapter = await PaymentDirector.actions(provider, params, { modules: this });
         return adapter.isActive() ? [provider] : [];
     }))).flat();

package/lib/services/supportedWarehousingProviders.js

@@ -1,7 +1,16 @@
+import { createLogger } from '@unchainedshop/logger';
 import { WarehousingDirector } from "../directors/index.js";
+const logger = createLogger('unchained:core');
 export async function supportedWarehousingProvidersService(params) {
     const allProviders = await this.warehousing.allProviders();
     const providers = (await Promise.all(allProviders.map(async (provider) => {
+        if (!WarehousingDirector.getAdapter(provider.adapterKey)) {
+            logger.warn('Warehousing provider skipped, its adapter is not registered', {
+                warehousingProviderId: provider._id,
+                adapterKey: provider.adapterKey,
+            });
+            return [];
+        }
         const adapter = await WarehousingDirector.actions(provider, params, { modules: this });
         return adapter.isActive() ? [provider] : [];
     }))).flat();

package/lib/services/suspendEnrollment.d.ts

@@ -0,0 +1,5 @@
+import { type Enrollment } from '@unchainedshop/core-enrollments';
+import type { Modules } from '../modules.ts';
+export declare function suspendEnrollmentService(this: Modules, enrollment: Enrollment, { resumeAt }?: {
+    resumeAt?: Date;
+}): Promise<Enrollment>;

package/lib/services/suspendEnrollment.js

@@ -0,0 +1,21 @@
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { addMessageService } from "./addMessage.js";
+export async function suspendEnrollmentService(enrollment, { resumeAt } = {}) {
+    if (enrollment.status === EnrollmentStatus.TERMINATED)
+        return enrollment;
+    let updatedEnrollment = (await this.enrollments.updateStatus(enrollment._id, {
+        status: EnrollmentStatus.SUSPENDED,
+        info: 'suspended manually',
+    }));
+    if (resumeAt) {
+        updatedEnrollment = (await this.enrollments.updateResumeAt(enrollment._id, resumeAt));
+    }
+    const user = await this.users.findUserById(enrollment.userId);
+    const locale = this.users.userLocale(user);
+    await addMessageService.bind(this)('ENROLLMENT_STATUS', {
+        reason: 'status_change',
+        locale: locale.baseName,
+        enrollmentId: updatedEnrollment._id,
+    });
+    return updatedEnrollment;
+}