@unchainedshop/core 5.0.0-alpha.1 → 5.0.0-alpha.11

package/lib/factory/registerVirtualWarehousing.js

@@ -5,7 +5,7 @@ export default function registerVirtualWarehousing({ adapterId, orderIndex = 0,
     const adapter = {
         ...WarehousingAdapter,
         key: 'shop.unchained.warehousing.virtual.' + adapterId,
-        label: 'Virtual Wareshousing: ' + adapterId,
+        label: 'Virtual Warehousing: ' + adapterId,
         version: '1.0.0',
         orderIndex,
         initialConfiguration: [{ key: 'shipping-hub', value: 'Shipping Hub' }],

package/lib/factory/registerWorker.js

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

package/lib/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;
         }
@@ -93,21 +95,34 @@ class PluginRegistry {
         for (const plugin of this.plugins.values()) {
             if (!plugin.adapters)
                 continue;
+            if (this.skippedPlugins.has(plugin.key))
+                continue;
             for (const adapter of plugin.adapters) {
                 if (adapter.adapterType === adapterType) {
                     result.push(adapter);
                 }
             }
         }
-        return result;
+        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/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/bulkAssignProductsToAssortment.d.ts

@@ -0,0 +1,8 @@
+import type { Modules } from '../modules.ts';
+export declare function bulkAssignProductsToAssortmentService(this: Modules, { assortmentId, productIds }: {
+    assortmentId: string;
+    productIds: string[];
+}): Promise<{
+    successIds: string[];
+    failedIds: string[];
+}>;

package/lib/services/bulkAssignProductsToAssortment.js

@@ -0,0 +1,11 @@
+import { executeBulkOperation } from '@unchainedshop/utils';
+export async function bulkAssignProductsToAssortmentService({ assortmentId, productIds }) {
+    const result = await executeBulkOperation(productIds, async (productId) => {
+        if (!(await this.products.productExists({ productId })))
+            throw new Error('not-found');
+        const assignment = await this.assortments.products.create({ assortmentId, productId });
+        if (!assignment)
+            throw new Error('create-failed');
+    });
+    return result;
+}

package/lib/services/bulkDeleteUsers.d.ts

@@ -0,0 +1,7 @@
+import type { Modules } from '../modules.ts';
+export declare function bulkDeleteUsersService(this: Modules, { userIds }: {
+    userIds: string[];
+}): Promise<{
+    successIds: string[];
+    failedIds: string[];
+}>;

package/lib/services/bulkDeleteUsers.js

@@ -0,0 +1,11 @@
+import { executeBulkOperation } from '@unchainedshop/utils';
+import { deleteUserService } from "./deleteUser.js";
+export async function bulkDeleteUsersService({ userIds }) {
+    return executeBulkOperation(userIds, async (userId) => {
+        if (!(await this.users.userExists({ userId })))
+            throw new Error('not-found');
+        const result = await deleteUserService.call(this, { userId });
+        if (!result)
+            throw new Error('delete-failed');
+    });
+}

package/lib/services/bulkRemoveFilters.d.ts

@@ -0,0 +1,7 @@
+import type { Modules } from '../modules.ts';
+export declare function bulkRemoveFiltersService(this: Modules, { filterIds }: {
+    filterIds: string[];
+}): Promise<{
+    successIds: string[];
+    failedIds: string[];
+}>;

package/lib/services/bulkRemoveFilters.js

@@ -0,0 +1,10 @@
+import { executeBulkOperation } from '@unchainedshop/utils';
+import { removeFilterService } from "./removeFilter.js";
+export async function bulkRemoveFiltersService({ filterIds }) {
+    return executeBulkOperation(filterIds, async (filterId) => {
+        const filter = await this.filters.findFilter({ filterId });
+        if (!filter)
+            throw new Error('not-found');
+        await removeFilterService.call(this, { filter });
+    });
+}

package/lib/services/bulkRemoveProducts.d.ts

@@ -0,0 +1,7 @@
+import type { Modules } from '../modules.ts';
+export declare function bulkRemoveProductsService(this: Modules, { productIds }: {
+    productIds: string[];
+}): Promise<{
+    successIds: string[];
+    failedIds: string[];
+}>;

package/lib/services/bulkRemoveProducts.js

@@ -0,0 +1,23 @@
+import { executeBulkOperation } from '@unchainedshop/utils';
+import { removeProductService } from "./removeProduct.js";
+export async function bulkRemoveProductsService({ productIds }) {
+    return executeBulkOperation(productIds, async (productId) => {
+        if (!(await this.products.productExists({ productId })))
+            throw new Error('not-found');
+        if (await this.products.firstActiveProductBundle(productId)) {
+            throw new Error('linked-to-active-bundle');
+        }
+        if (await this.products.firstActiveProductProxy(productId)) {
+            throw new Error('linked-to-active-variation');
+        }
+        if (await this.quotations.openQuotationWithProduct({ productId })) {
+            throw new Error('linked-to-quotation');
+        }
+        if (await this.enrollments.openEnrollmentWithProduct({ productId })) {
+            throw new Error('linked-to-enrollment');
+        }
+        const result = await removeProductService.call(this, { productId });
+        if (!result)
+            throw new Error('already-deleted');
+    });
+}

package/lib/services/bulkSetFilterActive.d.ts

@@ -0,0 +1,8 @@
+import type { Modules } from '../modules.ts';
+export declare function bulkSetFilterActiveService(this: Modules, { filterIds, isActive }: {
+    filterIds: string[];
+    isActive: boolean;
+}): Promise<{
+    successIds: string[];
+    failedIds: string[];
+}>;

package/lib/services/bulkSetFilterActive.js

@@ -0,0 +1,12 @@
+import { executeBulkOperation } from '@unchainedshop/utils';
+import { updateFilterService } from "./updateFilter.js";
+export async function bulkSetFilterActiveService({ filterIds, isActive }) {
+    return executeBulkOperation(filterIds, async (filterId) => {
+        const filter = await this.filters.findFilter({ filterId });
+        if (!filter)
+            throw new Error('not-found');
+        if (!(await updateFilterService.call(this, filterId, { isActive }))) {
+            throw new Error('update-failed');
+        }
+    });
+}

package/lib/services/calculateDiscountTotal.d.ts

@@ -1,6 +1,10 @@
 import type { Order, OrderDiscount } from '@unchainedshop/core-orders';
 import type { Modules } from '../modules.ts';
-export declare function calculateDiscountTotalService(this: Modules, order: Order, orderDiscount: OrderDiscount): Promise<{
+export declare function calculateDiscountTotalService(this: Modules, order: Order, orderDiscount: OrderDiscount, { useNetPrice }?: {
+    useNetPrice?: boolean;
+}): Promise<{
     amount: number;
     currencyCode: string;
+    isTaxable: boolean;
+    isNetPrice: boolean;
 }>;

package/lib/services/calculateDiscountTotal.js

@@ -1,44 +1,52 @@
 import { OrderPricingRowCategory, OrderPricingSheet, DeliveryPricingRowCategory, DeliveryPricingSheet, ProductPricingRowCategory, ProductPricingSheet, PaymentPricingRowCategory, PaymentPricingSheet, } from "../directors/index.js";
-export async function calculateDiscountTotalService(order, orderDiscount) {
-    const orderDiscountId = orderDiscount._id;
+export async function calculateDiscountTotalService(order, orderDiscount, { useNetPrice = false } = {}) {
+    const discountId = orderDiscount._id;
     const orderDelivery = await this.orders.deliveries.findDelivery({
         orderDeliveryId: order.deliveryId,
     });
-    const orderDeliveryDiscountSum = DeliveryPricingSheet({
-        calculation: orderDelivery?.calculation || [],
-        currencyCode: order.currencyCode,
-    }).total({ category: DeliveryPricingRowCategory.Discount, discountId: orderDiscountId });
     const orderPayment = await this.orders.payments.findOrderPayment({
         orderPaymentId: order.paymentId,
     });
-    const orderPaymentDiscountSum = PaymentPricingSheet({
-        calculation: orderPayment?.calculation || [],
-        currencyCode: order.currencyCode,
-    }).total({ category: PaymentPricingRowCategory.Discount, discountId: orderDiscountId });
     const orderPositions = await this.orders.positions.findOrderPositions({
         orderId: order._id,
     });
-    const orderPositionDiscounts = orderPositions.map((orderPosition) => ProductPricingSheet({
-        calculation: orderPosition.calculation || [],
-        currencyCode: order.currencyCode,
-        quantity: orderPosition.quantity,
-    }).total({
-        category: ProductPricingRowCategory.Discount,
-        discountId: orderDiscountId,
-    }));
-    const orderDiscountSum = OrderPricingSheet({
-        calculation: order.calculation,
-        currencyCode: order.currencyCode,
-    }).total({ category: OrderPricingRowCategory.Discounts, discountId: orderDiscountId });
-    const prices = [
-        orderDeliveryDiscountSum.amount,
-        orderPaymentDiscountSum.amount,
-        ...orderPositionDiscounts.map((positionDiscount) => positionDiscount.amount),
-        orderDiscountSum.amount,
+    const discountedSheets = [
+        {
+            category: DeliveryPricingRowCategory.Discount,
+            sheet: DeliveryPricingSheet({
+                calculation: orderDelivery?.calculation || [],
+                currencyCode: order.currencyCode,
+            }),
+        },
+        {
+            category: PaymentPricingRowCategory.Discount,
+            sheet: PaymentPricingSheet({
+                calculation: orderPayment?.calculation || [],
+                currencyCode: order.currencyCode,
+            }),
+        },
+        ...orderPositions.map((orderPosition) => ({
+            category: ProductPricingRowCategory.Discount,
+            sheet: ProductPricingSheet({
+                calculation: orderPosition.calculation || [],
+                currencyCode: order.currencyCode,
+                quantity: orderPosition.quantity,
+            }),
+        })),
+        {
+            category: OrderPricingRowCategory.Discounts,
+            sheet: OrderPricingSheet({
+                calculation: order.calculation,
+                currencyCode: order.currencyCode,
+            }),
+        },
     ];
-    const amount = prices.reduce((oldValue, price) => oldValue + (price || 0), 0);
+    const amount = discountedSheets.reduce((sum, { category, sheet }) => sum + (sheet.total({ category, discountId, useNetPrice }).amount || 0), 0);
+    const taxAmount = discountedSheets.reduce((sum, { category, sheet }) => sum + sheet.taxSum({ baseCategory: category, discountId }), 0);
     return {
         amount,
         currencyCode: order.currencyCode,
+        isTaxable: taxAmount !== 0,
+        isNetPrice: useNetPrice,
     };
 }

package/lib/services/checkoutOrder.js

@@ -2,6 +2,8 @@ import { OrderStatus } from '@unchainedshop/core-orders';
 import { nextUserCartService } from "./nextUserCart.js";
 import { validateOrderService } from "./validateOrder.js";
 import { processOrderService } from "./processOrder.js";
+import { reserveOrderDiscountsForCheckout } from "./reserveOrderDiscountsForCheckout.js";
+import { reserveOrderQuotationsForCheckout } from "./reserveOrderQuotationsForCheckout.js";
 export async function checkoutOrderService(orderId, transactionContext) {
     const order = await this.orders.findOrder({ orderId });
     if (!order)
@@ -10,7 +12,11 @@ export async function checkoutOrderService(orderId, transactionContext) {
         return order;
     await validateOrderService.bind(this)(order);
     const lock = await this.orders.acquireLock(order._id, 'checkout');
+    let discounts;
+    let quotations;
     try {
+        quotations = await reserveOrderQuotationsForCheckout.call(this, order);
+        discounts = await reserveOrderDiscountsForCheckout.call(this, order);
         const processedOrder = await processOrderService.bind(this)(order, transactionContext);
         if (processedOrder.billingAddress) {
             await this.users.updateLastBillingAddress(processedOrder.userId, processedOrder.billingAddress);
@@ -27,6 +33,8 @@ export async function checkoutOrderService(orderId, transactionContext) {
         return processedOrder;
     }
     finally {
+        await discounts?.release();
+        await quotations?.release();
         await lock.release();
     }
 }

package/lib/services/createFilter.d.ts

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

package/lib/services/createFilter.js

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

package/lib/services/createFilterOption.d.ts

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

package/lib/services/createFilterOption.js

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

package/lib/services/createSignedURL.js

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

package/lib/services/deleteCart.d.ts

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

package/lib/services/deleteCart.js

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

package/lib/services/deleteUser.js

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