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

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/registerProductDiscoverabilityFilter.d.ts

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

package/lib/factory/registerProductDiscoverabilityFilter.js

@@ -1,10 +1,13 @@
 import { FilterAdapter } from "../core-index.js";
 import { pluginRegistry } from "../plugins/PluginRegistry.js";
-export default function registerProductDiscoverabilityFilter({ orderIndex = 0, hiddenTagValue = 'hidden', }) {
+export default function registerProductDiscoverabilityFilter({ adapterId, orderIndex = 0, hiddenTagValue = 'hidden', }) {
+    const id = adapterId ?? crypto.randomUUID();
     const adapter = {
         ...FilterAdapter,
-        key: `shop.unchained.filters.product-discoverability-${crypto.randomUUID()}`,
-        label: 'Product Discoverability Filter (auto-generated)',
+        key: `shop.unchained.filters.product-discoverability-${id}`,
+        label: adapterId
+            ? `Product Discoverability Filter: ${adapterId}`
+            : 'Product Discoverability Filter (auto-generated)',
         version: '1.0.0',
         orderIndex,
         actions: (params) => {

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/registerProductSearchFilter.d.ts

@@ -1,6 +1,7 @@
 import type { SearchQuery } from '@unchainedshop/core-filters';
 import { type IPlugin } from '../core-index.ts';
-export default function registerProductSearchFilter({ orderIndex, search, }: {
+export default function registerProductSearchFilter({ adapterId, orderIndex, search, }: {
+    adapterId?: string;
     orderIndex?: number;
     search: (params: SearchQuery & {
         queryString: string;

package/lib/factory/registerProductSearchFilter.js

@@ -1,10 +1,11 @@
 import { FilterAdapter } from "../core-index.js";
 import { pluginRegistry } from "../plugins/PluginRegistry.js";
-export default function registerProductSearchFilter({ orderIndex = 0, search, }) {
+export default function registerProductSearchFilter({ adapterId, orderIndex = 0, search, }) {
+    const id = adapterId ?? crypto.randomUUID();
     const adapter = {
         ...FilterAdapter,
-        key: `shop.unchained.filters.product-search-${crypto.randomUUID()}`,
-        label: 'Product Search Filter (auto-generated)',
+        key: `shop.unchained.filters.product-search-${id}`,
+        label: adapterId ? `Product Search Filter: ${adapterId}` : 'Product Search Filter (auto-generated)',
         version: '1.0.0',
         orderIndex,
         actions: (params) => {

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/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,6 +35,7 @@ declare class PluginRegistry {
     getPlugin(key: string): IPlugin | undefined;
     getAllPlugins(): IPlugin[];
     getAdapters(adapterType: symbol): IBaseAdapter[];
+    getAllAdapters(): IBaseAdapter[];
     hasPlugin(key: string): boolean;
     clear(): void;
 }

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,13 +95,20 @@ 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);

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');
+        }
+    });
+}