@unchainedshop/core 4.8.26 → 4.8.27

package/lib/services/createBookmark.js

@@ -0,0 +1,21 @@
+import { ProductNotFoundError, BookmarkAlreadyExistsError } from "../errors/index.js";
+export async function createBookmarkService(params) {
+    const { productId, userId, meta } = params;
+    if (!(await this.products.productExists({ productId }))) {
+        throw new ProductNotFoundError({ productId });
+    }
+    const [existingBookmark] = await this.bookmarks.findBookmarks({
+        productId,
+        userId,
+        meta,
+    });
+    if (existingBookmark) {
+        throw new BookmarkAlreadyExistsError({ bookmarkId: existingBookmark._id });
+    }
+    const bookmarkId = await this.bookmarks.create({
+        userId,
+        productId,
+        meta,
+    });
+    return (await this.bookmarks.findBookmarkById(bookmarkId));
+}

package/lib/services/createDeliveryProvider.d.ts

@@ -0,0 +1,6 @@
+import type { DeliveryProvider } from '@unchainedshop/core-delivery';
+import type { Modules } from '../modules.ts';
+export interface CreateDeliveryProviderParams {
+    deliveryProvider: Pick<DeliveryProvider, 'type' | 'adapterKey'>;
+}
+export declare function createDeliveryProviderService(this: Modules, params: CreateDeliveryProviderParams): Promise<DeliveryProvider | null>;

package/lib/services/createDeliveryProvider.js

@@ -0,0 +1,19 @@
+import { DeliveryDirector } from "../directors/DeliveryDirector.js";
+import { ProviderConfigurationInvalidError } from "../errors/index.js";
+export async function createDeliveryProviderService(params) {
+    const { deliveryProvider } = params;
+    const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
+    if (!Adapter)
+        return null;
+    const provider = await this.delivery.create({
+        configuration: Adapter.initialConfiguration,
+        ...deliveryProvider,
+    });
+    if (!provider) {
+        throw new ProviderConfigurationInvalidError({
+            adapterKey: deliveryProvider.adapterKey,
+            type: deliveryProvider.type,
+        });
+    }
+    return provider;
+}

package/lib/services/createEnrollment.d.ts

@@ -0,0 +1,17 @@
+import type { Enrollment, EnrollmentPlan } from '@unchainedshop/core-enrollments';
+import type { Address, Contact } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface CreateEnrollmentParams {
+    productId: string;
+    quantity?: number;
+    configuration?: EnrollmentPlan['configuration'];
+    billingAddress?: Address;
+    contact?: Contact;
+    payment?: Enrollment['payment'];
+    delivery?: Enrollment['delivery'];
+    meta?: any;
+    countryCode: string;
+    currencyCode: string;
+    userId: string;
+}
+export declare function createEnrollmentService(this: Modules, params: CreateEnrollmentParams): Promise<Enrollment>;

package/lib/services/createEnrollment.js

@@ -0,0 +1,33 @@
+import { ProductStatus, ProductType } from '@unchainedshop/core-products';
+import { initializeEnrollmentService } from "./initializeEnrollment.js";
+import { ProductNotFoundError, ProductWrongStatusError, ProductWrongTypeError, } from "../errors/index.js";
+export async function createEnrollmentService(params) {
+    const { productId, quantity, configuration, billingAddress, contact, payment, delivery, meta, countryCode, currencyCode, userId, } = params;
+    const product = await this.products.findProduct({ productId });
+    if (!product) {
+        throw new ProductNotFoundError({ productId });
+    }
+    if (product.status !== ProductStatus.ACTIVE) {
+        throw new ProductWrongStatusError({ status: product.status });
+    }
+    if (product.type !== ProductType.PLAN_PRODUCT) {
+        throw new ProductWrongTypeError({ type: product.type });
+    }
+    const enrollment = await this.enrollments.create({
+        billingAddress: billingAddress,
+        configuration: configuration ?? null,
+        contact: contact,
+        countryCode,
+        currencyCode,
+        delivery: delivery,
+        meta,
+        payment,
+        productId,
+        quantity: quantity ?? 1,
+        userId,
+    });
+    return initializeEnrollmentService.bind(this)(enrollment, {
+        orderIdForFirstPeriod: enrollment.orderIdForFirstPeriod,
+        reason: 'new_enrollment',
+    });
+}

package/lib/services/createProduct.d.ts

@@ -0,0 +1,7 @@
+import type { Product, ProductText } from '@unchainedshop/core-products';
+import type { Modules } from '../modules.ts';
+export interface CreateProductParams {
+    product: Partial<Product>;
+    texts?: ProductText[];
+}
+export declare function createProductService(this: Modules, params: CreateProductParams): Promise<Product>;

package/lib/services/createProduct.js

@@ -0,0 +1,8 @@
+export async function createProductService(params) {
+    const { product: productData, texts } = params;
+    const newProduct = await this.products.create(productData);
+    if (texts) {
+        await this.products.texts.updateTexts(newProduct._id, texts);
+    }
+    return newProduct;
+}

package/lib/services/createProductBundleItem.d.ts

@@ -0,0 +1,5 @@
+import { type Product, type ProductBundleItem } from '@unchainedshop/core-products';
+import type { Modules } from '../modules.ts';
+import { ProductNotFoundError, ProductWrongTypeError, CyclicProductBundlingNotSupportedError } from '../errors/index.ts';
+export { ProductNotFoundError, ProductWrongTypeError, CyclicProductBundlingNotSupportedError };
+export declare function createProductBundleItemService(this: Modules, productId: string, item: ProductBundleItem): Promise<Product | null>;

package/lib/services/createProductBundleItem.js

@@ -0,0 +1,25 @@
+import { ProductType } from '@unchainedshop/core-products';
+import { ProductNotFoundError, ProductWrongTypeError, CyclicProductBundlingNotSupportedError, } from "../errors/index.js";
+export { ProductNotFoundError, ProductWrongTypeError, CyclicProductBundlingNotSupportedError };
+export async function createProductBundleItemService(productId, item) {
+    const product = await this.products.findProduct({ productId });
+    if (!product) {
+        throw new ProductNotFoundError({ productId });
+    }
+    if (product.type !== ProductType.BUNDLE_PRODUCT) {
+        throw new ProductWrongTypeError({
+            productId,
+            received: product.type,
+            required: ProductType.BUNDLE_PRODUCT,
+        });
+    }
+    const itemProduct = await this.products.findProduct({ productId: item.productId });
+    if (!itemProduct) {
+        throw new ProductNotFoundError({ productId: item.productId });
+    }
+    if (itemProduct._id === product._id) {
+        throw new CyclicProductBundlingNotSupportedError({ productId: itemProduct._id });
+    }
+    await this.products.bundleItems.addBundleItem(productId, item);
+    return this.products.findProduct({ productId });
+}

package/lib/services/createProductReview.d.ts

@@ -0,0 +1,8 @@
+import type { ProductReview } from '@unchainedshop/core-products';
+import type { Modules } from '../modules.ts';
+export interface CreateProductReviewParams {
+    productId: string;
+    authorId: string;
+    productReview: Pick<ProductReview, 'title' | 'rating' | 'meta'>;
+}
+export declare function createProductReviewService(this: Modules, params: CreateProductReviewParams): Promise<ProductReview>;

package/lib/services/createProductReview.js

@@ -0,0 +1,12 @@
+import { ProductNotFoundError } from "../errors/index.js";
+export async function createProductReviewService(params) {
+    const { productId, authorId, productReview } = params;
+    if (!(await this.products.productExists({ productId }))) {
+        throw new ProductNotFoundError({ productId });
+    }
+    return this.products.reviews.create({
+        ...productReview,
+        productId,
+        authorId,
+    });
+}

package/lib/services/deleteDeadCarts.d.ts

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

package/lib/services/deleteDeadCarts.js

@@ -0,0 +1,17 @@
+import { deleteCartService } from "./deleteCart.js";
+export async function deleteDeadCartsService() {
+    const cartUserIds = (await this.orders.findCartUserIds()).filter(Boolean);
+    if (!cartUserIds.length)
+        return 0;
+    const existingUserIds = new Set(await this.users.findExistingUserIds({ userIds: cartUserIds }));
+    const deadUserIds = cartUserIds.filter((userId) => !existingUserIds.has(userId));
+    if (!deadUserIds.length)
+        return 0;
+    const deadCarts = await this.orders.findCarts({ userIds: deadUserIds }, { projection: { _id: 1 } });
+    let deletedCount = 0;
+    await Array.fromAsync(deadCarts, async (cart) => {
+        await deleteCartService.bind(this)(cart._id);
+        deletedCount += 1;
+    });
+    return deletedCount;
+}

package/lib/services/deliverOrder.d.ts

@@ -0,0 +1,5 @@
+import { type Order } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+import { OrderDeliveryNotFoundError, OrderWrongDeliveryStatusError } from '../errors/index.ts';
+export { OrderDeliveryNotFoundError, OrderWrongDeliveryStatusError };
+export declare function deliverOrderService(this: Modules, orderId: string): Promise<Order>;

package/lib/services/deliverOrder.js

@@ -0,0 +1,26 @@
+import { OrderDeliveryStatus } from '@unchainedshop/core-orders';
+import { processOrderService } from "./processOrder.js";
+import { OrderNotFoundError, OrderWrongStatusError, OrderDeliveryNotFoundError, OrderWrongDeliveryStatusError, } from "../errors/index.js";
+export { OrderDeliveryNotFoundError, OrderWrongDeliveryStatusError };
+export async function deliverOrderService(orderId) {
+    const order = await this.orders.findOrder({ orderId });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId });
+    }
+    if (this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    const orderDelivery = order.deliveryId &&
+        (await this.orders.deliveries.findDelivery({
+            orderDeliveryId: order.deliveryId,
+        }));
+    if (!orderDelivery) {
+        throw new OrderDeliveryNotFoundError({ orderDeliveryId: order.deliveryId });
+    }
+    if (this.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN &&
+        order.confirmed) {
+        throw new OrderWrongDeliveryStatusError({ status: orderDelivery.status });
+    }
+    await this.orders.deliveries.markAsDelivered(orderDelivery);
+    return processOrderService.bind(this)(order, {});
+}

package/lib/services/findActiveWorkTypes.d.ts

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

package/lib/services/findActiveWorkTypes.js

@@ -0,0 +1,6 @@
+import { WorkerDirector } from "../directors/index.js";
+export async function findActiveWorkTypesService() {
+    const typeList = await this.worker.activeWorkTypes();
+    const pluginTypes = WorkerDirector.getActivePluginTypes();
+    return typeList.filter((type) => pluginTypes.includes(type));
+}

package/lib/services/findDeliveryInterfaces.d.ts

@@ -0,0 +1,7 @@
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+export interface DeliveryInterface {
+    _id: string;
+    label: string;
+    version: string;
+}
+export declare function findDeliveryInterfacesService(type?: DeliveryProviderType): Promise<DeliveryInterface[]>;

package/lib/services/findDeliveryInterfaces.js

@@ -0,0 +1,13 @@
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { DeliveryDirector } from "../directors/index.js";
+export async function findDeliveryInterfacesService(type) {
+    const allAdapters = await DeliveryDirector.getAdapters();
+    const filteredAdapters = type
+        ? allAdapters.filter((Adapter) => Adapter.typeSupported(type))
+        : allAdapters;
+    return filteredAdapters.map((Adapter) => ({
+        _id: Adapter.key,
+        label: Adapter.label,
+        version: Adapter.version,
+    }));
+}

package/lib/services/findOrdersWithFilters.d.ts

@@ -0,0 +1,9 @@
+import type { Order, OrderQuery } from '@unchainedshop/core-orders';
+import type { SortOption } from '@unchainedshop/utils';
+import type { Modules } from '../modules.ts';
+export interface FindOrdersWithFiltersParams extends OrderQuery {
+    limit?: number;
+    offset?: number;
+    sort?: SortOption[];
+}
+export declare function findOrdersWithFiltersService(this: Modules, params: FindOrdersWithFiltersParams): Promise<Order[]>;

package/lib/services/findOrdersWithFilters.js

@@ -0,0 +1,25 @@
+export async function findOrdersWithFiltersService(params) {
+    const { paymentProviderIds, deliveryProviderIds, ...restParams } = params;
+    if (!paymentProviderIds?.length && !deliveryProviderIds?.length) {
+        return this.orders.findOrders(restParams);
+    }
+    const [orderPayments, orderDeliveries] = await Promise.all([
+        paymentProviderIds?.length
+            ? this.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
+            : [],
+        deliveryProviderIds?.length
+            ? this.orders.deliveries.findDeliveryByProvidersId({ deliveryProviderIds })
+            : [],
+    ]);
+    if ((paymentProviderIds?.length && !orderPayments.length) ||
+        (deliveryProviderIds?.length && !orderDeliveries.length)) {
+        return [];
+    }
+    const paymentIds = orderPayments.map((p) => p._id);
+    const deliveryIds = orderDeliveries.map((d) => d._id);
+    return this.orders.findOrders({
+        ...restParams,
+        paymentIds,
+        deliveryIds,
+    });
+}

package/lib/services/findPaymentInterfaces.d.ts

@@ -0,0 +1,7 @@
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+export interface PaymentInterface {
+    _id: string;
+    label: string;
+    version: string;
+}
+export declare function findPaymentInterfacesService(type?: PaymentProviderType): Promise<PaymentInterface[]>;

package/lib/services/findPaymentInterfaces.js

@@ -0,0 +1,13 @@
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { PaymentDirector } from "../directors/index.js";
+export async function findPaymentInterfacesService(type) {
+    const allAdapters = await PaymentDirector.getAdapters();
+    const filteredAdapters = type
+        ? allAdapters.filter((Adapter) => Adapter.typeSupported(type))
+        : allAdapters;
+    return filteredAdapters.map((Adapter) => ({
+        _id: Adapter.key,
+        label: Adapter.label,
+        version: Adapter.version,
+    }));
+}

package/lib/services/findWarehousingInterfaces.d.ts

@@ -0,0 +1,7 @@
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+export interface WarehousingInterface {
+    _id: string;
+    label: string;
+    version: string;
+}
+export declare function findWarehousingInterfacesService(type?: WarehousingProviderType): Promise<WarehousingInterface[]>;

package/lib/services/findWarehousingInterfaces.js

@@ -0,0 +1,13 @@
+import { WarehousingProviderType } from '@unchainedshop/core-warehousing';
+import { WarehousingDirector } from "../directors/index.js";
+export async function findWarehousingInterfacesService(type) {
+    const allAdapters = await WarehousingDirector.getAdapters();
+    const filteredAdapters = type
+        ? allAdapters.filter((Adapter) => Adapter.typeSupported(type))
+        : allAdapters;
+    return filteredAdapters.map((Adapter) => ({
+        _id: Adapter.key,
+        label: Adapter.label,
+        version: Adapter.version,
+    }));
+}

package/lib/services/getDeliveryDiscounts.d.ts

@@ -0,0 +1,8 @@
+import type { OrderDelivery } from '@unchainedshop/core-orders';
+export interface DeliveryDiscountPrice {
+    item: OrderDelivery;
+    amount: number;
+    currencyCode: string;
+    discountId: string;
+}
+export declare function getDeliveryDiscountsService(orderDelivery: OrderDelivery, currencyCode: string): DeliveryDiscountPrice[];

package/lib/services/getDeliveryDiscounts.js

@@ -0,0 +1,14 @@
+import { DeliveryPricingSheet } from "../directors/index.js";
+export function getDeliveryDiscountsService(orderDelivery, currencyCode) {
+    const pricing = DeliveryPricingSheet({
+        calculation: orderDelivery.calculation,
+        currencyCode,
+    });
+    if (pricing.isValid()) {
+        return pricing.discountPrices().map((discount) => ({
+            item: orderDelivery,
+            ...discount,
+        }));
+    }
+    return [];
+}

package/lib/services/getPaymentDiscounts.d.ts

@@ -0,0 +1,8 @@
+import type { OrderPayment } from '@unchainedshop/core-orders';
+export interface PaymentDiscountPrice {
+    item: OrderPayment;
+    amount: number;
+    currencyCode: string;
+    discountId: string;
+}
+export declare function getPaymentDiscountsService(orderPayment: OrderPayment, currencyCode: string): PaymentDiscountPrice[];

package/lib/services/getPaymentDiscounts.js

@@ -0,0 +1,14 @@
+import { PaymentPricingSheet } from "../directors/index.js";
+export function getPaymentDiscountsService(orderPayment, currencyCode) {
+    const pricing = PaymentPricingSheet({
+        calculation: orderPayment.calculation,
+        currencyCode,
+    });
+    if (pricing.isValid()) {
+        return pricing.discountPrices().map((discount) => ({
+            item: orderPayment,
+            ...discount,
+        }));
+    }
+    return [];
+}

package/lib/services/getShopInfo.d.ts

@@ -0,0 +1,25 @@
+import type { Modules } from '../modules.ts';
+export interface AdminUIConfig {
+    customProperties?: unknown[];
+    singleSignOnURL?: string;
+    externalLinks?: unknown[];
+    defaultProductTags?: string[];
+    defaultAssortmentTags?: string[];
+    defaultUserTags?: string[];
+}
+export interface ShopInfoResult {
+    version?: string;
+    adminUiConfig: {
+        customProperties: () => Promise<unknown[]>;
+        singleSignOnURL?: string;
+        externalLinks: () => unknown[];
+        productTags: () => Promise<string[]>;
+        assortmentTags: () => Promise<string[]>;
+        userTags: () => Promise<string[]>;
+    };
+    vapidPublicKey?: string;
+}
+export declare function getShopInfoService(this: Modules, params: {
+    version?: string;
+    adminUiConfig?: AdminUIConfig;
+}): ShopInfoResult;

package/lib/services/getShopInfo.js

@@ -0,0 +1,47 @@
+import { readFile } from 'fs/promises';
+async function loadCustomProperties(adminUiConfig) {
+    try {
+        if (!process.env.UNCHAINED_ADMIN_UI_CUSTOM_PROPERTIES) {
+            return adminUiConfig?.customProperties ?? [];
+        }
+        const raw = await readFile(process.env.UNCHAINED_ADMIN_UI_CUSTOM_PROPERTIES, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return adminUiConfig?.customProperties ?? [];
+    }
+}
+function loadExternalLinks() {
+    try {
+        if (!process.env.EXTERNAL_LINKS)
+            return [];
+        return JSON.parse(process.env.EXTERNAL_LINKS);
+    }
+    catch {
+        return [];
+    }
+}
+async function getConfiguredTags(existingTagsFn, envVar, configDefault) {
+    const existingTags = await existingTagsFn();
+    const envTags = (process.env[envVar] || '')
+        .split(',')
+        .map((t) => t.trim())
+        .filter(Boolean);
+    const normalizedDefaultTags = envTags?.length ? envTags : (configDefault || []).filter(Boolean);
+    return Array.from(new Set(normalizedDefaultTags.concat(existingTags)));
+}
+export function getShopInfoService(params) {
+    const { version, adminUiConfig } = params;
+    return {
+        version,
+        adminUiConfig: {
+            customProperties: () => loadCustomProperties(adminUiConfig),
+            singleSignOnURL: process.env.UNCHAINED_ADMIN_UI_SINGLE_SIGN_ON_URL || adminUiConfig?.singleSignOnURL,
+            externalLinks: loadExternalLinks,
+            productTags: () => getConfiguredTags(() => this.products.existingTags(), 'UNCHAINED_ADMIN_UI_DEFAULT_PRODUCT_TAGS', adminUiConfig?.defaultProductTags),
+            assortmentTags: () => getConfiguredTags(() => this.assortments.existingTags(), 'UNCHAINED_ADMIN_UI_DEFAULT_ASSORTMENT_TAGS', adminUiConfig?.defaultAssortmentTags),
+            userTags: () => getConfiguredTags(() => this.users.existingTags(), 'UNCHAINED_ADMIN_UI_DEFAULT_USER_TAGS', adminUiConfig?.defaultUserTags),
+        },
+        vapidPublicKey: process.env?.PUSH_NOTIFICATION_PUBLIC_KEY,
+    };
+}

package/lib/services/impersonateUser.d.ts

@@ -0,0 +1,8 @@
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface ImpersonateUserParams {
+    userIdToImpersonate: string;
+    currentUserId?: string;
+    countryCode: string;
+}
+export declare function impersonateUserService(this: Modules, params: ImpersonateUserParams): Promise<User>;

package/lib/services/impersonateUser.js

@@ -0,0 +1,20 @@
+import { nextUserCartService } from "./nextUserCart.js";
+import { UserNotFoundError, ImpersonatingAdminUserError } from "../errors/index.js";
+export async function impersonateUserService(params) {
+    const { userIdToImpersonate, currentUserId, countryCode } = params;
+    const userToImpersonate = await this.users.findUserById(userIdToImpersonate);
+    if (!userToImpersonate) {
+        throw new UserNotFoundError({ userId: userIdToImpersonate });
+    }
+    if ((userToImpersonate.roles || []).includes('admin')) {
+        throw new ImpersonatingAdminUserError({
+            impersonatedUserId: userIdToImpersonate,
+            userId: currentUserId,
+        });
+    }
+    await nextUserCartService.bind(this)({
+        user: userToImpersonate,
+        countryCode,
+    });
+    return userToImpersonate;
+}

package/lib/services/loginAsGuest.d.ts

@@ -0,0 +1,10 @@
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface HttpContext {
+    remoteAddress?: string;
+    remotePort?: number;
+    userAgent?: string;
+    locale?: string;
+    countryCode: string;
+}
+export declare function loginAsGuestService(this: Modules, httpContext: HttpContext): Promise<User>;

package/lib/services/loginAsGuest.js

@@ -0,0 +1,19 @@
+import { nextUserCartService } from "./nextUserCart.js";
+export async function loginAsGuestService(httpContext) {
+    const guestname = `guest-${crypto.randomUUID()}`;
+    const guestUserId = await this.users.createUser({
+        email: `${guestname}@unchained.local`,
+        guest: true,
+        password: null,
+        initialPassword: true,
+    }, { skipMessaging: true });
+    const user = (await this.users.updateHeartbeat(guestUserId, {
+        remoteAddress: httpContext.remoteAddress,
+        remotePort: httpContext.remotePort,
+        userAgent: httpContext.userAgent,
+        locale: httpContext.locale,
+        countryCode: httpContext.countryCode,
+    }));
+    await nextUserCartService.bind(this)({ user, countryCode: httpContext.countryCode });
+    return user;
+}

package/lib/services/obfuscateWorkerData.d.ts

@@ -0,0 +1,4 @@
+export interface WorkerObfuscationOptions {
+    blacklistedVariables?: string[];
+}
+export declare function obfuscateWorkerDataService<T>(data: T, options?: WorkerObfuscationOptions): T;

package/lib/services/obfuscateWorkerData.js

@@ -0,0 +1,4 @@
+import { buildObfuscatedFieldsFilter } from '@unchainedshop/utils';
+export function obfuscateWorkerDataService(data, options) {
+    return buildObfuscatedFieldsFilter(options?.blacklistedVariables)(data);
+}

package/lib/services/orderPricingAccessors.d.ts

@@ -0,0 +1,18 @@
+import type { Order, OrderPosition } from '@unchainedshop/core-orders';
+import type { Price } from '@unchainedshop/utils';
+import type { Modules } from '../modules.ts';
+import { type IOrderPricingSheet } from '../directors/OrderPricingSheet.ts';
+import { type IProductPricingSheet } from '../directors/ProductPricingSheet.ts';
+export declare function getOrderPricingSheetService(this: Modules, order: Order): IOrderPricingSheet | null;
+export declare function getOrderTotalService(this: Modules, order: Order, params?: {
+    category?: string;
+    useNetPrice?: boolean;
+}): Price | null;
+export declare function getPositionPricingSheetService(this: Modules, position: OrderPosition, currencyCode: string): IProductPricingSheet | null;
+export declare function getPositionTotalService(this: Modules, position: OrderPosition, currencyCode: string, params?: {
+    category?: string;
+    useNetPrice?: boolean;
+}): Price | null;
+export declare function getPositionUnitPriceService(this: Modules, position: OrderPosition, currencyCode: string, params?: {
+    useNetPrice?: boolean;
+}): Price | null;

package/lib/services/orderPricingAccessors.js

@@ -0,0 +1,29 @@
+import { OrderPricingSheet } from "../directors/OrderPricingSheet.js";
+import { ProductPricingSheet } from "../directors/ProductPricingSheet.js";
+export function getOrderPricingSheetService(order) {
+    const pricing = OrderPricingSheet({
+        calculation: order.calculation,
+        currencyCode: order.currencyCode,
+    });
+    return pricing.isValid() ? pricing : null;
+}
+export function getOrderTotalService(order, params = {}) {
+    const pricing = getOrderPricingSheetService.call(this, order);
+    return pricing?.total(params) ?? null;
+}
+export function getPositionPricingSheetService(position, currencyCode) {
+    const pricing = ProductPricingSheet({
+        calculation: position.calculation,
+        currencyCode,
+        quantity: position.quantity,
+    });
+    return pricing.isValid() ? pricing : null;
+}
+export function getPositionTotalService(position, currencyCode, params = {}) {
+    const pricing = getPositionPricingSheetService.call(this, position, currencyCode);
+    return pricing?.total(params) ?? null;
+}
+export function getPositionUnitPriceService(position, currencyCode, params = {}) {
+    const pricing = getPositionPricingSheetService.call(this, position, currencyCode);
+    return pricing?.unitPrice(params) ?? null;
+}

package/lib/services/payOrder.d.ts

@@ -0,0 +1,5 @@
+import { type Order } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+import { OrderNotFoundError, OrderWrongStatusError, OrderPaymentNotFoundError, OrderWrongPaymentStatusError } from '../errors/index.ts';
+export { OrderNotFoundError, OrderWrongStatusError, OrderPaymentNotFoundError, OrderWrongPaymentStatusError, };
+export declare function payOrderService(this: Modules, orderId: string): Promise<Order>;

package/lib/services/payOrder.js

@@ -0,0 +1,25 @@
+import { OrderPaymentStatus } from '@unchainedshop/core-orders';
+import { processOrderService } from "./processOrder.js";
+import { OrderNotFoundError, OrderWrongStatusError, OrderPaymentNotFoundError, OrderWrongPaymentStatusError, } from "../errors/index.js";
+export { OrderNotFoundError, OrderWrongStatusError, OrderPaymentNotFoundError, OrderWrongPaymentStatusError, };
+export async function payOrderService(orderId) {
+    const order = await this.orders.findOrder({ orderId });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId });
+    }
+    if (this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    const payment = order.paymentId &&
+        (await this.orders.payments.findOrderPayment({
+            orderPaymentId: order.paymentId,
+        }));
+    if (!payment) {
+        throw new OrderPaymentNotFoundError({ orderPaymentId: order.paymentId });
+    }
+    if (this.orders.payments.normalizedStatus(payment) !== OrderPaymentStatus.OPEN) {
+        throw new OrderWrongPaymentStatusError({ status: payment.status });
+    }
+    await this.orders.payments.markAsPaid(payment, null);
+    return processOrderService.bind(this)(order, {});
+}