@unchainedshop/core 4.6.1 → 4.7.2

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/linkFileService.js

@@ -1,4 +1,4 @@
-import { FileDirector } from '@unchainedshop/file-upload';
+import { FileDirector } from "../directors/FileDirector.js";
 export async function linkFileService({ fileId, size, type }) {
     const file = await this.files.findFile({ fileId });
     if (!file)

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

package/lib/services/registerUser.d.ts

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

package/lib/services/registerUser.js

@@ -0,0 +1,44 @@
+import { nextUserCartService } from "./nextUserCart.js";
+import { UsernameOrEmailRequiredError, PasswordOrWebAuthnPublicKeyRequiredError, EmailAlreadyExistsError, UsernameAlreadyExistsError, PasswordInvalidError, WebAuthnVerificationFailedError, AuthOperationFailedError, } from "../errors/index.js";
+export async function registerUserService(params, httpContext) {
+    if (!params.username && !params.email) {
+        throw new UsernameOrEmailRequiredError();
+    }
+    if (!params.password && !params.webAuthnPublicKeyCredentials) {
+        throw new PasswordOrWebAuthnPublicKeyRequiredError({ username: params.username });
+    }
+    const usersCountBeforeCreation = await this.users.count({
+        includeDeleted: true,
+        includeGuests: true,
+    });
+    const isFirstUser = usersCountBeforeCreation === 0;
+    let newUserId;
+    try {
+        newUserId = await this.users.createUser({
+            ...params,
+            initialPassword: false,
+            roles: isFirstUser ? ['admin'] : [],
+        }, {});
+    }
+    catch (e) {
+        if (e.cause === 'EMAIL_INVALID')
+            throw new EmailAlreadyExistsError({ email: params.email });
+        else if (e.cause === 'USERNAME_INVALID')
+            throw new UsernameAlreadyExistsError({ username: params.username });
+        else if (e.cause === 'PASSWORD_INVALID')
+            throw new PasswordInvalidError({ username: params.username });
+        else if (e.cause === 'WEBAUTHN_INVALID')
+            throw new WebAuthnVerificationFailedError({ username: params.username });
+        else
+            throw new AuthOperationFailedError({ username: params.username, email: params.email });
+    }
+    const user = (await this.users.updateHeartbeat(newUserId, {
+        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, isFirstUser };
+}

package/lib/services/removeBookmark.d.ts

@@ -0,0 +1,6 @@
+import type { Bookmark } from '@unchainedshop/core-bookmarks';
+import type { Modules } from '../modules.ts';
+export interface RemoveBookmarkParams {
+    bookmarkId: string;
+}
+export declare function removeBookmarkService(this: Modules, params: RemoveBookmarkParams): Promise<Bookmark>;

package/lib/services/removeBookmark.js

@@ -0,0 +1,10 @@
+import { BookmarkNotFoundError } from "../errors/index.js";
+export async function removeBookmarkService(params) {
+    const { bookmarkId } = params;
+    const bookmark = await this.bookmarks.findBookmarkById(bookmarkId);
+    if (!bookmark) {
+        throw new BookmarkNotFoundError({ bookmarkId });
+    }
+    await this.bookmarks.delete(bookmarkId);
+    return bookmark;
+}

package/lib/services/removeCartItem.d.ts

@@ -0,0 +1,6 @@
+import type { OrderPosition } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export interface RemoveCartItemParams {
+    itemId: string;
+}
+export declare function removeCartItemService(this: Modules, params: RemoveCartItemParams): Promise<OrderPosition>;

package/lib/services/removeCartItem.js

@@ -0,0 +1,19 @@
+import { updateCalculationService } from "./updateCalculation.js";
+import { OrderItemNotFoundError, OrderNotFoundError, OrderWrongStatusError } from "../errors/index.js";
+export async function removeCartItemService(params) {
+    const { itemId } = params;
+    const orderItem = await this.orders.positions.findOrderPosition({ itemId });
+    if (!orderItem) {
+        throw new OrderItemNotFoundError({ orderItemId: itemId });
+    }
+    const order = await this.orders.findOrder({ orderId: orderItem.orderId });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId: orderItem.orderId });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    const removedOrderPosition = await this.orders.positions.delete(itemId);
+    await updateCalculationService.bind(this)(order._id);
+    return removedOrderPosition;
+}

package/lib/services/removeFiles.js

@@ -1,4 +1,4 @@
-import { getFileAdapter } from '@unchainedshop/core-files';
+import { getFileAdapter } from "../utils/getFileAdapter.js";
 export async function removeFilesService({ fileIds }) {
     if (fileIds && typeof fileIds !== 'string' && !Array.isArray(fileIds))
         throw Error('Media id/s to be removed not provided as a string or array');

package/lib/services/resetPasswordWithMigration.d.ts

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

package/lib/services/resetPasswordWithMigration.js

@@ -0,0 +1,31 @@
+import { migrateUserDataService } from "./migrateUserData.js";
+import { nextUserCartService } from "./nextUserCart.js";
+import { InvalidResetTokenError, PasswordInvalidError } from "../errors/index.js";
+export async function resetPasswordWithMigrationService(params, httpContext, currentUserId) {
+    const { token, newPassword } = params;
+    let user;
+    try {
+        user = await this.users.resetPassword(token, newPassword);
+    }
+    catch (e) {
+        if (e && typeof e === 'object' && 'cause' in e && e.cause === 'PASSWORD_INVALID') {
+            throw new PasswordInvalidError();
+        }
+        throw e;
+    }
+    if (!user) {
+        throw new InvalidResetTokenError();
+    }
+    user = (await this.users.updateHeartbeat(user._id, {
+        remoteAddress: httpContext.remoteAddress,
+        remotePort: httpContext.remotePort,
+        userAgent: httpContext.userAgent,
+        locale: httpContext.locale,
+        countryCode: httpContext.countryCode,
+    }));
+    if (currentUserId) {
+        await migrateUserDataService.bind(this)(currentUserId, user._id);
+    }
+    await nextUserCartService.bind(this)({ user, countryCode: httpContext.countryCode });
+    return user;
+}

package/lib/services/resolveWorkType.d.ts

@@ -0,0 +1 @@
+export declare function resolveWorkTypeService(workType: string): string;

package/lib/services/resolveWorkType.js

@@ -0,0 +1,7 @@
+import { WorkerDirector } from "../directors/WorkerDirector.js";
+export function resolveWorkTypeService(workType) {
+    if (WorkerDirector.getActivePluginTypes().includes(workType)) {
+        return workType;
+    }
+    return 'UNKNOWN';
+}

package/lib/services/searchProductsWithAssortment.d.ts

@@ -0,0 +1,19 @@
+import type { Assortment } from '@unchainedshop/core-assortments';
+import type { SearchQuery } from '@unchainedshop/core-filters';
+import type { Modules } from '../modules.ts';
+export interface SearchProductsWithAssortmentParams extends SearchQuery {
+    assortmentId?: string;
+    assortment?: Assortment;
+    ignoreChildAssortments?: boolean;
+}
+export interface SearchProductsOptions {
+    locale: Intl.Locale;
+    userId?: string;
+    forceLiveCollection?: boolean;
+}
+export declare function searchProductsWithAssortmentService(this: Modules, params: SearchProductsWithAssortmentParams, options: SearchProductsOptions): Promise<{
+    searchConfiguration: import("../core-index.ts").SearchProductsOptions;
+    totalProductIds: string[];
+    aggregatedTotalProductIds: string[];
+    aggregatedFilteredProductIds: string[];
+}>;

package/lib/services/searchProductsWithAssortment.js

@@ -0,0 +1,17 @@
+import { searchProductsService } from "./searchProducts.js";
+export async function searchProductsWithAssortmentService(params, options) {
+    const { assortmentId, assortment: providedAssortment, ignoreChildAssortments, ...searchQuery } = params;
+    const assortment = providedAssortment ||
+        (assortmentId ? await this.assortments.findAssortment({ assortmentId }) : null);
+    if (!assortment) {
+        return searchProductsService.call(this, searchQuery, options);
+    }
+    const [productIds, filterIds] = await Promise.all([
+        this.assortments.findProductIds({
+            assortment,
+            ignoreChildAssortments: ignoreChildAssortments || false,
+        }),
+        this.assortments.filters.findFilterIds({ assortmentId: assortment._id }),
+    ]);
+    return searchProductsService.call(this, { ...searchQuery, productIds, filterIds }, options);
+}

package/lib/services/toggleBookmark.d.ts

@@ -0,0 +1,8 @@
+import type { Bookmark } from '@unchainedshop/core-bookmarks';
+import type { Modules } from '../modules.ts';
+export interface ToggleBookmarkParams {
+    productId: string;
+    userId: string;
+    bookmarked: boolean;
+}
+export declare function toggleBookmarkService(this: Modules, params: ToggleBookmarkParams): Promise<Bookmark>;

package/lib/services/toggleBookmark.js

@@ -0,0 +1,33 @@
+import { ProductNotFoundError, BookmarkNotFoundError, MultipleBookmarksFoundError, } from "../errors/index.js";
+export async function toggleBookmarkService(params) {
+    const { productId, userId, bookmarked } = params;
+    if (!(await this.products.productExists({ productId }))) {
+        throw new ProductNotFoundError({ productId });
+    }
+    const foundBookmarks = await this.bookmarks.findBookmarks({
+        productId,
+        userId,
+    });
+    if (foundBookmarks.length > 1) {
+        throw new MultipleBookmarksFoundError({
+            productId,
+            userId,
+            bookmarkIds: foundBookmarks.map((b) => b._id),
+        });
+    }
+    const foundBookmark = foundBookmarks[0];
+    if (bookmarked) {
+        if (foundBookmark)
+            return foundBookmark;
+        const bookmarkId = await this.bookmarks.create({
+            productId,
+            userId,
+        });
+        return (await this.bookmarks.findBookmarkById(bookmarkId));
+    }
+    if (!foundBookmark) {
+        throw new BookmarkNotFoundError({ productId, userId });
+    }
+    await this.bookmarks.delete(foundBookmark._id);
+    return foundBookmark;
+}

package/lib/services/updateCart.d.ts

@@ -0,0 +1,15 @@
+import type { Order } from '@unchainedshop/core-orders';
+import type { User } from '@unchainedshop/core-users';
+import type { Address, Contact } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface UpdateCartParams {
+    orderId?: string;
+    billingAddress?: Address;
+    contact?: Contact;
+    paymentProviderId?: string;
+    deliveryProviderId?: string;
+    meta?: any;
+    user: User;
+    countryCode: string;
+}
+export declare function updateCartService(this: Modules, params: UpdateCartParams): Promise<Order>;

package/lib/services/updateCart.js

@@ -0,0 +1,27 @@
+import { findOrInitCartService } from "./findOrInitCart.js";
+import { updateCalculationService } from "./updateCalculation.js";
+import { OrderNotFoundError, OrderWrongStatusError } from "../errors/index.js";
+export async function updateCartService(params) {
+    const { orderId, billingAddress, contact, paymentProviderId, deliveryProviderId, meta, user, countryCode, } = params;
+    const order = await findOrInitCartService.bind(this)({
+        orderId,
+        user,
+        countryCode,
+    });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    if (meta || billingAddress || contact) {
+        await this.orders.updateCartFields(order._id, { meta, billingAddress, contact });
+    }
+    if (paymentProviderId) {
+        await this.orders.setPaymentProvider(order._id, paymentProviderId);
+    }
+    if (deliveryProviderId) {
+        await this.orders.setDeliveryProvider(order._id, deliveryProviderId);
+    }
+    return updateCalculationService.bind(this)(order._id);
+}

package/lib/services/updateCartItem.d.ts

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