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

package/lib/services/simulateProductDispatching.js

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

package/lib/services/simulateProductInventory.d.ts

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

package/lib/services/simulateProductInventory.js

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

package/lib/services/supportedDeliveryProviders.js

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

package/lib/services/supportedPaymentProviders.js

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

package/lib/services/supportedWarehousingProviders.js

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

package/lib/services/suspendEnrollment.d.ts

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

package/lib/services/suspendEnrollment.js

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

package/lib/services/terminateEnrollment.d.ts

@@ -1,2 +1,6 @@
-import { type Enrollment } from '@unchainedshop/core-enrollments';
-export declare function terminateEnrollmentService(enrollment: Enrollment): Promise<any>;
+import { type Enrollment, type EnrollmentTerminationReason } from '@unchainedshop/core-enrollments';
+import type { Modules } from '../modules.ts';
+export declare function terminateEnrollmentService(this: Modules, enrollment: Enrollment, { reason, comment }?: {
+    reason?: EnrollmentTerminationReason;
+    comment?: string;
+}): Promise<Enrollment>;

package/lib/services/terminateEnrollment.js

@@ -1,14 +1,34 @@
-import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
+import { EnrollmentStatus, } from '@unchainedshop/core-enrollments';
 import { processEnrollmentService } from "./processEnrollment.js";
 import { addMessageService } from "./addMessage.js";
-export async function terminateEnrollmentService(enrollment) {
+import { EnrollmentDirector } from "../core-index.js";
+import { createServiceError } from "../errors.js";
+export async function terminateEnrollmentService(enrollment, { reason, comment } = {}) {
     if (enrollment.status === EnrollmentStatus.TERMINATED)
         return enrollment;
-    let updatedEnrollment = await this.enrollments.updateStatus(enrollment._id, {
-        status: EnrollmentStatus.TERMINATED,
-        info: 'terminated manually',
-    });
-    updatedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+    const product = await this.products.findProduct({ productId: enrollment.productId });
+    if (!product)
+        throw createServiceError('ProductNotFoundError', 'Product not found for enrollment');
+    const director = await EnrollmentDirector.actions({ enrollment, product }, { modules: this });
+    const terminationDate = await director.terminationDate({ referenceDate: new Date() });
+    if (!terminationDate) {
+        throw createServiceError('EnrollmentTerminationNotAllowedError', 'Enrollment termination is not allowed at this time');
+    }
+    const expires = new Date(Math.min(Math.max(terminationDate.getTime(), enrollment.minimumCommitmentEnd?.getTime() ?? 0), enrollment.expires?.getTime() ?? Infinity));
+    if (reason || comment) {
+        await this.enrollments.updateCancellation(enrollment._id, { reason, comment });
+    }
+    let updatedEnrollment;
+    if (expires.getTime() > Date.now()) {
+        updatedEnrollment = (await this.enrollments.updateExpiry(enrollment._id, expires));
+    }
+    else {
+        updatedEnrollment = (await this.enrollments.updateStatus(enrollment._id, {
+            status: EnrollmentStatus.TERMINATED,
+            info: 'terminated manually',
+        }));
+        updatedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+    }
     const user = await this.users.findUserById(enrollment.userId);
     const locale = this.users.userLocale(user);
     await addMessageService.bind(this)('ENROLLMENT_STATUS', {

package/lib/services/updateCalculation.js

@@ -1,11 +1,12 @@
 import { OrderDiscountTrigger, } from '@unchainedshop/core-orders';
 import { initCartProvidersService } from "./initCartProviders.js";
 import { updateSchedulingService } from "./updateScheduling.js";
+import { createServiceError } from "../errors.js";
 import { OrderDiscountDirector, OrderPricingDirector, DeliveryPricingDirector, ProductPricingDirector, PaymentPricingDirector, } from "../directors/index.js";
 export async function updateCalculationService(orderId) {
     let order = await this.orders.findOrder({ orderId });
     if (!order)
-        throw new Error('Order not found');
+        throw createServiceError('OrderNotFoundError', 'Order not found');
     if (order.status !== null)
         return order;
     const discounts = await this.orders.discounts.findOrderDiscounts({

package/lib/services/updateCartItem.d.ts

@@ -1,11 +1,11 @@
-import { type OrderPosition } from '@unchainedshop/core-orders';
+import { type Order, type OrderPosition } from '@unchainedshop/core-orders';
 import type { Modules } from '../modules.ts';
-export interface UpdateCartItemParams {
-    itemId: string;
-    quantity?: number;
+export declare function updateCartItemService(this: Modules, { order, item, quantity, configuration, }: {
+    order: Order;
+    item: OrderPosition;
+    quantity?: number | null;
     configuration?: {
         key: string;
         value: string;
-    }[];
-}
-export declare function updateCartItemService(this: Modules, params: UpdateCartItemParams, context: any): Promise<OrderPosition>;
+    }[] | null;
+}, unchainedAPI?: Record<string, any>): Promise<OrderPosition | null>;

package/lib/services/updateCartItem.js

@@ -1,37 +1,40 @@
 import { ordersSettings } from '@unchainedshop/core-orders';
-import { updateCalculationService } from "./updateCalculation.js";
-import { OrderItemNotFoundError, OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, ProductNotFoundError, } from "../errors/index.js";
-export async function updateCartItemService(params, context) {
-    const { itemId, configuration, quantity = 1 } = params;
-    const item = await this.orders.positions.findOrderPosition({ itemId });
-    if (!item) {
-        throw new OrderItemNotFoundError({ orderItemId: itemId });
-    }
-    const order = await this.orders.findOrder({ orderId: item.orderId });
-    if (!order) {
-        throw new OrderNotFoundError({ orderId: item.orderId });
-    }
-    if (!this.orders.isCart(order)) {
-        throw new OrderWrongStatusError({ status: order.status });
-    }
+import { QuotationDirector } from "../directors/QuotationDirector.js";
+import { createServiceError } from "../errors.js";
+export async function updateCartItemService({ order, item, quantity, configuration, }, unchainedAPI = {}) {
+    const context = { ...unchainedAPI, modules: this };
     const product = await this.products.findProduct({ productId: item.productId });
     if (!product) {
-        throw new ProductNotFoundError({ productId: item.productId });
+        throw createServiceError('ProductNotFoundError', `Product not found: ${item.productId}`);
     }
-    if (quantity !== null && quantity < 1) {
-        throw new OrderQuantityTooLowError({ quantity });
+    let itemQuantity = quantity === undefined ? 1 : quantity;
+    let itemConfiguration = configuration;
+    if (item.quotationId) {
+        const quotation = await this.quotations.findQuotation({ quotationId: item.quotationId });
+        if (!quotation) {
+            throw createServiceError('QuotationNotFoundError', `Quotation not found: ${item.quotationId}`);
+        }
+        const director = await QuotationDirector.actions({ quotation }, context);
+        const requestedQuantity = quantity || item.quantity;
+        const quotationConfiguration = await director.transformItemConfiguration({
+            quantity: requestedQuantity,
+            configuration: configuration || item.configuration || [],
+        });
+        if (!quotationConfiguration) {
+            throw createServiceError('QuotationItemConfigurationError', `Quotation ${quotation._id} does not take quantity ${requestedQuantity}`);
+        }
+        itemQuantity = quotationConfiguration.quantity || requestedQuantity;
+        itemConfiguration = quotationConfiguration.configuration;
     }
     await ordersSettings.validateOrderPosition({
         order,
         product,
-        configuration,
-        quantityDiff: quantity - item.quantity,
+        configuration: itemConfiguration,
+        quantityDiff: itemQuantity - item.quantity,
     }, context);
-    await this.orders.positions.updateProductItem({
+    return this.orders.positions.updateProductItem({
         orderPositionId: item._id,
-        quantity: quantity || null,
-        configuration: configuration || null,
+        quantity: itemQuantity || null,
+        configuration: itemConfiguration || null,
     });
-    await updateCalculationService.bind(this)(order._id);
-    return (await this.orders.positions.findOrderPosition({ itemId: item._id }));
 }

package/lib/services/updateEnrollmentPlan.d.ts

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

package/lib/services/updateEnrollmentPlan.js

@@ -0,0 +1,26 @@
+import { emit } from '@unchainedshop/events';
+import { EnrollmentDirector } from "../core-index.js";
+import { processEnrollmentService } from "./processEnrollment.js";
+import { addMessageService } from "./addMessage.js";
+import { createServiceError } from "../errors.js";
+export async function updateEnrollmentPlanService(enrollment, { plan }) {
+    const product = await this.products.findProduct({ productId: enrollment.productId });
+    if (!product)
+        throw createServiceError('ProductNotFoundError', 'Product not found for enrollment');
+    const director = await EnrollmentDirector.actions({ enrollment, product }, { modules: this });
+    const newPlan = await director.transformPlanToNewPlan({ plan });
+    if (!newPlan) {
+        throw createServiceError('EnrollmentPlanChangeNotSupportedError', 'Plan change is not supported for this enrollment');
+    }
+    let updatedEnrollment = (await this.enrollments.updatePlan(enrollment._id, newPlan));
+    updatedEnrollment = await processEnrollmentService.bind(this)(updatedEnrollment);
+    await emit('ENROLLMENT_PLAN_CHANGE', { enrollment: updatedEnrollment });
+    const user = await this.users.findUserById(enrollment.userId);
+    const locale = this.users.userLocale(user);
+    await addMessageService.bind(this)('ENROLLMENT_STATUS', {
+        reason: 'plan_change',
+        locale: locale.baseName,
+        enrollmentId: updatedEnrollment._id,
+    });
+    return updatedEnrollment;
+}

package/lib/services/updateFilter.d.ts

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

package/lib/services/updateFilter.js

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

package/lib/services/uploadFileFromStream.js

@@ -1,5 +1,6 @@
 import { getFileFromFileData } from '@unchainedshop/core-files';
 import { getFileAdapter } from "../utils/getFileAdapter.js";
+import { createServiceError } from "../errors.js";
 export async function uploadFileFromStreamService({ directoryName, rawFile, meta, ...options }) {
     const fileUploadAdapter = getFileAdapter();
     const uploadFileData = await fileUploadAdapter.uploadFileFromStream(directoryName, rawFile, {
@@ -9,6 +10,6 @@ export async function uploadFileFromStreamService({ directoryName, rawFile, meta
     const fileId = await this.files.create(fileData);
     const file = await this.files.findFile({ fileId });
     if (!file)
-        throw new Error('File not found after upload');
+        throw createServiceError('FileNotFoundError', 'File not found after upload');
     return file;
 }

package/lib/services/validateOrder.js

@@ -1,20 +1,19 @@
 import { ordersSettings } from '@unchainedshop/core-orders';
+import { createServiceError } from "../errors.js";
 export async function validateOrderService(order) {
     if (!order.contact)
-        throw new Error('Contact data not provided');
+        throw createServiceError('ContactMissingError', 'Contact data not provided');
     if (!order.billingAddress)
-        throw new Error('Billing address not provided');
+        throw createServiceError('BillingAddressMissingError', 'Billing address not provided');
     if (!order.deliveryId ||
         !(await this.orders.deliveries.findDelivery({ orderDeliveryId: order.deliveryId })))
-        throw new Error('No delivery provider selected');
+        throw createServiceError('NoDeliveryProviderError', 'No delivery provider selected');
     if (!order.paymentId ||
         !(await this.orders.payments.findOrderPayment({ orderPaymentId: order.paymentId })))
-        throw new Error('No payment provider selected');
+        throw createServiceError('NoPaymentProviderError', 'No payment provider selected');
     const orderPositions = await this.orders.positions.findOrderPositions({ orderId: order._id });
     if (orderPositions.length === 0) {
-        const NoItemsError = new Error('No items to checkout');
-        NoItemsError.name = 'NoItemsError';
-        throw NoItemsError;
+        throw createServiceError('NoItemsError', 'No items to checkout');
     }
     for (const orderPosition of orderPositions) {
         const product = await this.products.findProduct({
@@ -30,8 +29,13 @@ export async function validateOrderService(order) {
             (await this.quotations.findQuotation({
                 quotationId: orderPosition.quotationId,
             }));
-        if (quotation && !this.quotations.isProposalValid(quotation)) {
-            throw new Error('Quotation expired or fullfiled, please request a new offer');
+        if (quotation &&
+            !this.quotations.isProposalValidFor(quotation, {
+                userId: order.userId,
+                productId: orderPosition.productId,
+                currencyCode: order.currencyCode,
+            })) {
+            throw createServiceError('QuotationInvalidError', 'Quotation expired, fulfilled or not valid for this order, please request a new offer');
         }
     }
 }

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@unchainedshop/core",
   "description": "Core orchestration package for the Unchained Engine with business services and directors",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.11",
+  "files": [
+    "lib"
+  ],
   "main": "lib/core-index.js",
   "types": "lib/core-index.d.ts",
   "type": "module",
@@ -35,29 +38,32 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/core-assortments": "^5.0.0-alpha.1",
-    "@unchainedshop/core-bookmarks": "^5.0.0-alpha.1",
-    "@unchainedshop/core-countries": "^5.0.0-alpha.1",
-    "@unchainedshop/core-currencies": "^5.0.0-alpha.1",
-    "@unchainedshop/core-delivery": "^5.0.0-alpha.1",
-    "@unchainedshop/core-enrollments": "^5.0.0-alpha.1",
-    "@unchainedshop/core-events": "^5.0.0-alpha.1",
-    "@unchainedshop/core-files": "^5.0.0-alpha.1",
-    "@unchainedshop/core-filters": "^5.0.0-alpha.1",
-    "@unchainedshop/core-languages": "^5.0.0-alpha.1",
-    "@unchainedshop/core-orders": "^5.0.0-alpha.1",
-    "@unchainedshop/core-payment": "^5.0.0-alpha.1",
-    "@unchainedshop/core-products": "^5.0.0-alpha.1",
-    "@unchainedshop/core-quotations": "^5.0.0-alpha.1",
-    "@unchainedshop/core-users": "^5.0.0-alpha.1",
-    "@unchainedshop/core-warehousing": "^5.0.0-alpha.1",
-    "@unchainedshop/core-worker": "^5.0.0-alpha.1",
-    "@unchainedshop/logger": "^5.0.0-alpha.1",
-    "@unchainedshop/utils": "^5.0.0-alpha.1",
-    "minipass-json-stream": "^1.0.2"
+    "@unchainedshop/core-assortments": "^5.0.0-alpha.11",
+    "@unchainedshop/core-bookmarks": "^5.0.0-alpha.11",
+    "@unchainedshop/core-countries": "^5.0.0-alpha.11",
+    "@unchainedshop/core-currencies": "^5.0.0-alpha.11",
+    "@unchainedshop/core-delivery": "^5.0.0-alpha.11",
+    "@unchainedshop/core-enrollments": "^5.0.0-alpha.11",
+    "@unchainedshop/core-events": "^5.0.0-alpha.11",
+    "@unchainedshop/core-files": "^5.0.0-alpha.11",
+    "@unchainedshop/core-filters": "^5.0.0-alpha.11",
+    "@unchainedshop/core-languages": "^5.0.0-alpha.11",
+    "@unchainedshop/core-orders": "^5.0.0-alpha.11",
+    "@unchainedshop/core-payment": "^5.0.0-alpha.11",
+    "@unchainedshop/core-products": "^5.0.0-alpha.11",
+    "@unchainedshop/core-quotations": "^5.0.0-alpha.11",
+    "@unchainedshop/core-users": "^5.0.0-alpha.11",
+    "@unchainedshop/core-warehousing": "^5.0.0-alpha.11",
+    "@unchainedshop/core-worker": "^5.0.0-alpha.11",
+    "@unchainedshop/events": "^5.0.0-alpha.11",
+    "@unchainedshop/logger": "^5.0.0-alpha.11",
+    "@unchainedshop/mongodb": "^5.0.0-alpha.11",
+    "@unchainedshop/utils": "^5.0.0-alpha.11",
+    "minipass-json-stream": "^1.0.2",
+    "zod": "^4.2.0"
   },
   "devDependencies": {
-    "@types/node": "^25.0.0",
-    "typescript": "^5.8.3"
+    "@types/node": "^26.2.0",
+    "typescript": "^6.0.3"
   }
 }