@unchainedshop/api 4.0.0-rc.2 → 4.0.0-rc.21

package/src/resolvers/mutations/orders/updateCartDeliveryPickUp.ts

@@ -0,0 +1,54 @@
+import { Context } from '../../../context.js';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  OrderDeliveryNotFoundError,
+  OrderDeliveryTypeError,
+  OrderNotFoundError,
+  OrderWrongStatusError,
+} from '../../../errors.js';
+
+export default async function updateCartDeliveryPickUp(
+  root: never,
+  params: { orderId: string; deliveryProviderId: string; orderPickUpLocationId: string; meta: any },
+  context: Context,
+) {
+  const { modules, services, userId, user } = context;
+  const { orderId, deliveryProviderId, orderPickUpLocationId, meta } = params;
+  log(`mutation updateCartDeliveryPickUp provider ${deliveryProviderId}`, {
+    userId,
+  });
+
+  if (!deliveryProviderId) throw new InvalidIdError({ deliveryProviderId });
+
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user: user!,
+    countryCode: context.countryCode,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+  if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
+
+  const provider = await modules.delivery.findProvider({
+    deliveryProviderId,
+  });
+  const deliveryProviderType = provider?.type;
+
+  if (deliveryProviderType !== DeliveryProviderType.PICKUP)
+    throw new OrderDeliveryTypeError({
+      orderId: order._id,
+      received: deliveryProviderType,
+      required: DeliveryProviderType.PICKUP,
+    });
+
+  order = (await modules.orders.setDeliveryProvider(order._id, deliveryProviderId)) || order;
+
+  if (!order.deliveryId) throw new OrderDeliveryNotFoundError({ orderId: order._id });
+
+  await modules.orders.deliveries.updateContext(order.deliveryId, {
+    orderPickUpLocationId,
+    meta,
+  });
+  return services.orders.updateCalculation(order._id);
+}

package/src/resolvers/mutations/orders/updateCartDeliveryShipping.ts

@@ -0,0 +1,54 @@
+import { Context } from '../../../context.js';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  OrderDeliveryNotFoundError,
+  OrderDeliveryTypeError,
+  OrderNotFoundError,
+  OrderWrongStatusError,
+} from '../../../errors.js';
+
+export default async function updateCartDeliveryShipping(
+  root: never,
+  params: { orderId: string; deliveryProviderId: string; address: any; meta: any },
+  context: Context,
+) {
+  const { modules, services, userId, user } = context;
+  const { orderId, deliveryProviderId, address, meta } = params;
+  log(`mutation updateCartDeliveryShipping provider ${deliveryProviderId}`, {
+    userId,
+  });
+
+  if (!deliveryProviderId) throw new InvalidIdError({ deliveryProviderId });
+
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user: user!,
+    countryCode: context.countryCode,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+  if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
+
+  const provider = await modules.delivery.findProvider({
+    deliveryProviderId,
+  });
+  const deliveryProviderType = provider?.type;
+
+  if (deliveryProviderType !== DeliveryProviderType.SHIPPING)
+    throw new OrderDeliveryTypeError({
+      orderId: order._id,
+      received: deliveryProviderType,
+      required: DeliveryProviderType.SHIPPING,
+    });
+
+  order = (await modules.orders.setDeliveryProvider(order._id, deliveryProviderId)) || order;
+
+  if (!order.deliveryId) throw new OrderDeliveryNotFoundError({ orderId: order._id });
+
+  await modules.orders.deliveries.updateContext(order.deliveryId, {
+    address,
+    meta,
+  });
+  return services.orders.updateCalculation(order._id);
+}

package/src/resolvers/mutations/orders/updateCartItem.ts

@@ -6,6 +6,7 @@ import {
   OrderWrongStatusError,
   ProductNotFoundError,
   InvalidIdError,
+  OrderNotFoundError,
 } from '../../../errors.js';
 import { ordersSettings } from '@unchainedshop/core-orders';
 
@@ -19,7 +20,7 @@ export default async function updateCartItem(
   context: Context,
 ) {
   const { modules, services, userId } = context;
-  const { itemId, configuration = null, quantity = null } = params;
+  const { itemId, configuration, quantity = 1 } = params;
 
   log(`mutation updateCartItem ${itemId} ${quantity} ${JSON.stringify(configuration)}`, { userId });
 
@@ -29,6 +30,9 @@ export default async function updateCartItem(
   if (!item) throw new OrderItemNotFoundError({ itemId });
 
   const order = await modules.orders.findOrder({ orderId: item.orderId });
+
+  if (!order) throw new OrderNotFoundError({ orderId: item.orderId });
+
   if (!modules.orders.isCart(order)) {
     throw new OrderWrongStatusError({ status: order.status });
   }
@@ -50,11 +54,12 @@ export default async function updateCartItem(
     context,
   );
 
-  const updatedOrderPosition = await modules.orders.positions.updateProductItem({
+  await modules.orders.positions.updateProductItem({
     orderPositionId: item._id,
     quantity,
     configuration,
   });
+
   await services.orders.updateCalculation(order._id);
-  return modules.orders.positions.findOrderPosition({ itemId: updatedOrderPosition._id });
+  return modules.orders.positions.findOrderPosition({ itemId: item._id });
 }

package/src/resolvers/mutations/orders/updateCartPaymentGeneric.ts

@@ -0,0 +1,53 @@
+import { Context } from '../../../context.js';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  OrderNotFoundError,
+  OrderPaymentNotFoundError,
+  OrderPaymentTypeError,
+  OrderWrongStatusError,
+} from '../../../errors.js';
+
+export default async function updateCartPaymentGeneric(
+  root: never,
+  params: { orderId: string; paymentProviderId: string; meta?: any },
+  context: Context,
+) {
+  const { modules, services, userId, user } = context;
+  const { orderId, paymentProviderId, meta } = params;
+  log(`mutation updateCartPaymentGeneric provider ${paymentProviderId}`, {
+    userId,
+  });
+
+  if (!paymentProviderId) throw new InvalidIdError({ paymentProviderId });
+
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user: user!,
+    countryCode: context.countryCode,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+  if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
+
+  const provider = await modules.payment.paymentProviders.findProvider({
+    paymentProviderId,
+  });
+  const paymentProviderType = provider?.type;
+
+  if (paymentProviderType !== PaymentProviderType.GENERIC)
+    throw new OrderPaymentTypeError({
+      orderId: order._id,
+      received: paymentProviderType,
+      required: PaymentProviderType.GENERIC,
+    });
+
+  order = (await modules.orders.setPaymentProvider(order._id, paymentProviderId)) || order;
+
+  if (!order.paymentId) throw new OrderPaymentNotFoundError({ orderId: order._id });
+
+  await modules.orders.payments.updateContext(order.paymentId, {
+    meta,
+  });
+  return services.orders.updateCalculation(order._id);
+}

package/src/resolvers/mutations/orders/updateCartPaymentInvoice.ts

@@ -0,0 +1,53 @@
+import { Context } from '../../../context.js';
+import { PaymentProviderType } from '@unchainedshop/core-payment';
+import { log } from '@unchainedshop/logger';
+import {
+  InvalidIdError,
+  OrderNotFoundError,
+  OrderPaymentNotFoundError,
+  OrderPaymentTypeError,
+  OrderWrongStatusError,
+} from '../../../errors.js';
+
+export default async function updateCartPaymentInvoice(
+  root: never,
+  params: { orderId: string; paymentProviderId: string; meta?: any },
+  context: Context,
+) {
+  const { modules, services, userId, user } = context;
+  const { orderId, paymentProviderId, meta } = params;
+  log(`mutation updateCartPaymentInvoice provider ${paymentProviderId}`, {
+    userId,
+  });
+
+  if (!paymentProviderId) throw new InvalidIdError({ paymentProviderId });
+
+  let order = await services.orders.findOrInitCart({
+    orderId,
+    user: user!,
+    countryCode: context.countryCode,
+  });
+  if (!order) throw new OrderNotFoundError({ orderId });
+  if (!modules.orders.isCart(order)) throw new OrderWrongStatusError({ status: order.status });
+
+  const provider = await modules.payment.paymentProviders.findProvider({
+    paymentProviderId,
+  });
+  const paymentProviderType = provider?.type;
+
+  if (paymentProviderType !== PaymentProviderType.INVOICE)
+    throw new OrderPaymentTypeError({
+      orderId: order._id,
+      received: paymentProviderType,
+      required: PaymentProviderType.INVOICE,
+    });
+
+  order = (await modules.orders.setPaymentProvider(order._id, paymentProviderId)) || order;
+
+  if (!order.paymentId) throw new OrderPaymentNotFoundError({ orderId: order._id });
+
+  await modules.orders.payments.updateContext(order.paymentId, {
+    meta,
+  });
+  return services.orders.updateCalculation(order._id);
+}

package/src/resolvers/mutations/payment/createPaymentProvider.ts

@@ -6,7 +6,7 @@ import { PaymentDirector } from '@unchainedshop/core';
 
 export default async (
   root: never,
-  { paymentProvider }: { paymentProvider: PaymentProvider },
+  { paymentProvider }: { paymentProvider: Pick<PaymentProvider, 'type' | 'adapterKey'> },
   { modules, userId }: Context,
 ) => {
   log('mutation createPaymentProvider', { userId });

package/src/resolvers/mutations/payment/markPaymentCredentialsPreferred.ts

@@ -22,7 +22,7 @@ export default async function makePaymentCredentialsPreferred(
 
   await modules.payment.paymentCredentials.markPreferred({
     paymentCredentialsId,
-    userId,
+    userId: userId!,
   });
 
   return modules.payment.paymentCredentials.findPaymentCredential({

package/src/resolvers/mutations/products/addProductAssignment.ts

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { ProductTypes } from '@unchainedshop/core-products';
+import { ProductTypes, ProductVariation } from '@unchainedshop/core-products';
 
 import { Context } from '../../../context.js';
 import { ProductConfiguration } from '@unchainedshop/core-products';
@@ -9,8 +9,9 @@ import {
   ProductWrongTypeError,
   ProductVariationVectorInvalid,
   ProductVariationVectorAlreadySet,
+  ProductVariationInfinityLoop,
 } from '../../../errors.js';
-const extractVariationMatrix = (variations = []) => {
+const extractVariationMatrix = (variations: ProductVariation[] = []) => {
   const cartesianProduct = (arrays) => {
     return arrays.reduce(
       (acc, array) => acc.flatMap((item) => array.map((value) => [...item, value])),
@@ -61,6 +62,8 @@ export default async function addProductAssignment(
   });
   if (!proxyProduct) throw new ProductNotFoundError({ proxyId });
 
+  if (productId === proxyId) throw new ProductVariationInfinityLoop({ productId });
+
   if (proxyProduct.type !== ProductTypes.ConfigurableProduct)
     throw new ProductWrongTypeError({
       proxyId,

package/src/resolvers/mutations/products/addProductReviewVote.ts

@@ -18,5 +18,5 @@ export default async function addProductReviewVote(
   });
   if (!productReview) throw new ProductReviewNotFoundError({ productReviewId });
 
-  return modules.products.reviews.votes.addVote(productReview, { meta, type, userId });
+  return modules.products.reviews.votes.addVote(productReview, { meta, type, userId: userId! });
 }

package/src/resolvers/mutations/products/createProductBundleItem.ts

@@ -2,7 +2,12 @@ import { log } from '@unchainedshop/logger';
 import { ProductTypes } from '@unchainedshop/core-products';
 import { Context } from '../../../context.js';
 import { ProductBundleItem } from '@unchainedshop/core-products';
-import { ProductNotFoundError, InvalidIdError, ProductWrongTypeError } from '../../../errors.js';
+import {
+  ProductNotFoundError,
+  InvalidIdError,
+  ProductWrongTypeError,
+  CyclicProductBundlingNotSupportedError,
+} from '../../../errors.js';
 
 export default async function createProductBundleItem(
   root: never,
@@ -24,8 +29,13 @@ export default async function createProductBundleItem(
       required: ProductTypes.BundleProduct,
     });
 
-  if (!(await modules.products.productExists({ productId: item.productId })))
-    throw new ProductNotFoundError({ productId: item.productId });
+  const itemProduct = await modules.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 modules.products.bundleItems.addBundleItem(productId, item);
 

package/src/resolvers/mutations/products/createProductReview.ts

@@ -6,7 +6,10 @@ import { InvalidIdError, ProductNotFoundError } from '../../../errors.js';
 
 export default async function createProductReview(
   root: never,
-  { productId, productReview }: { productId: string; productReview: ProductReview },
+  {
+    productId,
+    productReview,
+  }: { productId: string; productReview: Pick<ProductReview, 'title' | 'rating' | 'meta'> },
   { modules, userId }: Context,
 ) {
   log('mutation createProductReview', { userId, productId });
@@ -17,8 +20,8 @@ export default async function createProductReview(
     throw new ProductNotFoundError({ productId });
 
   return modules.products.reviews.create({
-    productId,
-    authorId: userId,
     ...productReview,
+    productId,
+    authorId: userId!,
   });
 }

package/src/resolvers/mutations/products/updateProductCommerce.ts

@@ -1,6 +1,6 @@
 import { log } from '@unchainedshop/logger';
-import { ProductCommerce } from '@unchainedshop/core-products';
-import { ProductNotFoundError, InvalidIdError } from '../../../errors.js';
+import { ProductCommerce, ProductTypes } from '@unchainedshop/core-products';
+import { ProductNotFoundError, InvalidIdError, ProductWrongTypeError } from '../../../errors.js';
 import { Context } from '../../../context.js';
 
 export default async function updateProductCommerce(
@@ -12,8 +12,16 @@ export default async function updateProductCommerce(
 
   if (!productId) throw new InvalidIdError({ productId });
 
-  if (!(await modules.products.productExists({ productId })))
-    throw new ProductNotFoundError({ productId });
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  if (product.type === ProductTypes.ConfigurableProduct) {
+    throw new ProductWrongTypeError({
+      productId: productId,
+      received: product.type,
+      required: { not: ProductTypes.ConfigurableProduct },
+    });
+  }
 
   await modules.products.update(productId, { commerce });
 

package/src/resolvers/mutations/quotations/requestQuotation.ts

@@ -20,7 +20,7 @@ export default async function requestQuotation(
     throw new ProductNotFoundError({ productId });
 
   const newQuotation = await modules.quotations.create({
-    userId,
+    userId: userId!,
     productId,
     countryCode,
     currencyCode,

package/src/resolvers/mutations/users/addPushSubscription.ts

@@ -10,12 +10,12 @@ const addPushSubscription = async (
   const userAgent = context.getHeader('user-agent');
   log(`mutation addPushSubscription ${userAgent}`, { userId });
 
-  await modules.users.addPushSubscription(userId, subscription, {
+  await modules.users.addPushSubscription(userId!, subscription, {
     userAgent,
     unsubscribeFromOtherUsers,
   });
 
-  return modules.users.findUserById(userId);
+  return modules.users.findUserById(userId!);
 };
 
 export default addPushSubscription;

package/src/resolvers/mutations/users/removePushSubscription.ts

@@ -7,9 +7,9 @@ const removePushSubscription = async (_, { p256dh }, context: Context) => {
 
   log(`mutation removePushSubscription ${userId} ${userAgent}`, { userId });
 
-  await modules.users.removePushSubscription(userId, p256dh);
+  await modules.users.removePushSubscription(userId!, p256dh);
 
-  return modules.users.findUserById(userId);
+  return modules.users.findUserById(userId!);
 };
 
 export default removePushSubscription;

package/src/resolvers/mutations/users/removeUser.ts

@@ -13,11 +13,11 @@ export default async function removeUser(
 
   log(`mutation removeUser ${normalizedUserId}`, { userId: currentUserId });
 
-  if (!(await modules.users.userExists({ userId: normalizedUserId })))
+  if (!(await modules.users.userExists({ userId: normalizedUserId! })))
     throw new UserNotFoundError({ userId: normalizedUserId });
 
   if (removeUserReviews) {
-    await modules.products.reviews.deleteMany({ authorId: normalizedUserId });
+    await modules.products.reviews.deleteMany({ authorId: normalizedUserId! });
   }
-  return services.users.deleteUser({ userId: normalizedUserId });
+  return services.users.deleteUser({ userId: normalizedUserId! });
 }

package/src/resolvers/mutations/users/updateUserProfile.ts

@@ -13,8 +13,8 @@ export default async function updateUserProfile(
 
   log(`mutation updateUserProfile ${normalizedUserId}`, { userId });
 
-  if (!(await modules.users.userExists({ userId: normalizedUserId })))
+  if (!(await modules.users.userExists({ userId: normalizedUserId! })))
     throw UserNotFoundError({ userId: normalizedUserId });
 
-  return modules.users.updateProfile(normalizedUserId, profile);
+  return modules.users.updateProfile(normalizedUserId!, profile);
 }

package/src/resolvers/mutations/warehousing/createWarehousingProvider.ts

@@ -6,7 +6,7 @@ import { WarehousingDirector } from '@unchainedshop/core';
 
 export default async function createWarehousingProvider(
   root: never,
-  { warehousingProvider }: { warehousingProvider: WarehousingProvider },
+  { warehousingProvider }: { warehousingProvider: Pick<WarehousingProvider, 'type' | 'adapterKey'> },
   { modules, userId }: Context,
 ) {
   log('mutation createWarehousingProvider', { userId });

package/src/resolvers/mutations/worker/allocateWork.ts

@@ -3,7 +3,7 @@ import { log } from '@unchainedshop/logger';
 
 export default async function allocateWork(
   root: never,
-  { types, worker }: { types?: string[]; worker?: string },
+  { types, worker }: { types: string[]; worker: string },
   { modules, userId }: Context,
 ) {
   log(`mutation allocateWork ${(types || []).join(',')} ${worker}`, {

package/src/resolvers/mutations/worker/finishWork.ts

@@ -10,12 +10,12 @@ export default async function finishWork(
     finished?: Date;
     result?: any;
     started?: Date;
-    success?: boolean;
+    success: boolean;
     worker?: string;
   },
   { modules, userId }: Context,
 ) {
-  const { workId, error, success } = data;
+  const { workId, error, success, ...workData } = data;
 
   log(`mutation finishWork ${workId} ${success}`, {
     userId,
@@ -26,7 +26,7 @@ export default async function finishWork(
   const work = await modules.worker.finishWork(workId, {
     error,
     success,
-    ...data,
+    ...workData,
   });
 
   if (!work) throw new WorkNotFoundOrWrongStatus({ workId });

package/src/resolvers/queries/delivery/deliveryInterfaces.ts

@@ -3,16 +3,20 @@ import { Context } from '../../../context.js';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 import { log } from '@unchainedshop/logger';
 
-export default function deliveryInterfaces(
+export default async function deliveryInterfaces(
   root: never,
   { type }: { type: DeliveryProviderType },
   { userId }: Context,
 ) {
   log(`query deliveryInterfaces ${type}`, { userId });
 
-  return DeliveryDirector.getAdapters({
-    adapterFilter: (Adapter) => Adapter.typeSupported(type),
-  }).map((Adapter) => ({
+  const allAdapters = await DeliveryDirector.getAdapters();
+
+  const filteredAdapters = type
+    ? allAdapters.filter((Adapter) => Adapter.typeSupported(type as DeliveryProviderType))
+    : allAdapters;
+
+  return filteredAdapters.map((Adapter) => ({
     _id: Adapter.key,
     label: Adapter.label,
     version: Adapter.version,

package/src/resolvers/queries/filters/searchAssortments.ts

@@ -1,18 +1,13 @@
 import { Context } from '../../../context.js';
 import { SearchQuery } from '@unchainedshop/core-filters';
 import { log } from '@unchainedshop/logger';
-import { QueryStringRequiredError } from '../../../errors.js';
 
 export default async function searchAssortments(root: never, query: SearchQuery, context: Context) {
   const { services, userId, locale } = context;
-  const forceLiveCollection = false;
 
   log(`query search assortments ${JSON.stringify(query)}`, { userId });
 
-  if (!query.queryString && !query.assortmentIds?.length) throw new QueryStringRequiredError({});
-
   return services.filters.searchAssortments(query, {
-    forceLiveCollection,
     locale,
   });
 }

package/src/resolvers/queries/filters/searchProducts.ts

@@ -1,6 +1,5 @@
 import { log } from '@unchainedshop/logger';
 import { SearchFilterQuery } from '@unchainedshop/core-filters';
-import { QueryStringRequiredError } from '../../../errors.js';
 import { Context } from '../../../context.js';
 
 export default async function searchProducts(
@@ -16,7 +15,6 @@ export default async function searchProducts(
   context: Context,
 ) {
   const { modules, services, userId, locale } = context;
-  const forceLiveCollection = false;
   const { queryString, includeInactive, filterQuery, assortmentId, ignoreChildAssortments, ...rest } =
     query;
 
@@ -25,7 +23,6 @@ export default async function searchProducts(
   if (assortmentId) {
     const productIds = await modules.assortments.findProductIds({
       assortmentId,
-      forceLiveCollection,
       ignoreChildAssortments,
     });
     const filterIds = await modules.assortments.filters.findFilterIds({
@@ -33,14 +30,12 @@ export default async function searchProducts(
     });
     return services.filters.searchProducts(
       { queryString, includeInactive, filterQuery, productIds, filterIds, ...rest },
-      { forceLiveCollection, locale: locale },
+      { locale: locale },
     );
   }
 
-  if (!queryString) throw new QueryStringRequiredError({});
-
   return services.filters.searchProducts(
     { queryString, includeInactive, filterQuery, ...rest },
-    { forceLiveCollection, locale: locale },
+    { locale: locale },
   );
 }

package/src/resolvers/queries/index.ts

@@ -79,7 +79,7 @@ export default {
   impersonator,
   user: acl(actions.viewUser)(user),
   users: acl(actions.viewUsers)(users),
-  usersCount: acl(actions.viewUsers)(usersCount),
+  usersCount: acl(actions.viewUserCount)(usersCount),
   product: acl(actions.viewProduct)(product),
   products: acl(actions.viewProducts)(products),
   productsCount: acl(actions.viewProducts)(productsCount),

package/src/resolvers/queries/orders/orderStatistics.ts

@@ -5,12 +5,12 @@ import { DateFilterInput } from '@unchainedshop/utils';
 export default async function orderStatistics(
   root: never,
   params: { dateRange?: DateFilterInput },
-  { modules, userId }: Context,
+  { userId }: Context,
 ) {
+  const { dateRange } = params || {};
   log(`query orderStatistics `, {
     userId,
     ...(params?.dateRange || {}),
   });
-
-  return modules.orders.getReport(params);
+  return { dateRange };
 }

package/src/resolvers/queries/orders/orders.ts

@@ -8,11 +8,31 @@ export default async function orders(
   params: OrderQuery & { limit?: number; offset?: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
-  const { includeCarts, limit, offset, queryString } = params;
+  const { limit, offset, paymentProviderIds, deliveryProviderIds, ...restParams } = params;
+  log(`query orders: ${limit} ${offset}  ${restParams?.queryString || ''}`, { userId });
 
-  log(`query orders: ${limit} ${offset} ${includeCarts} ${queryString}`, {
-    userId,
-  });
+  const promises: Promise<any>[] = [];
+
+  await Promise.all(promises);
+  const [orderPayments, orderDeliveries] = await Promise.all([
+    paymentProviderIds?.length
+      ? modules.orders.payments.findOrderPaymentsByProviderIds({ paymentProviderIds })
+      : [],
+    deliveryProviderIds?.length
+      ? modules.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 modules.orders.findOrders(params);
+  return modules.orders.findOrders({
+    ...restParams,
+    paymentIds,
+    deliveryIds,
+  });
 }