@unchainedshop/core 4.4.0 → 4.6.0

package/lib/bulk-importer/handlers/assortment/create.d.ts

@@ -5,7 +5,6 @@ export declare const AssortmentCreatePayloadSchema: z.ZodObject<{
     _id: z.ZodString;
     specification: z.ZodObject<{
         isActive: z.ZodBoolean;
-        isBase: z.ZodOptional<z.ZodBoolean>;
         isRoot: z.ZodOptional<z.ZodBoolean>;
         sequence: z.ZodNumber;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -71,7 +70,6 @@ declare namespace createAssortment {
         _id: z.ZodString;
         specification: z.ZodObject<{
             isActive: z.ZodBoolean;
-            isBase: z.ZodOptional<z.ZodBoolean>;
             isRoot: z.ZodOptional<z.ZodBoolean>;
             sequence: z.ZodNumber;
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/lib/bulk-importer/handlers/assortment/create.js

@@ -8,7 +8,6 @@ export const AssortmentCreatePayloadSchema = z.object({
     _id: z.string(),
     specification: z.object({
         isActive: z.boolean(),
-        isBase: z.boolean().optional(),
         isRoot: z.boolean().optional(),
         sequence: z.number(),
         tags: z.array(z.string()).optional(),

package/lib/bulk-importer/handlers/assortment/update.d.ts

@@ -5,7 +5,6 @@ export declare const AssortmentUpdatePayloadSchema: z.ZodObject<{
     _id: z.ZodString;
     specification: z.ZodOptional<z.ZodObject<{
         isActive: z.ZodOptional<z.ZodBoolean>;
-        isBase: z.ZodOptional<z.ZodBoolean>;
         isRoot: z.ZodOptional<z.ZodBoolean>;
         sequence: z.ZodOptional<z.ZodNumber>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -72,7 +71,6 @@ declare namespace updateAssortment {
         _id: z.ZodString;
         specification: z.ZodOptional<z.ZodObject<{
             isActive: z.ZodOptional<z.ZodBoolean>;
-            isBase: z.ZodOptional<z.ZodBoolean>;
             isRoot: z.ZodOptional<z.ZodBoolean>;
             sequence: z.ZodOptional<z.ZodNumber>;
             tags: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/lib/bulk-importer/handlers/assortment/update.js

@@ -10,7 +10,6 @@ export const AssortmentUpdatePayloadSchema = z.object({
     specification: z
         .object({
         isActive: z.boolean().optional(),
-        isBase: z.boolean().optional(),
         isRoot: z.boolean().optional(),
         sequence: z.number().optional(),
         tags: z.array(z.string()).optional(),

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

@@ -17,8 +17,8 @@ export const ProductCreateSpecificationSchema = z.object({
             maxQuantity: z.number().optional(),
             isTaxable: z.boolean().optional(),
             isNetPrice: z.boolean().optional(),
-            currencyCode: z.string(),
-            countryCode: z.string(),
+            currencyCode: z.string().min(1, 'currencyCode is required'),
+            countryCode: z.string().min(1, 'countryCode is required'),
         })),
     })
         .optional(),

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

@@ -16,8 +16,8 @@ export const ProductUpdateSpecificationSchema = z.object({
             maxQuantity: z.number().optional(),
             isTaxable: z.boolean().optional(),
             isNetPrice: z.boolean().optional(),
-            currencyCode: z.string(),
-            countryCode: z.string(),
+            currencyCode: z.string().min(1, 'currencyCode is required'),
+            countryCode: z.string().min(1, 'countryCode is required'),
         })),
     })
         .optional(),

package/lib/core-index.d.ts

@@ -7,6 +7,7 @@ export * from './bulk-importer/index.ts';
 export * from './services/index.ts';
 export * from './directors/index.ts';
 export * from './factory/index.ts';
+export { default as schedule, type ScheduleData } from './utils/schedule.ts';
 export interface UnchainedCoreOptions {
     db: mongodb.Db;
     migrationRepository: MigrationRepository<UnchainedCore>;

package/lib/core-index.js

@@ -7,6 +7,7 @@ export * from "./bulk-importer/index.js";
 export * from "./services/index.js";
 export * from "./directors/index.js";
 export * from "./factory/index.js";
+export { default as schedule } from "./utils/schedule.js";
 export const initCore = async ({ db, migrationRepository, bulkImporter: bulkImporterOptions = {}, modules: customModules = {}, services: customServices = {}, options = {}, }) => {
     const bulkImporter = createBulkImporterFactory(db, bulkImporterOptions);
     const modules = await initModules({ db, migrationRepository, options }, customModules);

package/lib/directors/BaseWorker.js

@@ -1,4 +1,4 @@
-import later from '@breejs/later';
+import schedule from "../utils/schedule.js";
 import { WorkerDirector } from "./WorkerDirector.js";
 export const BaseWorker = {
     key: 'shop.unchained.worker.base',
@@ -37,7 +37,7 @@ export const BaseWorker = {
                     }
                     const fixedSchedule = { ...workConfig.schedule };
                     fixedSchedule.schedules[0].s = [0];
-                    const nextDate = later.schedule(fixedSchedule).next(1, referenceDate);
+                    const nextDate = schedule.schedule(fixedSchedule).next(1, referenceDate);
                     nextDate.setMilliseconds(0);
                     const workData = {
                         type: workConfig.type,

package/lib/directors/DeliveryPricingAdapter.d.ts

@@ -37,7 +37,7 @@ export interface DeliveryPricingAdapterContext extends BasePricingAdapterContext
     currencyCode?: string;
     provider: DeliveryProvider;
     providerContext?: any;
-    order: Order;
+    order?: Order;
     orderDelivery?: OrderDelivery;
     user: User;
     discounts: OrderDiscount[];

package/lib/directors/DeliveryPricingDirector.d.ts

@@ -9,7 +9,7 @@ export type DeliveryPricingContext = {
     countryCode?: string;
     provider: DeliveryProvider;
     providerContext?: any;
-    order: Order;
+    order?: Order;
     user: User;
 } | {
     currencyCode: string;

package/lib/directors/EnrollmentDirector.d.ts

@@ -3,11 +3,14 @@ import type { EnrollmentAdapterActions, EnrollmentContext, IEnrollmentAdapter }
 import type { OrderPosition } from '@unchainedshop/core-orders';
 import type { Product } from '@unchainedshop/core-products';
 import type { Enrollment } from '@unchainedshop/core-enrollments';
+import type { Modules } from '../modules.ts';
 export type IEnrollmentDirector = IBaseDirector<IEnrollmentAdapter> & {
     transformOrderItemToEnrollment: (item: {
         orderPosition: OrderPosition;
         product: Product;
     }, doc: Omit<Enrollment, 'configuration' | 'productId' | 'quantity' | 'status' | 'periods' | 'log' | '_id' | 'created'>, unchainedAPI: any) => Promise<Omit<Enrollment, 'status' | 'periods' | 'log' | '_id' | 'created'> & Pick<Partial<Enrollment>, '_id' | 'created'>>;
-    actions: (enrollmentContext: EnrollmentContext, unchainedAPI: any) => Promise<EnrollmentAdapterActions>;
+    actions: (enrollmentContext: EnrollmentContext, unchainedAPI: {
+        modules: Modules;
+    }) => Promise<EnrollmentAdapterActions>;
 };
 export declare const EnrollmentDirector: IEnrollmentDirector;

package/lib/directors/IntervalWorker.d.ts

@@ -1,9 +1,9 @@
-import { type ScheduleData } from '@breejs/later';
+import { type ScheduleData } from '../utils/schedule.ts';
 import { type IWorker } from './BaseWorker.ts';
 export interface IntervalWorkerParams {
     workerId?: string;
     batchCount?: number;
     schedule?: ScheduleData;
 }
-export declare const scheduleToInterval: (schedule: ScheduleData) => number;
+export declare const scheduleToInterval: (scheduleData: ScheduleData) => number;
 export declare const IntervalWorker: IWorker<IntervalWorkerParams>;

package/lib/directors/IntervalWorker.js

@@ -1,12 +1,12 @@
-import later, {} from '@breejs/later';
+import schedule, {} from "../utils/schedule.js";
 import { BaseWorker } from "./BaseWorker.js";
 import { createLogger } from '@unchainedshop/logger';
 const { NODE_ENV } = process.env;
 const logger = createLogger('unchained:worker:interval');
-const defaultSchedule = later.parse.text(NODE_ENV !== 'production' ? 'every 2 seconds' : 'every 30 seconds');
-export const scheduleToInterval = (schedule) => {
+const defaultSchedule = schedule.parse.text(NODE_ENV !== 'production' ? 'every 2 seconds' : 'every 30 seconds');
+export const scheduleToInterval = (scheduleData) => {
     const referenceDate = new Date(1000);
-    const nextDates = later.schedule(schedule).next(2, referenceDate);
+    const nextDates = schedule.schedule(scheduleData).next(2, referenceDate);
     if (!nextDates || nextDates.length < 2) {
         throw new Error('Schedule must produce at least 2 consecutive dates');
     }

package/lib/directors/PaymentDirector.js

@@ -150,6 +150,8 @@ export const PaymentDirector = {
         const paymentProvider = await modules.payment.paymentProviders.findProvider({
             paymentProviderId: orderPayment.paymentProviderId,
         });
+        if (!paymentProvider)
+            throw new Error('Payment provider not found: ' + orderPayment.paymentProviderId);
         const actions = await PaymentDirector.actions(paymentProvider, buildPaymentProviderActionsContext(orderPayment, {
             ...context,
             transactionContext: {

package/lib/directors/PaymentPricingAdapter.d.ts

@@ -12,10 +12,10 @@ export interface PaymentPricingCalculation extends PricingCalculation {
 }
 export interface PaymentPricingAdapterContext extends BasePricingAdapterContext {
     countryCode?: string;
-    currency?: string;
+    currencyCode?: string;
     user: User | null;
     orderPayment?: OrderPayment;
-    order: Order;
+    order?: Order;
     provider: PaymentProvider;
     discounts: OrderDiscount[];
 }

package/lib/directors/PaymentPricingAdapter.js

@@ -8,7 +8,7 @@ export const PaymentPricingAdapter = {
     },
     actions: (params) => {
         const { context } = params;
-        const { currencyCode } = context.order;
+        const currencyCode = context.currencyCode || context.order?.currencyCode;
         const baseActions = basePricingAdapter.actions(params);
         const resultSheet = PaymentPricingSheet({ currencyCode });
         return {

package/lib/directors/PaymentPricingDirector.d.ts

@@ -6,7 +6,7 @@ export type PaymentPricingContext = {
     countryCode?: string;
     currencyCode?: string;
     user?: User;
-    order: Order;
+    order?: Order;
     provider: PaymentProvider;
     providerContext?: any;
 } | {

package/lib/directors/WorkerDirector.d.ts

@@ -1,6 +1,6 @@
 import type { Work, WorkData, WorkResult } from '@unchainedshop/core-worker';
 import { type IBaseDirector } from '@unchainedshop/utils';
-import type { ScheduleData } from '@breejs/later';
+import type { ScheduleData } from '../utils/schedule.ts';
 import type { IWorkerAdapter } from './WorkerAdapter.ts';
 import type { Modules } from '../modules.ts';
 export type WorkScheduleConfiguration = Pick<WorkData, 'timeout' | 'retries' | 'priority' | 'worker' | 'scheduleId'> & {

package/lib/services/addMultipleCartProducts.d.ts

@@ -0,0 +1,18 @@
+import type { Modules } from '../modules.ts';
+import type { Order } from '@unchainedshop/core-orders';
+export declare function addMultipleCartProductsService(this: Modules, { orderId, items, context, }: {
+    orderId: string;
+    items: {
+        productId: string;
+        quantity: number;
+        configuration?: {
+            key: string;
+            value: string;
+        }[];
+    }[];
+    context: {
+        localeContext: Intl.Locale;
+        userId?: string;
+        countryCode?: string;
+    };
+}): Promise<Order | null>;

package/lib/services/addMultipleCartProducts.js

@@ -0,0 +1,25 @@
+import { ordersSettings } from '@unchainedshop/core-orders';
+export async function addMultipleCartProductsService({ orderId, items, context, }) {
+    const order = await this.orders.findOrder({ orderId });
+    if (!order)
+        return null;
+    for (const { productId, quantity, configuration } of items) {
+        const originalProduct = await this.products.findProduct({ productId });
+        if (!originalProduct) {
+            throw new Error(`Product not found: ${productId}`);
+        }
+        if (quantity < 1) {
+            throw new Error(`Invalid quantity for product: ${productId}`);
+        }
+        const product = await this.products.resolveOrderableProduct(originalProduct, { configuration });
+        await ordersSettings.validateOrderPosition({ order, product, configuration, quantityDiff: quantity }, { modules: this, ...context });
+        await this.orders.positions.addProductItem({
+            quantity,
+            configuration,
+            originalProductId: originalProduct._id,
+            productId: product._id,
+            orderId: order._id,
+        });
+    }
+    return order;
+}

package/lib/services/createFileDownloadURL.d.ts

@@ -0,0 +1,7 @@
+import { type File } from '@unchainedshop/core-files';
+import type { Modules } from '../modules.ts';
+export declare function createFileDownloadURLService(this: Modules, { file, expires, params, }: {
+    file: File;
+    expires?: number;
+    params?: Record<string, any>;
+}): Promise<string | null>;

package/lib/services/createFileDownloadURL.js

@@ -0,0 +1,10 @@
+import { getFileAdapter } from '@unchainedshop/core-files';
+export async function createFileDownloadURLService({ file, expires, params = {}, }) {
+    if (!file)
+        return null;
+    const fileUploadAdapter = getFileAdapter();
+    const url = await fileUploadAdapter.createDownloadURL(file, expires);
+    if (!url)
+        return null;
+    return this.files.normalizeUrl(url, params);
+}

package/lib/services/findProductSiblings.d.ts

@@ -0,0 +1,9 @@
+import type { Product } from '@unchainedshop/core-products';
+import type { Modules } from '../modules.ts';
+export declare function findProductSiblingsService(this: Modules, { product, assortmentId, limit, offset, includeInactive, }: {
+    product: Product;
+    assortmentId?: string;
+    limit?: number;
+    offset?: number;
+    includeInactive?: boolean;
+}): Promise<Product[]>;

package/lib/services/findProductSiblings.js

@@ -0,0 +1,18 @@
+export async function findProductSiblingsService({ product, assortmentId, limit, offset, includeInactive = false, }) {
+    const productId = product._id;
+    const assortmentIds = assortmentId
+        ? [assortmentId]
+        : await this.assortments.products.findAssortmentIds({ productId });
+    if (!assortmentIds.length)
+        return [];
+    const productIds = await this.assortments.products.findSiblings({
+        productId,
+        assortmentIds,
+    });
+    return this.products.findProducts({
+        productIds,
+        includeDrafts: includeInactive,
+        limit,
+        offset,
+    });
+}

package/lib/services/fulfillQuotation.d.ts

@@ -0,0 +1,3 @@
+import { type Quotation } from '@unchainedshop/core-quotations';
+import type { Modules } from '../modules.ts';
+export declare function fulfillQuotationService(this: Modules, quotation: Quotation, info: any): Promise<Quotation>;

package/lib/services/{fullfillQuotation.js → fulfillQuotation.js}

@@ -1,10 +1,10 @@
 import { QuotationStatus } from '@unchainedshop/core-quotations';
 import { processQuotationService } from "./processQuotation.js";
-export async function fullfillQuotationService(quotation, info) {
-    if (quotation.status === QuotationStatus.FULLFILLED)
+export async function fulfillQuotationService(quotation, info) {
+    if (quotation.status === QuotationStatus.FULFILLED)
         return quotation;
     const updatedQuotation = await this.quotations.updateStatus(quotation._id, {
-        status: QuotationStatus.FULLFILLED,
+        status: QuotationStatus.FULFILLED,
         info: JSON.stringify(info),
     });
     return processQuotationService.bind(this)(updatedQuotation, {});

package/lib/services/index.d.ts

@@ -32,20 +32,31 @@ import { initializeEnrollmentService } from './initializeEnrollment.ts';
 import { activateEnrollmentService } from './activateEnrollment.ts';
 import { terminateEnrollmentService } from './terminateEnrollment.ts';
 import { invalidateFilterCacheService } from './invalidateFilterCache.ts';
-import { fullfillQuotationService } from './fullfillQuotation.ts';
+import { fulfillQuotationService } from './fulfillQuotation.ts';
 import { processQuotationService } from './processQuotation.ts';
 import { proposeQuotationService } from './proposeQuotation.ts';
 import { rejectQuotationService } from './rejectQuotation.ts';
 import { verifyQuotationService } from './verifyQuotation.ts';
 import { loadFiltersService } from './loadFilters.ts';
 import { loadFilterOptionsService } from './loadFilterOptions.ts';
+import { removeFilterService } from './removeFilter.ts';
+import { removeCartDiscountService } from './removeCartDiscount.ts';
+import { addMultipleCartProductsService } from './addMultipleCartProducts.ts';
 import { ercMetadataService } from './ercMetadata.ts';
 import { simulateProductPricingService } from './simulateProductPricing.ts';
 import { simulateProductDispatchingService } from './simulateProductDispatching.ts';
 import { simulateProductInventoryService } from './simulateProductInventory.ts';
+import { simulateDeliveryPricingService } from './simulateDeliveryPricing.ts';
+import { simulatePaymentPricingService } from './simulatePaymentPricing.ts';
 import { findOrInitCartService } from './findOrInitCart.ts';
 import { addMessageService } from './addMessage.ts';
 import { generateOrderFromEnrollmentService } from './generateOrderFromEnrollment.ts';
+import { resolveOrderItemDispatchesService } from './resolveOrderItemDispatches.ts';
+import { findProductSiblingsService } from './findProductSiblings.ts';
+import { simulateConfigurablePriceRangeService } from './simulateConfigurablePriceRange.ts';
+import { createFileDownloadURLService } from './createFileDownloadURL.ts';
+import { resolveTokenStatusService } from './resolveTokenStatus.ts';
+import { isTokenInvalidateableService } from './isTokenInvalidateable.ts';
 export type ServiceInterface = (this: Modules, ...args: any[]) => Promise<any> | any;
 export type Bound<T extends ServiceInterface> = OmitThisParameter<T>;
 export type CustomServices = Record<string, ServiceInterface | Record<string, ServiceInterface>>;
@@ -60,6 +71,7 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         uploadFileFromStream: Bound<typeof uploadFileFromStreamService>;
         removeFiles: Bound<typeof removeFilesService>;
         createDownloadStream: Bound<typeof createDownloadStreamService>;
+        createFileDownloadURL: Bound<typeof createFileDownloadURLService>;
     };
     orders: {
         registerPaymentCredentials: Bound<typeof registerPaymentCredentialsService>;
@@ -78,12 +90,17 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         rejectOrder: Bound<typeof rejectOrderService>;
         discountedEntities: Bound<typeof discountedEntitiesService>;
         createManualOrderDiscount: Bound<typeof createManualOrderDiscountService>;
+        resolveOrderItemDispatches: Bound<typeof resolveOrderItemDispatchesService>;
+        removeCartDiscount: Bound<typeof removeCartDiscountService>;
+        addMultipleCartProducts: Bound<typeof addMultipleCartProductsService>;
     };
     products: {
         simulateProductPricing: Bound<typeof simulateProductPricingService>;
         simulateProductDispatching: Bound<typeof simulateProductDispatchingService>;
         simulateProductInventory: Bound<typeof simulateProductInventoryService>;
         removeProduct: Bound<typeof removeProductService>;
+        findProductSiblings: Bound<typeof findProductSiblingsService>;
+        simulateConfigurablePriceRange: Bound<typeof simulateConfigurablePriceRangeService>;
     };
     users: {
         migrateUserData: Bound<typeof migrateUserDataService>;
@@ -99,7 +116,7 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         terminateEnrollment: Bound<typeof terminateEnrollmentService>;
     };
     quotations: {
-        fullfillQuotation: Bound<typeof fullfillQuotationService>;
+        fulfillQuotation: Bound<typeof fulfillQuotationService>;
         processQuotation: Bound<typeof processQuotationService>;
         proposeQuotation: Bound<typeof proposeQuotationService>;
         rejectQuotation: Bound<typeof rejectQuotationService>;
@@ -111,12 +128,21 @@ export default function initServices(modules: Modules, customServices?: CustomSe
         invalidateFilterCache: Bound<typeof invalidateFilterCacheService>;
         loadFilters: Bound<typeof loadFiltersService>;
         loadFilterOptions: Bound<typeof loadFilterOptionsService>;
+        removeFilter: Bound<typeof removeFilterService>;
     };
     warehousing: {
         ercMetadata: Bound<typeof ercMetadataService>;
+        resolveTokenStatus: Bound<typeof resolveTokenStatusService>;
+        isTokenInvalidateable: Bound<typeof isTokenInvalidateableService>;
     };
     worker: {
         addMessage: Bound<typeof addMessageService>;
     };
+    delivery: {
+        simulateDeliveryPricing: Bound<typeof simulateDeliveryPricingService>;
+    };
+    payment: {
+        simulatePaymentPricing: Bound<typeof simulatePaymentPricingService>;
+    };
 };
 export type Services = ReturnType<typeof initServices>;

package/lib/services/index.js

@@ -31,20 +31,31 @@ import { initializeEnrollmentService } from "./initializeEnrollment.js";
 import { activateEnrollmentService } from "./activateEnrollment.js";
 import { terminateEnrollmentService } from "./terminateEnrollment.js";
 import { invalidateFilterCacheService } from "./invalidateFilterCache.js";
-import { fullfillQuotationService } from "./fullfillQuotation.js";
+import { fulfillQuotationService } from "./fulfillQuotation.js";
 import { processQuotationService } from "./processQuotation.js";
 import { proposeQuotationService } from "./proposeQuotation.js";
 import { rejectQuotationService } from "./rejectQuotation.js";
 import { verifyQuotationService } from "./verifyQuotation.js";
 import { loadFiltersService } from "./loadFilters.js";
 import { loadFilterOptionsService } from "./loadFilterOptions.js";
+import { removeFilterService } from "./removeFilter.js";
+import { removeCartDiscountService } from "./removeCartDiscount.js";
+import { addMultipleCartProductsService } from "./addMultipleCartProducts.js";
 import { ercMetadataService } from "./ercMetadata.js";
 import { simulateProductPricingService } from "./simulateProductPricing.js";
 import { simulateProductDispatchingService } from "./simulateProductDispatching.js";
 import { simulateProductInventoryService } from "./simulateProductInventory.js";
+import { simulateDeliveryPricingService } from "./simulateDeliveryPricing.js";
+import { simulatePaymentPricingService } from "./simulatePaymentPricing.js";
 import { findOrInitCartService } from "./findOrInitCart.js";
 import { addMessageService } from "./addMessage.js";
 import { generateOrderFromEnrollmentService } from "./generateOrderFromEnrollment.js";
+import { resolveOrderItemDispatchesService } from "./resolveOrderItemDispatches.js";
+import { findProductSiblingsService } from "./findProductSiblings.js";
+import { simulateConfigurablePriceRangeService } from "./simulateConfigurablePriceRange.js";
+import { createFileDownloadURLService } from "./createFileDownloadURL.js";
+import { resolveTokenStatusService } from "./resolveTokenStatus.js";
+import { isTokenInvalidateableService } from "./isTokenInvalidateable.js";
 function bindMethodsToModules(modules) {
     return {
         get(target, prop, receiver) {
@@ -71,6 +82,7 @@ export default function initServices(modules, customServices = {}) {
             uploadFileFromStream: uploadFileFromStreamService,
             removeFiles: removeFilesService,
             createDownloadStream: createDownloadStreamService,
+            createFileDownloadURL: createFileDownloadURLService,
         },
         orders: {
             registerPaymentCredentials: registerPaymentCredentialsService,
@@ -89,12 +101,17 @@ export default function initServices(modules, customServices = {}) {
             rejectOrder: rejectOrderService,
             discountedEntities: discountedEntitiesService,
             createManualOrderDiscount: createManualOrderDiscountService,
+            resolveOrderItemDispatches: resolveOrderItemDispatchesService,
+            removeCartDiscount: removeCartDiscountService,
+            addMultipleCartProducts: addMultipleCartProductsService,
         },
         products: {
             simulateProductPricing: simulateProductPricingService,
             simulateProductDispatching: simulateProductDispatchingService,
             simulateProductInventory: simulateProductInventoryService,
             removeProduct: removeProductService,
+            findProductSiblings: findProductSiblingsService,
+            simulateConfigurablePriceRange: simulateConfigurablePriceRangeService,
         },
         users: {
             migrateUserData: migrateUserDataService,
@@ -110,7 +127,7 @@ export default function initServices(modules, customServices = {}) {
             terminateEnrollment: terminateEnrollmentService,
         },
         quotations: {
-            fullfillQuotation: fullfillQuotationService,
+            fulfillQuotation: fulfillQuotationService,
             processQuotation: processQuotationService,
             proposeQuotation: proposeQuotationService,
             rejectQuotation: rejectQuotationService,
@@ -122,13 +139,22 @@ export default function initServices(modules, customServices = {}) {
             invalidateFilterCache: invalidateFilterCacheService,
             loadFilters: loadFiltersService,
             loadFilterOptions: loadFilterOptionsService,
+            removeFilter: removeFilterService,
         },
         warehousing: {
             ercMetadata: ercMetadataService,
+            resolveTokenStatus: resolveTokenStatusService,
+            isTokenInvalidateable: isTokenInvalidateableService,
         },
         worker: {
             addMessage: addMessageService,
         },
+        delivery: {
+            simulateDeliveryPricing: simulateDeliveryPricingService,
+        },
+        payment: {
+            simulatePaymentPricing: simulatePaymentPricingService,
+        },
     };
     return new Proxy({ ...services, ...customServices }, bindMethodsToModules(modules));
 }

package/lib/services/isTokenInvalidateable.d.ts

@@ -0,0 +1,5 @@
+import type { TokenSurrogate } from '@unchainedshop/core-warehousing';
+import type { Modules } from '../modules.ts';
+export declare function isTokenInvalidateableService(this: Modules, { token, }: {
+    token: TokenSurrogate;
+}): Promise<boolean>;

package/lib/services/isTokenInvalidateable.js

@@ -0,0 +1,15 @@
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { WarehousingDirector } from "../directors/WarehousingDirector.js";
+export async function isTokenInvalidateableService({ token, }) {
+    const product = await this.products.findProduct({ productId: token.productId });
+    if (!product)
+        return false;
+    const virtualProviders = (await this.warehousing.allProviders()).filter(({ type }) => type === WarehousingProviderType.VIRTUAL);
+    const isInvalidateable = await WarehousingDirector.isInvalidateable(virtualProviders, {
+        token,
+        product,
+        quantity: token?.quantity || 1,
+        referenceDate: new Date(),
+    }, { modules: this });
+    return !!isInvalidateable;
+}

package/lib/services/processOrder.js

@@ -3,14 +3,16 @@ import { createEnrollmentFromCheckoutService } from "./createEnrollmentFromCheck
 import { ProductType } from '@unchainedshop/core-products';
 import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
 import { WarehousingDirector, DeliveryDirector, PaymentDirector } from "../directors/index.js";
-import { fullfillQuotationService } from "./fullfillQuotation.js";
+import { fulfillQuotationService } from "./fulfillQuotation.js";
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:core:processOrder');
 const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modules) => {
     if (orderPayment.status !== OrderPaymentStatus.PAID) {
         const paymentProvider = await modules.payment.paymentProviders.findProvider({
             paymentProviderId: orderPayment.paymentProviderId,
         });
         if (!paymentProvider)
-            throw new Error('Payment provider not found: ' + orderPayment.paymentProviderId);
+            throw new Error(`Payment provider not found: ${orderPayment.paymentProviderId}`);
         const actions = await PaymentDirector.actions(paymentProvider, {}, { modules });
         if (!actions.isPayLaterAllowed())
             return false;
@@ -20,7 +22,7 @@ const isAutoConfirmationEnabled = async ({ orderPayment, orderDelivery, }, modul
             deliveryProviderId: orderDelivery.deliveryProviderId,
         });
         if (!deliveryProvider)
-            throw new Error('Delivery provider not found: ' + orderDelivery.deliveryProviderId);
+            throw new Error(`Delivery provider not found: ${orderDelivery.deliveryProviderId}`);
         const director = await DeliveryDirector.actions(deliveryProvider, {}, { modules });
         if (!director.isAutoReleaseAllowed())
             return false;
@@ -31,7 +33,7 @@ const findNextStatus = async (status, order, modules) => {
     if (status === null) {
         return OrderStatus.PENDING;
     }
-    if (status === OrderStatus.FULLFILLED || status === OrderStatus.REJECTED) {
+    if (status === OrderStatus.FULFILLED || status === OrderStatus.REJECTED) {
         return status;
     }
     const orderPayment = order.paymentId &&
@@ -52,10 +54,10 @@ const findNextStatus = async (status, order, modules) => {
         }
     }
     if (status === OrderStatus.CONFIRMED) {
-        const readyForFullfillment = orderDelivery.status === OrderDeliveryStatus.DELIVERED &&
+        const readyForFulfillment = orderDelivery.status === OrderDeliveryStatus.DELIVERED &&
             orderPayment.status === OrderPaymentStatus.PAID;
-        if (readyForFullfillment) {
-            return OrderStatus.FULLFILLED;
+        if (readyForFulfillment) {
+            return OrderStatus.FULFILLED;
         }
     }
     return status;
@@ -125,9 +127,15 @@ export async function processOrderService(initialOrder, orderTransactionContext)
                 const quotation = await this.quotations.findQuotation({
                     quotationId: orderPosition.quotationId,
                 });
-                if (!quotation)
+                if (!quotation) {
+                    logger.warn('Quotation not found during order fulfillment', {
+                        orderId,
+                        orderPositionId: orderPosition._id,
+                        quotationId: orderPosition.quotationId,
+                    });
                     return;
-                await fullfillQuotationService.bind(this)(quotation, {
+                }
+                await fulfillQuotationService.bind(this)(quotation, {
                     orderId,
                     orderPositionId: orderPosition._id,
                 });

package/lib/services/rejectQuotation.js

@@ -1,7 +1,7 @@
 import { QuotationStatus } from '@unchainedshop/core-quotations';
 import { processQuotationService } from "./processQuotation.js";
 export async function rejectQuotationService(quotation, { quotationContext }) {
-    if (quotation.status === QuotationStatus.FULLFILLED)
+    if (quotation.status === QuotationStatus.FULFILLED)
         return quotation;
     const updatedQuotation = (await this.quotations.updateStatus(quotation._id, {
         status: QuotationStatus.REJECTED,

package/lib/services/removeCartDiscount.d.ts

@@ -0,0 +1,10 @@
+import type { Modules } from '../modules.ts';
+import { type Order, type OrderDiscount } from '@unchainedshop/core-orders';
+export declare function removeCartDiscountService(this: Modules, { order, orderDiscount, requestContext, }: {
+    order: Order;
+    orderDiscount: OrderDiscount;
+    requestContext: {
+        localeContext: Intl.Locale;
+        userId?: string;
+    };
+}): Promise<OrderDiscount | null>;

package/lib/services/removeCartDiscount.js

@@ -0,0 +1,14 @@
+import { OrderDiscountDirector } from "../directors/index.js";
+import { OrderDiscountTrigger } from '@unchainedshop/core-orders';
+export async function removeCartDiscountService({ order, orderDiscount, requestContext, }) {
+    if (orderDiscount.trigger === OrderDiscountTrigger.USER) {
+        const Adapter = OrderDiscountDirector.getAdapter(orderDiscount.discountKey);
+        if (Adapter) {
+            const adapter = await Adapter.actions({
+                context: { order, orderDiscount, code: orderDiscount.code, modules: this, ...requestContext },
+            });
+            await adapter.release();
+        }
+    }
+    return this.orders.discounts.delete(orderDiscount._id);
+}

package/lib/services/removeFiles.js

@@ -4,7 +4,7 @@ export async function removeFilesService({ fileIds }) {
         throw Error('Media id/s to be removed not provided as a string or array');
     const fileUploadAdapter = getFileAdapter();
     const fileObjects = await this.files.findFiles({
-        _id: { $in: fileIds },
+        fileIds,
     });
     try {
         await fileUploadAdapter.removeFiles(fileObjects, { modules: this });

package/lib/services/removeFilter.d.ts

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

package/lib/services/removeFilter.js

@@ -0,0 +1,5 @@
+export async function removeFilterService({ filter }) {
+    await this.assortments.filters.deleteMany({ filterId: filter._id });
+    await this.filters.delete(filter._id);
+    return filter;
+}

package/lib/services/resolveOrderItemDispatches.d.ts

@@ -0,0 +1,19 @@
+import type { DeliveryProvider } from '@unchainedshop/core-delivery';
+import type { OrderPosition } from '@unchainedshop/core-orders';
+import type { Product } from '@unchainedshop/core-products';
+import type { WarehousingProvider } from '@unchainedshop/core-warehousing';
+import type { Modules } from '../modules.ts';
+export interface OrderItemDispatch {
+    _id: string;
+    deliveryProvider: DeliveryProvider;
+    warehousingProvider: WarehousingProvider;
+    product: Product;
+    quantity: number;
+    countryCode: string;
+    userId: string;
+    shipping: Date;
+    earliestDelivery: Date;
+}
+export declare function resolveOrderItemDispatchesService(this: Modules, { orderPosition, }: {
+    orderPosition: OrderPosition;
+}): Promise<OrderItemDispatch[] | null>;

package/lib/services/resolveOrderItemDispatches.js

@@ -0,0 +1,38 @@
+export async function resolveOrderItemDispatchesService({ orderPosition, }) {
+    const scheduling = orderPosition.scheduling || [];
+    if (!scheduling.length)
+        return [];
+    const order = await this.orders.findOrder({ orderId: orderPosition.orderId });
+    if (!order)
+        return null;
+    const { countryCode, userId, deliveryId } = order;
+    if (!deliveryId)
+        return null;
+    const orderDelivery = await this.orders.deliveries.findDelivery({
+        orderDeliveryId: deliveryId,
+    });
+    if (!orderDelivery)
+        return null;
+    const deliveryProvider = await this.delivery.findProvider({
+        deliveryProviderId: orderDelivery.deliveryProviderId,
+    });
+    if (!deliveryProvider)
+        return null;
+    const product = await this.products.findProduct({ productId: orderPosition.productId });
+    if (!product)
+        return null;
+    return Promise.all(scheduling.map(async (schedule) => {
+        const warehousingProvider = await this.warehousing.findProvider({
+            warehousingProviderId: schedule.warehousingProviderId,
+        });
+        return {
+            warehousingProvider,
+            deliveryProvider,
+            product,
+            quantity: orderPosition.quantity,
+            countryCode,
+            userId,
+            ...schedule,
+        };
+    }));
+}

package/lib/services/resolveTokenStatus.d.ts

@@ -0,0 +1,5 @@
+import type { TokenSurrogate, TokenStatus as TokenStatusType } from '@unchainedshop/core-warehousing';
+import type { Modules } from '../modules.ts';
+export declare function resolveTokenStatusService(this: Modules, { token, }: {
+    token: TokenSurrogate;
+}): Promise<TokenStatusType>;

package/lib/services/resolveTokenStatus.js

@@ -0,0 +1,15 @@
+import { TokenStatus } from '@unchainedshop/core-warehousing';
+import { WorkStatus } from '@unchainedshop/core-worker';
+export async function resolveTokenStatusService({ token, }) {
+    if (token.walletAddress && !token.userId) {
+        return TokenStatus.DECENTRALIZED;
+    }
+    const workItems = await this.worker.findWorkQueue({
+        types: ['EXPORT_TOKEN'],
+        status: [WorkStatus.NEW, WorkStatus.ALLOCATED],
+    });
+    if (workItems.find((item) => item.input?.token?._id === token._id)) {
+        return TokenStatus.EXPORTING;
+    }
+    return TokenStatus.CENTRALIZED;
+}

package/lib/services/simulateConfigurablePriceRange.d.ts

@@ -0,0 +1,13 @@
+import type { Product, ProductConfiguration, ProductPriceRange } from '@unchainedshop/core-products';
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export declare function simulateConfigurablePriceRangeService(this: Modules, { product, currencyCode, countryCode, quantity, useNetPrice, vectors, includeInactive, user, }: {
+    product: Product;
+    currencyCode: string;
+    countryCode: string;
+    quantity?: number;
+    useNetPrice?: boolean;
+    vectors?: ProductConfiguration[];
+    includeInactive?: boolean;
+    user?: User;
+}): Promise<ProductPriceRange | null>;

package/lib/services/simulateConfigurablePriceRange.js

@@ -0,0 +1,39 @@
+import { ProductPricingDirector } from "../core-index.js";
+export async function simulateConfigurablePriceRangeService({ product, currencyCode, countryCode, quantity = 1, useNetPrice = false, vectors, includeInactive = false, user, }) {
+    const products = await this.products.proxyProducts(product, vectors, {
+        includeInactive,
+    });
+    const filteredPrices = (await Promise.all(products.map(async (proxyProduct) => {
+        const pricingContext = {
+            product: proxyProduct,
+            user,
+            countryCode,
+            discounts: [],
+            currencyCode,
+            quantity,
+        };
+        const calculated = await ProductPricingDirector.rebuildCalculation(pricingContext, {
+            modules: this,
+        });
+        if (!calculated || !calculated.length)
+            return null;
+        const pricing = ProductPricingDirector.calculationSheet(pricingContext, calculated);
+        const unitPrice = pricing.unitPrice({ useNetPrice });
+        return {
+            ...unitPrice,
+            isNetPrice: useNetPrice,
+            isTaxable: pricing.taxSum() > 0,
+            currencyCode: pricing.currencyCode,
+        };
+    }))).filter(Boolean);
+    if (!filteredPrices.length)
+        return null;
+    const { minPrice, maxPrice } = this.products.prices.priceRange({
+        productId: product._id,
+        prices: filteredPrices,
+    });
+    return {
+        minPrice,
+        maxPrice,
+    };
+}

package/lib/services/simulateDeliveryPricing.d.ts

@@ -0,0 +1,21 @@
+import type { DeliveryProvider } from '@unchainedshop/core-delivery';
+import type { Order } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface SimulatedDeliveryPrice {
+    amount: number;
+    currencyCode: string;
+    countryCode: string;
+    isTaxable: boolean;
+    isNetPrice: boolean;
+}
+export declare function simulateDeliveryPricingService(this: Modules, pricingContext: {
+    currencyCode: string;
+    countryCode: string;
+    provider: DeliveryProvider;
+    providerContext?: any;
+    order?: Order;
+    user: User;
+}, options?: {
+    useNetPrice?: boolean;
+}): Promise<SimulatedDeliveryPrice | null>;

package/lib/services/simulateDeliveryPricing.js

@@ -0,0 +1,23 @@
+import { DeliveryPricingDirector } from "../core-index.js";
+export async function simulateDeliveryPricingService(pricingContext, options = {}) {
+    const context = {
+        currencyCode: pricingContext.currencyCode,
+        countryCode: pricingContext.countryCode,
+        provider: pricingContext.provider,
+        providerContext: pricingContext.providerContext,
+        order: pricingContext.order,
+        user: pricingContext.user,
+    };
+    const calculated = await DeliveryPricingDirector.rebuildCalculation(context, { modules: this });
+    if (!calculated?.length)
+        return null;
+    const pricing = DeliveryPricingDirector.calculationSheet(context, calculated);
+    const orderPrice = pricing.total({ useNetPrice: options.useNetPrice });
+    return {
+        amount: orderPrice.amount,
+        currencyCode: orderPrice.currencyCode,
+        countryCode: pricingContext.countryCode,
+        isTaxable: pricing.taxSum() > 0,
+        isNetPrice: options.useNetPrice || false,
+    };
+}

package/lib/services/simulatePaymentPricing.d.ts

@@ -0,0 +1,21 @@
+import type { PaymentProvider } from '@unchainedshop/core-payment';
+import type { Order } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface SimulatedPaymentPrice {
+    amount: number;
+    currencyCode: string;
+    countryCode: string;
+    isTaxable: boolean;
+    isNetPrice: boolean;
+}
+export declare function simulatePaymentPricingService(this: Modules, pricingContext: {
+    currencyCode: string;
+    countryCode: string;
+    provider: PaymentProvider;
+    providerContext?: any;
+    order?: Order;
+    user: User;
+}, options?: {
+    useNetPrice?: boolean;
+}): Promise<SimulatedPaymentPrice | null>;

package/lib/services/simulatePaymentPricing.js

@@ -0,0 +1,23 @@
+import { PaymentPricingDirector } from "../core-index.js";
+export async function simulatePaymentPricingService(pricingContext, options = {}) {
+    const context = {
+        currencyCode: pricingContext.currencyCode,
+        countryCode: pricingContext.countryCode,
+        provider: pricingContext.provider,
+        providerContext: pricingContext.providerContext,
+        order: pricingContext.order,
+        user: pricingContext.user,
+    };
+    const calculated = await PaymentPricingDirector.rebuildCalculation(context, { modules: this });
+    if (!calculated?.length)
+        return null;
+    const pricing = PaymentPricingDirector.calculationSheet(context, calculated);
+    const orderPrice = pricing.total({ useNetPrice: options.useNetPrice });
+    return {
+        amount: orderPrice.amount,
+        currencyCode: orderPrice.currencyCode,
+        countryCode: pricingContext.countryCode,
+        isTaxable: pricing.taxSum() > 0,
+        isNetPrice: options.useNetPrice || false,
+    };
+}

package/lib/services/updateUserAvatarAfterUpload.js

@@ -4,9 +4,9 @@ const logger = createLogger('unchained:core');
 export async function updateUserAvatarAfterUploadService({ file }) {
     const { userId } = file.meta;
     const files = await this.files.findFiles({
-        _id: { $ne: file._id },
+        excludeFileId: file._id,
         path: file.path,
-        'meta.userId': userId,
+        meta: { userId },
     });
     const fileIds = files.map((f) => f._id);
     try {

package/lib/utils/schedule.d.ts

@@ -0,0 +1,22 @@
+export interface ScheduleData {
+    schedules: {
+        s?: number[];
+        m?: number[];
+        h?: number[];
+        D?: number[];
+        M?: number[];
+        d?: number[];
+    }[];
+}
+declare function parseCron(cronExpr: string): ScheduleData;
+declare function parseText(text: string): ScheduleData;
+export declare const schedule: {
+    parse: {
+        cron: typeof parseCron;
+        text: typeof parseText;
+    };
+    schedule: (scheduleData: ScheduleData) => {
+        next: (count: number, referenceDate: Date) => Date | Date[];
+    };
+};
+export default schedule;

package/lib/utils/schedule.js

@@ -0,0 +1,148 @@
+function parseCronField(field, min, max) {
+    if (field === '*')
+        return undefined;
+    const values = [];
+    const parts = field.split(',');
+    for (const part of parts) {
+        const stepMatch = part.match(/^(\d+|\*)-?(\d+)?\/(\d+)$|^(\*|\d+-\d+)\/(\d+)$/);
+        if (stepMatch || part.includes('/')) {
+            const [rangePart, stepPart] = part.split('/');
+            const step = parseInt(stepPart, 10);
+            let start = min;
+            let end = max;
+            if (rangePart !== '*') {
+                if (rangePart.includes('-')) {
+                    const [rangeStart, rangeEnd] = rangePart.split('-').map(Number);
+                    start = rangeStart;
+                    end = rangeEnd;
+                }
+                else {
+                    start = parseInt(rangePart, 10);
+                }
+            }
+            for (let i = start; i <= end; i += step) {
+                if (!values.includes(i))
+                    values.push(i);
+            }
+            continue;
+        }
+        if (part.includes('-')) {
+            const [start, end] = part.split('-').map(Number);
+            for (let i = start; i <= end; i++) {
+                if (!values.includes(i))
+                    values.push(i);
+            }
+            continue;
+        }
+        const num = parseInt(part, 10);
+        if (!isNaN(num) && !values.includes(num)) {
+            values.push(num);
+        }
+    }
+    return values.length > 0 ? values.sort((a, b) => a - b) : undefined;
+}
+function parseCron(cronExpr) {
+    const parts = cronExpr.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Invalid cron expression: expected 5 fields, got ${parts.length}`);
+    }
+    const [minute, hour, dayOfMonth, month, dayOfWeek] = parts;
+    return {
+        schedules: [
+            {
+                s: [0],
+                m: parseCronField(minute, 0, 59),
+                h: parseCronField(hour, 0, 23),
+                D: parseCronField(dayOfMonth, 1, 31),
+                M: parseCronField(month, 1, 12),
+                d: parseCronField(dayOfWeek, 0, 6),
+            },
+        ],
+    };
+}
+function parseText(text) {
+    const match = text.toLowerCase().match(/every\s+(\d+)\s+(second|minute|hour)s?/);
+    if (!match) {
+        throw new Error(`Invalid schedule text: "${text}". Supported formats: "every N seconds/minutes/hours"`);
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+        case 'second': {
+            const seconds = [];
+            for (let i = 0; i < 60; i += value) {
+                seconds.push(i);
+            }
+            return {
+                schedules: [{ s: seconds }],
+            };
+        }
+        case 'minute': {
+            const minutes = [];
+            for (let i = 0; i < 60; i += value) {
+                minutes.push(i);
+            }
+            return {
+                schedules: [{ s: [0], m: minutes }],
+            };
+        }
+        case 'hour': {
+            const hours = [];
+            for (let i = 0; i < 24; i += value) {
+                hours.push(i);
+            }
+            return {
+                schedules: [{ s: [0], m: [0], h: hours }],
+            };
+        }
+        default:
+            throw new Error(`Unsupported time unit: ${unit}`);
+    }
+}
+function getNextOccurrences(scheduleData, count, referenceDate) {
+    const results = [];
+    const schedule = scheduleData.schedules[0];
+    const current = new Date(referenceDate.getTime());
+    current.setMilliseconds(0);
+    current.setSeconds(current.getSeconds() + 1);
+    const maxIterations = 366 * 24 * 60 * 60;
+    let iterations = 0;
+    while (results.length < count && iterations < maxIterations) {
+        iterations++;
+        const month = current.getMonth() + 1;
+        const dayOfMonth = current.getDate();
+        const dayOfWeek = current.getDay();
+        const hour = current.getHours();
+        const minute = current.getMinutes();
+        const second = current.getSeconds();
+        const matchesMonth = !schedule.M || schedule.M.includes(month);
+        const matchesDay = !schedule.D || schedule.D.includes(dayOfMonth);
+        const matchesDayOfWeek = !schedule.d || schedule.d.includes(dayOfWeek);
+        const matchesHour = !schedule.h || schedule.h.includes(hour);
+        const matchesMinute = !schedule.m || schedule.m.includes(minute);
+        const matchesSecond = !schedule.s || schedule.s.includes(second);
+        if (matchesMonth &&
+            matchesDay &&
+            matchesDayOfWeek &&
+            matchesHour &&
+            matchesMinute &&
+            matchesSecond) {
+            results.push(new Date(current));
+        }
+        current.setSeconds(current.getSeconds() + 1);
+    }
+    return results;
+}
+export const schedule = {
+    parse: {
+        cron: parseCron,
+        text: parseText,
+    },
+    schedule: (scheduleData) => ({
+        next: (count, referenceDate) => {
+            const results = getNextOccurrences(scheduleData, count, referenceDate);
+            return count === 1 ? results[0] : results;
+        },
+    }),
+};
+export default schedule;

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@unchainedshop/core",
-  "version": "4.4.0",
+  "description": "Core orchestration package for the Unchained Engine with business services and directors",
+  "version": "4.6.0",
   "main": "lib/core-index.js",
   "types": "lib/core-index.d.ts",
   "type": "module",
+  "sideEffects": false,
   "scripts": {
     "clean": "tsc -b --clean",
     "build": "tsc -b",
@@ -33,30 +35,28 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@breejs/later": "^4.2.0",
-    "@unchainedshop/core-assortments": "^4.4.0",
-    "@unchainedshop/core-bookmarks": "^4.4.0",
-    "@unchainedshop/core-countries": "^4.4.0",
-    "@unchainedshop/core-currencies": "^4.4.0",
-    "@unchainedshop/core-delivery": "^4.4.0",
-    "@unchainedshop/core-enrollments": "^4.4.0",
-    "@unchainedshop/core-events": "^4.4.0",
-    "@unchainedshop/core-files": "^4.4.0",
-    "@unchainedshop/core-filters": "^4.4.0",
-    "@unchainedshop/core-languages": "^4.4.0",
-    "@unchainedshop/core-orders": "^4.4.0",
-    "@unchainedshop/core-payment": "^4.4.0",
-    "@unchainedshop/core-products": "^4.4.0",
-    "@unchainedshop/core-quotations": "^4.4.0",
-    "@unchainedshop/core-users": "^4.4.0",
-    "@unchainedshop/core-warehousing": "^4.4.0",
-    "@unchainedshop/core-worker": "^4.4.0",
-    "@unchainedshop/logger": "^4.4.0",
-    "@unchainedshop/utils": "^4.4.0",
+    "@unchainedshop/core-assortments": "^4.6.0",
+    "@unchainedshop/core-bookmarks": "^4.6.0",
+    "@unchainedshop/core-countries": "^4.6.0",
+    "@unchainedshop/core-currencies": "^4.6.0",
+    "@unchainedshop/core-delivery": "^4.6.0",
+    "@unchainedshop/core-enrollments": "^4.6.0",
+    "@unchainedshop/core-events": "^4.6.0",
+    "@unchainedshop/core-files": "^4.6.0",
+    "@unchainedshop/core-filters": "^4.6.0",
+    "@unchainedshop/core-languages": "^4.6.0",
+    "@unchainedshop/core-orders": "^4.6.0",
+    "@unchainedshop/core-payment": "^4.6.0",
+    "@unchainedshop/core-products": "^4.6.0",
+    "@unchainedshop/core-quotations": "^4.6.0",
+    "@unchainedshop/core-users": "^4.6.0",
+    "@unchainedshop/core-warehousing": "^4.6.0",
+    "@unchainedshop/core-worker": "^4.6.0",
+    "@unchainedshop/logger": "^4.6.0",
+    "@unchainedshop/utils": "^4.6.0",
     "minipass-json-stream": "^1.0.2"
   },
   "devDependencies": {
-    "@types/breejs__later": "^4.1.5",
     "@types/node": "^25.0.0",
     "typescript": "^5.8.3"
   }

package/lib/services/fullfillQuotation.d.ts

@@ -1,3 +0,0 @@
-import { type Quotation } from '@unchainedshop/core-quotations';
-import type { Modules } from '../modules.ts';
-export declare function fullfillQuotationService(this: Modules, quotation: Quotation, info: any): Promise<Quotation>;