@unchainedshop/core 4.6.1 → 4.7.2

package/lib/services/addCartQuotation.js

@@ -0,0 +1,52 @@
+import { QuotationStatus } from '@unchainedshop/core-quotations';
+import { QuotationDirector } from "../directors/QuotationDirector.js";
+import { updateCalculationService } from "./updateCalculation.js";
+import { findOrInitCartService } from "./findOrInitCart.js";
+import { OrderNotFoundError, OrderWrongStatusError, OrderQuantityTooLowError, ProductNotFoundError, QuotationNotFoundError, QuotationWrongStatusError, QuotationItemConfigurationError, } from "../errors/index.js";
+export async function addCartQuotationService(params) {
+    const { orderId, quotationId, quantity, configuration, user, countryCode, context } = params;
+    if (quantity < 1) {
+        throw new OrderQuantityTooLowError({ quantity });
+    }
+    const quotation = await this.quotations.findQuotation({ quotationId });
+    if (!quotation) {
+        throw new QuotationNotFoundError({ quotationId });
+    }
+    if (quotation.status !== QuotationStatus.PROPOSED) {
+        throw new QuotationWrongStatusError({ status: quotation.status });
+    }
+    const order = await findOrInitCartService.bind(this)({
+        orderId,
+        user,
+        countryCode,
+    });
+    if (!order) {
+        throw new OrderNotFoundError({ orderId: orderId || null });
+    }
+    if (!this.orders.isCart(order)) {
+        throw new OrderWrongStatusError({ status: order.status });
+    }
+    if (!(await this.products.productExists({ productId: quotation.productId }))) {
+        throw new ProductNotFoundError({ productId: quotation.productId });
+    }
+    const director = await QuotationDirector.actions({ quotation }, context);
+    const quotationConfiguration = await director.transformItemConfiguration({
+        quantity,
+        configuration,
+    });
+    if (!quotationConfiguration) {
+        throw new QuotationItemConfigurationError({ configuration });
+    }
+    const updatedOrderPosition = await this.orders.positions.addProductItem({
+        quantity: quotationConfiguration.quantity || 1,
+        configuration: quotationConfiguration.configuration,
+        quotationId,
+        productId: quotation.productId,
+        originalProductId: quotation.productId,
+        orderId: order._id,
+    });
+    await updateCalculationService.bind(this)(order._id);
+    return (await this.orders.positions.findOrderPosition({
+        itemId: updatedOrderPosition._id,
+    }));
+}

package/lib/services/addEmail.d.ts

@@ -0,0 +1,7 @@
+import type { User } from '@unchainedshop/core-users';
+import type { Modules } from '../modules.ts';
+export interface AddEmailParams {
+    userId: string;
+    email: string;
+}
+export declare function addEmailService(this: Modules, params: AddEmailParams): Promise<User>;

package/lib/services/addEmail.js

@@ -0,0 +1,17 @@
+import { UserNotFoundError, EmailAlreadyExistsError } from "../errors/index.js";
+export async function addEmailService(params) {
+    const { userId, email } = params;
+    if (!(await this.users.userExists({ userId }))) {
+        throw new UserNotFoundError({ userId });
+    }
+    try {
+        await this.users.addEmail(userId, email);
+    }
+    catch (e) {
+        if (e.cause === 'EMAIL_INVALID') {
+            throw new EmailAlreadyExistsError({ email });
+        }
+        throw e;
+    }
+    return (await this.users.findUserById(userId));
+}

package/lib/services/addProductAssignment.d.ts

@@ -0,0 +1,3 @@
+import { type Product, type ProductConfiguration } from '@unchainedshop/core-products';
+import type { Modules } from '../modules.ts';
+export declare function addProductAssignmentService(this: Modules, proxyId: string, productId: string, vectors: ProductConfiguration[]): Promise<Product | null>;

package/lib/services/addProductAssignment.js

@@ -0,0 +1,63 @@
+import { ProductType, } from '@unchainedshop/core-products';
+import { ProductNotFoundError, ProductWrongTypeError, ProductVariationInfinityLoopError, ProductVariationVectorInvalidError, ProductVariationVectorAlreadySetError, } from "../errors/index.js";
+const extractVariationMatrix = (variations = []) => {
+    const cartesianProduct = (arrays) => {
+        return arrays.reduce((acc, array) => acc.flatMap((item) => array.map((value) => [...item, value])), [
+            [],
+        ]);
+    };
+    const keys = variations.map((item) => item.key);
+    const options = variations.map((item) => item.options);
+    const combinations = cartesianProduct(options);
+    return combinations.map((combination) => combination.reduce((acc, value, index) => {
+        acc[keys[index]] = value;
+        return acc;
+    }, {}));
+};
+const combinationExists = (matrix, combination) => {
+    return matrix.some((variation) => {
+        return (Object.keys(variation).length === Object.keys(combination).length &&
+            Object.entries(combination).every(([key, value]) => variation[key] === value));
+    });
+};
+export async function addProductAssignmentService(proxyId, productId, vectors) {
+    if (!(await this.products.productExists({ productId }))) {
+        throw new ProductNotFoundError({ productId });
+    }
+    const proxyProduct = await this.products.findProduct({ productId: proxyId });
+    if (!proxyProduct) {
+        throw new ProductNotFoundError({ productId: proxyId });
+    }
+    if (productId === proxyId) {
+        throw new ProductVariationInfinityLoopError({ productId });
+    }
+    if (proxyProduct.type !== ProductType.CONFIGURABLE_PRODUCT) {
+        throw new ProductWrongTypeError({
+            proxyId,
+            received: proxyProduct.type,
+            required: ProductType.CONFIGURABLE_PRODUCT,
+        });
+    }
+    const variations = await this.products.variations.findProductVariations({
+        productId: proxyId,
+    });
+    const variationMatrix = extractVariationMatrix(variations);
+    const normalizedVectors = vectors?.reduce((prev, { key, value }) => {
+        return {
+            ...prev,
+            [key]: value,
+        };
+    }, {});
+    if (!combinationExists(variationMatrix, normalizedVectors)) {
+        throw new ProductVariationVectorInvalidError({ proxyId, vectors });
+    }
+    const added = await this.products.assignments.addProxyAssignment({
+        productId,
+        proxyId,
+        vectors,
+    });
+    if (!added) {
+        throw new ProductVariationVectorAlreadySetError({ proxyId, vectors });
+    }
+    return this.products.findProduct({ productId: proxyId });
+}

package/lib/services/authenticateWithPassword.d.ts

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

package/lib/services/authenticateWithPassword.js

@@ -0,0 +1,34 @@
+import { migrateUserDataService } from "./migrateUserData.js";
+import { nextUserCartService } from "./nextUserCart.js";
+import { UsernameOrEmailRequiredError, InvalidCredentialsError } from "../errors/index.js";
+export async function authenticateWithPasswordService(params, httpContext, currentUserId) {
+    const { username, email, password } = params;
+    if (!username && !email) {
+        throw new UsernameOrEmailRequiredError();
+    }
+    let user = username
+        ? await this.users.findUserByUsername(username)
+        : await this.users.findUserByEmail(email);
+    if (!user) {
+        throw new InvalidCredentialsError({ username, email });
+    }
+    const verified = user.services?.password && (await this.users.verifyPassword(user.services.password, password));
+    if (!verified) {
+        throw new InvalidCredentialsError({ username, email });
+    }
+    if (user.guest) {
+        await this.users.updateGuest(user, false);
+    }
+    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/changePassword.d.ts

@@ -0,0 +1,10 @@
+import type { Modules } from '../modules.ts';
+export interface ChangePasswordParams {
+    userId: string;
+    oldPassword: string;
+    newPassword: string;
+}
+export interface ChangePasswordResult {
+    success: boolean;
+}
+export declare function changePasswordService(this: Modules, params: ChangePasswordParams): Promise<ChangePasswordResult>;

package/lib/services/changePassword.js

@@ -0,0 +1,19 @@
+import { InvalidCredentialsError, PasswordInvalidError } from "../errors/index.js";
+export async function changePasswordService(params) {
+    const { userId, oldPassword, newPassword } = params;
+    const user = await this.users.findUserById(userId);
+    const isValidCurrentPassword = user?.services?.password && (await this.users.verifyPassword(user.services.password, oldPassword));
+    if (!isValidCurrentPassword) {
+        throw new InvalidCredentialsError();
+    }
+    try {
+        await this.users.setPassword(user._id, newPassword);
+        return { success: true };
+    }
+    catch (e) {
+        if (e.cause === 'PASSWORD_INVALID') {
+            throw new PasswordInvalidError({ userId });
+        }
+        throw e;
+    }
+}

package/lib/services/countOrdersWithFilters.d.ts

@@ -0,0 +1,3 @@
+import type { OrderQuery } from '@unchainedshop/core-orders';
+import type { Modules } from '../modules.ts';
+export declare function countOrdersWithFiltersService(this: Modules, params: OrderQuery): Promise<number>;

package/lib/services/countOrdersWithFilters.js

@@ -0,0 +1,25 @@
+export async function countOrdersWithFiltersService(params) {
+    const { paymentProviderIds, deliveryProviderIds, ...restParams } = params;
+    if (!paymentProviderIds?.length && !deliveryProviderIds?.length) {
+        return this.orders.count(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 0;
+    }
+    const paymentIds = orderPayments.map((p) => p._id);
+    const deliveryIds = orderDeliveries.map((d) => d._id);
+    return this.orders.count({
+        ...restParams,
+        paymentIds,
+        deliveryIds,
+    });
+}

package/lib/services/createAssortment.d.ts

@@ -0,0 +1,7 @@
+import type { Assortment, AssortmentText } from '@unchainedshop/core-assortments';
+import type { Modules } from '../modules.ts';
+export interface CreateAssortmentParams {
+    assortment: Partial<Assortment>;
+    texts?: AssortmentText[];
+}
+export declare function createAssortmentService(this: Modules, params: CreateAssortmentParams): Promise<Assortment>;

package/lib/services/createAssortment.js

@@ -0,0 +1,10 @@
+export async function createAssortmentService(params) {
+    const { assortment: assortmentData, texts } = params;
+    const assortment = await this.assortments.create({
+        ...assortmentData,
+    });
+    if (texts) {
+        await this.assortments.texts.updateTexts(assortment._id, texts);
+    }
+    return assortment;
+}

package/lib/services/createBookmark.d.ts

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

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

@@ -1,4 +1,4 @@
-import { getFileAdapter } from '@unchainedshop/core-files';
+import { getFileAdapter } from "../utils/getFileAdapter.js";
 export async function createDownloadStreamService({ fileId, }) {
     const fileAdapter = getFileAdapter();
     const file = await this.files.findFile({ fileId });

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

@@ -1,4 +1,5 @@
-import { getFileAdapter } from '@unchainedshop/core-files';
+import {} from '@unchainedshop/core-files';
+import { getFileAdapter } from "../utils/getFileAdapter.js";
 export async function createFileDownloadURLService({ file, expires, params = {}, }) {
     if (!file)
         return null;

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

@@ -1,4 +1,5 @@
-import { getFileFromFileData, getFileAdapter } from '@unchainedshop/core-files';
+import { getFileFromFileData } from '@unchainedshop/core-files';
+import { getFileAdapter } from "../utils/getFileAdapter.js";
 export async function createSignedURLService({ directoryName, fileName, meta }) {
     const fileUploadAdapter = getFileAdapter();
     const preparedFileData = await fileUploadAdapter.createSignedURL(directoryName, fileName, {

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[]>;