@unchainedshop/api 1.1.3

package/src/resolvers/queries/index.js

@@ -0,0 +1,133 @@
+import { actions } from '../../roles';
+import { checkResolver as acl } from '../../acl';
+
+import activeWorkTypes from './worker/activeWorkTypes';
+import assortment from './assortments/assortment';
+import assortments from './assortments/assortments';
+import assortmentsCount from './assortments/assortmentsCount';
+import countries from './countries/countries';
+import countriesCount from './countries/countriesCount';
+import country from './countries/country';
+import currencies from './currencies/currencies';
+import currenciesCount from './currencies/currenciesCount';
+import currency from './currencies/currency';
+import deliveryInterfaces from './delivery/deliveryInterfaces';
+import deliveryProvider from './delivery/deliveryProvider';
+import deliveryProviders from './delivery/deliveryProviders';
+import deliveryProvidersCount from './delivery/deliveryProvidersCount';
+import enrollment from './enrollments/enrollment';
+import enrollments from './enrollments/enrollments';
+import enrollmentsCount from './enrollments/enrollmentsCount';
+import event from './events/event';
+import events from './events/events';
+import eventsCount from './events/eventsCounts';
+import filter from './filters/filter';
+import filters from './filters/filters';
+import filtersCount from './filters/filtersCount';
+import language from './languages/language';
+import languages from './languages/languages';
+import languagesCount from './languages/languagesCount';
+import me from './users/me';
+import order from './orders/order';
+import orders from './orders/orders';
+import ordersCount from './orders/ordersCount';
+import paymentInterfaces from './payment/paymentInterfaces';
+import paymentProvider from './payment/paymentProvider';
+import paymentProviders from './payment/paymentProviders';
+import paymentProvidersCount from './payment/paymentProvidersCount';
+import product from './products/product';
+import productCatalogPrices from './products/productCatalogPrices';
+import productReview from './products/productReview';
+import productReviews from './products/productReviews';
+import productReviewsCount from './products/productReviewsCount';
+import products from './products/products';
+import productsCount from './products/productsCount';
+import quotation from './quotations/quotation';
+import quotations from './quotations/quotations';
+import quotationsCount from './quotations/quotationsCount';
+import searchAssortments from './filters/searchAssortments';
+import searchProducts from './filters/searchProducts';
+import shopInfo from './shopInfo';
+import translatedAssortmentMediaTexts from './assortments/translatedAssortmentMediaTexts';
+import translatedAssortmentTexts from './assortments/translatedAssortmentTexts';
+import translatedFilterTexts from './filters/translatedFilterTexts';
+import translatedProductMediaTexts from './products/translatedProductMediaTexts.ts';
+import translatedProductTexts from './products/translatedProductTexts';
+import translatedProductVariationTexts from './products/translatedProductVariationTexts';
+import user from './users/user';
+import users from './users/users';
+import usersCount from './users/usersCount';
+import warehousingInterfaces from './warehousing/warehousingInterfaces';
+import warehousingProvider from './warehousing/warehousingProvider';
+import warehousingProviders from './warehousing/warehousingProviders';
+import warehousingProvidersCount from './warehousing/warehousingProvidersCount';
+import work from './worker/work';
+import workQueue from './worker/workQueue';
+import workQueueCount from './worker/workQueueCount';
+
+export default {
+  me,
+  user: acl(actions.viewUser)(user),
+  users: acl(actions.viewUsers)(users),
+  usersCount: acl(actions.viewUsers)(usersCount),
+  product: acl(actions.viewProduct)(product),
+  products: acl(actions.viewProducts)(products),
+  productsCount: acl(actions.viewProducts)(productsCount),
+  productCatalogPrices: acl(actions.viewProduct)(productCatalogPrices),
+  languagesCount: acl(actions.viewLanguages)(languagesCount),
+  languages: acl(actions.viewLanguages)(languages),
+  language: acl(actions.viewLanguage)(language),
+  countriesCount: acl(actions.viewCountries)(countriesCount),
+  countries: acl(actions.viewCountries)(countries),
+  country: acl(actions.viewCountry)(country),
+  currenciesCount: acl(actions.viewCurrencies)(currenciesCount),
+  currencies: acl(actions.viewCurrencies)(currencies),
+  currency: acl(actions.viewCurrency)(currency),
+  paymentProviders: acl(actions.viewPaymentProviders)(paymentProviders),
+  paymentProvidersCount: acl(actions.viewPaymentProviders)(paymentProvidersCount),
+  paymentProvider: acl(actions.viewPaymentProvider)(paymentProvider),
+  paymentInterfaces: acl(actions.viewPaymentInterfaces)(paymentInterfaces),
+  deliveryProvidersCount: acl(actions.viewDeliveryProviders)(deliveryProvidersCount),
+  deliveryProviders: acl(actions.viewDeliveryProviders)(deliveryProviders),
+  deliveryProvider: acl(actions.viewDeliveryProvider)(deliveryProvider),
+  deliveryInterfaces: acl(actions.viewDeliveryInterfaces)(deliveryInterfaces),
+  warehousingProvidersCount: acl(actions.viewWarehousingProviders)(warehousingProvidersCount),
+  warehousingProviders: acl(actions.viewWarehousingProviders)(warehousingProviders),
+  warehousingProvider: acl(actions.viewWarehousingProvider)(warehousingProvider),
+  warehousingInterfaces: acl(actions.viewWarehousingInterfaces)(warehousingInterfaces),
+  translatedProductTexts: acl(actions.viewTranslations)(translatedProductTexts),
+  translatedProductMediaTexts: acl(actions.viewTranslations)(translatedProductMediaTexts),
+  translatedProductVariationTexts: acl(actions.viewTranslations)(translatedProductVariationTexts),
+  ordersCount: acl(actions.viewOrders)(ordersCount),
+  orders: acl(actions.viewOrders)(orders),
+  order: acl(actions.viewOrder)(order),
+  assortmentsCount: acl(actions.viewAssortments)(assortmentsCount),
+  assortments: acl(actions.viewAssortments)(assortments),
+  translatedAssortmentMediaTexts: acl(actions.viewAssortment)(translatedAssortmentMediaTexts),
+  assortment: acl(actions.viewAssortment)(assortment),
+  filtersCount: acl(actions.viewFilters)(filtersCount),
+  filters: acl(actions.viewFilters)(filters),
+  filter: acl(actions.viewFilter)(filter),
+  shopInfo: acl(actions.viewShopInfo)(shopInfo),
+  translatedAssortmentTexts: acl(actions.manageAssortments)(translatedAssortmentTexts),
+  translatedFilterTexts: acl(actions.manageFilters)(translatedFilterTexts),
+  productReview: acl(actions.manageProductReviews)(productReview),
+  productReviews: acl(actions.manageProductReviews)(productReviews),
+  productReviewsCount: acl(actions.manageProductReviews)(productReviewsCount),
+  quotation: acl(actions.viewQuotation)(quotation),
+  quotations: acl(actions.viewQuotations)(quotations),
+  quotationsCount: acl(actions.viewQuotations)(quotationsCount),
+  searchProducts: acl(actions.search)(searchProducts),
+  searchAssortments: acl(actions.search)(searchAssortments),
+  workQueue: acl(actions.manageWorker)(workQueue),
+  workQueueCount: acl(actions.manageWorker)(workQueueCount),
+  activeWorkTypes: acl(actions.manageWorker)(activeWorkTypes),
+  enrollment: acl(actions.viewEnrollment)(enrollment),
+  enrollments: acl(actions.viewEnrollments)(enrollments),
+  enrollmentsCount: acl(actions.viewEnrollments)(enrollmentsCount),
+
+  work: acl(actions.manageWorker)(work),
+  event: acl(actions.viewEvent)(event),
+  events: acl(actions.viewEvents)(events),
+  eventsCount: acl(actions.viewEvents)(eventsCount),
+};

package/src/resolvers/queries/languages/language.ts

@@ -0,0 +1,15 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError } from '../../../errors';
+
+export default async function language(
+  root: Root,
+  { languageId }: { languageId: string },
+  { modules, userId }: Context,
+) {
+  log(`query language ${languageId}`, { userId });
+
+  if (!languageId) throw new InvalidIdError({ languageId });
+
+  return modules.languages.findLanguage({ languageId });
+}

package/src/resolvers/queries/languages/languages.ts

@@ -0,0 +1,18 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root, SortOption } from '@unchainedshop/types/api';
+import { LanguageQuery } from '@unchainedshop/types/languages';
+
+export default async function languages(
+  root: Root,
+  params: LanguageQuery & { limit: number; offset: number; sort?: Array<SortOption> },
+  { modules, userId }: Context,
+) {
+  log(
+    `query languages: ${params.limit} ${params.offset} ${
+      params.includeInactive ? 'includeInactive' : ''
+    }`,
+    { userId },
+  );
+
+  return modules.languages.findLanguages(params);
+}

package/src/resolvers/queries/languages/languagesCount.ts

@@ -0,0 +1,15 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { LanguageQuery } from '@unchainedshop/types/languages';
+import { log } from '@unchainedshop/logger';
+
+export default async function languagesCount(
+  root: Root,
+  params: LanguageQuery,
+  { modules, userId }: Context,
+) {
+  log(`query languagesCount:  ${params.includeInactive ? 'includeInactive' : ''}`, {
+    userId,
+  });
+
+  return modules.languages.count(params);
+}

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

@@ -0,0 +1,15 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { InvalidIdError } from '../../../errors';
+
+export default async function order(
+  root: Root,
+  { orderId }: { orderId: string },
+  { modules, userId }: Context,
+) {
+  log(`query order ${orderId}`, { userId, orderId });
+
+  if (!orderId) throw new InvalidIdError({ orderId });
+
+  return modules.orders.findOrder({ orderId });
+}

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

@@ -0,0 +1,17 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { OrderQuery } from '@unchainedshop/types/orders';
+
+export default async function orders(
+  root: Root,
+  params: OrderQuery & { limit?: number; offset?: number },
+  { modules, userId }: Context,
+) {
+  const { includeCarts, limit, offset, queryString } = params;
+
+  log(`query orders: ${limit} ${offset} ${includeCarts} ${queryString}`, {
+    userId,
+  });
+
+  return modules.orders.findOrders(params);
+}

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

@@ -0,0 +1,9 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { OrderQuery } from '@unchainedshop/types/orders';
+
+export default async function ordersCount(root: Root, params: OrderQuery, { modules, userId }: Context) {
+  log(`query ordersCount: ${params.includeCarts ? 'includeCart' : ''}`, { userId });
+
+  return modules.orders.count(params);
+}

package/src/resolvers/queries/payment/paymentInterfaces.ts

@@ -0,0 +1,13 @@
+import { log } from '@unchainedshop/logger';
+import { PaymentProviderType } from '@unchainedshop/types/payments';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function paymentInterfaces(
+  root: Root,
+  { type }: { type: PaymentProviderType },
+  { modules, userId }: Context,
+) {
+  log(`query paymentInterfaces ${type}`, { userId });
+
+  return modules.payment.paymentProviders.findInterfaces({ type });
+}

package/src/resolvers/queries/payment/paymentProvider.ts

@@ -0,0 +1,17 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError } from '../../../errors';
+
+export default async function paymentProvider(
+  root: Root,
+  { paymentProviderId }: { paymentProviderId: string },
+  { modules, userId }: Context,
+) {
+  log(`query paymentProvider ${paymentProviderId}`, { userId });
+
+  if (!paymentProviderId) throw new InvalidIdError({ paymentProviderId });
+
+  return modules.payment.paymentProviders.findProvider({
+    paymentProviderId,
+  });
+}

package/src/resolvers/queries/payment/paymentProviders.ts

@@ -0,0 +1,13 @@
+import { log } from '@unchainedshop/logger';
+import { PaymentProviderQuery } from '@unchainedshop/types/payments';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function paymentProviders(
+  root: Root,
+  params: PaymentProviderQuery,
+  { modules, userId }: Context,
+) {
+  log(`query paymentProvider ${params.type}`, { userId });
+
+  return modules.payment.paymentProviders.findProviders(params);
+}

package/src/resolvers/queries/payment/paymentProvidersCount.ts

@@ -0,0 +1,13 @@
+import { log } from '@unchainedshop/logger';
+import { PaymentProviderQuery } from '@unchainedshop/types/payments';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function paymentProvidersCount(
+  root: Root,
+  params: PaymentProviderQuery,
+  { modules, userId }: Context,
+) {
+  log(`query paymentProvidersCount ${params.type}`, { userId });
+
+  return modules.payment.paymentProviders.count(params);
+}

package/src/resolvers/queries/products/product.ts

@@ -0,0 +1,15 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+import { InvalidIdError } from '../../../errors';
+
+export default async function product(
+  root: Root,
+  { productId, slug }: { productId?: string; slug?: string },
+  { modules, userId }: Context,
+) {
+  log(`query product ${productId} ${slug}`, { userId });
+
+  if (!productId === !slug) throw new InvalidIdError({ productId, slug });
+
+  return modules.products.findProduct({ productId, slug });
+}

package/src/resolvers/queries/products/productCatalogPrices.ts

@@ -0,0 +1,18 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { InvalidIdError } from '../../../errors';
+
+export default async function productCatalogPrices(
+  root: Root,
+  { productId }: { productId: string },
+  { modules, userId }: Context,
+) {
+  log(`query productCatalogPrices ${productId}`, { userId });
+
+  if (!productId) throw new InvalidIdError({ productId });
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) return null;
+
+  return modules.products.prices.catalogPrices(product);
+}

package/src/resolvers/queries/products/productReview.ts

@@ -0,0 +1,15 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { InvalidIdError } from '../../../errors';
+
+export default async function productReview(
+  root: Root,
+  { productReviewId }: { productReviewId: string },
+  { modules, userId }: Context,
+) {
+  log(`query productReview ${productReviewId}`, { userId });
+
+  if (!productReviewId) throw new InvalidIdError({ productReviewId });
+
+  return modules.products.reviews.findProductReview({ productReviewId });
+}

package/src/resolvers/queries/products/productReviews.ts

@@ -0,0 +1,21 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context, SortOption } from '@unchainedshop/types/api';
+
+export default async function productReviews(
+  root: Root,
+  params: {
+    limit: number;
+    offset: number;
+    sort: Array<SortOption>;
+    queryString?: string;
+  },
+  { modules, userId }: Context,
+) {
+  const { limit, offset, queryString } = params;
+
+  log(`query productReviews: ${limit} ${offset} ${queryString || ''}`, {
+    userId,
+  });
+
+  return modules.products.reviews.findProductReviews(params);
+}

package/src/resolvers/queries/products/productReviewsCount.ts

@@ -0,0 +1,13 @@
+import { log } from '@unchainedshop/logger';
+import { Root, Context } from '@unchainedshop/types/api';
+import { ProductReviewQuery } from '@unchainedshop/types/products.reviews';
+
+export default async function productReviewsCount(
+  root: Root,
+  params: ProductReviewQuery,
+  { modules, userId }: Context,
+) {
+  log(`query productReviewsCount`, { userId });
+
+  return modules.products.reviews.count(params);
+}

package/src/resolvers/queries/products/products.ts

@@ -0,0 +1,21 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root, SortOption } from '@unchainedshop/types/api';
+import { ProductQuery } from '@unchainedshop/types/products';
+
+export default async function products(
+  root: Root,
+  params: ProductQuery & {
+    sort: Array<SortOption>;
+    limit: number;
+    offset: number;
+  },
+  { modules, userId }: Context,
+) {
+  log(
+    `query products: ${params.limit} ${params.offset} ${
+      params.includeDrafts ? 'includeDrafts' : ''
+    } ${params.slugs?.join(',')}`,
+    { userId },
+  );
+  return modules.products.findProducts(params);
+}

package/src/resolvers/queries/products/productsCount.ts

@@ -0,0 +1,17 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { ProductQuery } from '@unchainedshop/types/products';
+
+export default async function productsCount(
+  root: Root,
+  params: ProductQuery,
+  { modules, userId }: Context,
+) {
+  log(
+    `query productsCount:  ${params.includeDrafts ? 'includeDrafts' : ''} ${params.slugs?.join(
+      ',',
+    )} queryString: ${params.queryString}`,
+    { userId },
+  );
+  return modules.products.count(params);
+}

package/src/resolvers/queries/products/translatedProductMediaTexts.ts

@@ -0,0 +1,12 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function translatedProductMediaTexts(
+  root: Root,
+  { productMediaId }: { productMediaId: string },
+  { modules, userId }: Context,
+) {
+  log(`query translatedProductMediaTexts ${productMediaId}`, { userId });
+
+  return modules.products.media.texts.findMediaTexts({ productMediaId });
+}

package/src/resolvers/queries/products/translatedProductTexts.ts

@@ -0,0 +1,12 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+
+export default async function translatedProductTexts(
+  root: Root,
+  { productId }: { productId: string },
+  { modules, userId }: Context,
+) {
+  log(`query translatedProductTexts ${productId}`, { userId });
+
+  return modules.products.texts.findTexts({ productId });
+}

package/src/resolvers/queries/products/translatedProductVariationTexts.ts

@@ -0,0 +1,18 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+
+export default async function translatedProductVariationTexts(
+  root: Root,
+  params: { productVariationId: string; productVariationOptionValue?: string },
+  { modules, userId }: Context,
+) {
+  const { productVariationId, productVariationOptionValue } = params;
+  log(`query translatedProductVariationTexts ${productVariationId} ${productVariationOptionValue}`, {
+    userId,
+  });
+
+  return modules.products.variations.texts.findVariationTexts({
+    productVariationId,
+    productVariationOptionValue,
+  });
+}

package/src/resolvers/queries/quotations/quotation.ts

@@ -0,0 +1,15 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { InvalidIdError } from '../../../errors';
+
+export default async function quotation(
+  root: Root,
+  { quotationId }: { quotationId: string },
+  { modules, userId }: Context,
+) {
+  log(`query quotation ${quotationId}`, { userId, quotationId });
+
+  if (!quotationId) throw new InvalidIdError({ quotationId });
+
+  return modules.quotations.findQuotation({ quotationId });
+}

package/src/resolvers/queries/quotations/quotations.ts

@@ -0,0 +1,13 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root, SortOption } from '@unchainedshop/types/api';
+import { QuotationQuery } from '@unchainedshop/types/quotations';
+
+export default async function quotations(
+  root: Root,
+  params: QuotationQuery & { limit?: number; offset?: number; sort?: Array<SortOption> },
+  { modules, userId }: Context,
+) {
+  log(`query quotations: ${params.limit} ${params.offset}`, { userId });
+
+  return modules.quotations.findQuotations(params);
+}

package/src/resolvers/queries/quotations/quotationsCount.ts

@@ -0,0 +1,13 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { QuotationQuery } from '@unchainedshop/types/quotations';
+
+export default async function quotationsCount(
+  root: Root,
+  params: QuotationQuery,
+  { modules, userId }: Context,
+) {
+  log(`query quotationsCount`, { userId });
+
+  return modules.quotations.count(params);
+}

package/src/resolvers/queries/shopInfo.ts

@@ -0,0 +1,17 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { log } from '@unchainedshop/logger';
+
+export default function shopInfo(
+  root: Root,
+  _: never,
+  context: Context,
+): { version?: string; externalLinks: Array<string> } {
+  log('query shopInfo', { userId: context.userId });
+
+  return {
+    version: context.version,
+    externalLinks: JSON.parse(process.env.EXTERNAL_LINKS || '[]'),
+  };
+}
+
+//

package/src/resolvers/queries/users/me.ts

@@ -0,0 +1,8 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function me(root: Root, params: any, { userId, user, remoteAddress }: Context) {
+  log(`query me ${remoteAddress}`, { userId });
+
+  return user;
+}

package/src/resolvers/queries/users/user.ts

@@ -0,0 +1,11 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+
+export default async function user(
+  root: Root,
+  params: { userId?: string },
+  { modules, userId }: Context,
+) {
+  log(`query user ${params.userId}`, { Id: userId });
+  return modules.users.findUserById(params.userId || userId);
+}

package/src/resolvers/queries/users/users.ts

@@ -0,0 +1,23 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { UserQuery } from '@unchainedshop/types/user';
+
+export default async function users(
+  root: Root,
+  params: UserQuery & {
+    limit?: number;
+    offset?: number;
+  },
+  { modules, userId }: Context,
+) {
+  log(
+    `query users ${params.limit} ${params.offset} ${params.queryString} ${
+      params.includeGuests ? 'includeGuests' : ''
+    }`,
+    {
+      userId,
+    },
+  );
+
+  return modules.users.findUsers(params);
+}

package/src/resolvers/queries/users/usersCount.ts

@@ -0,0 +1,11 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { UserQuery } from '@unchainedshop/types/user';
+
+export default async function usersCount(root: Root, params: UserQuery, { modules, userId }: Context) {
+  log(`query usersCount ${params.queryString || ''} ${params.includeGuests ? 'includeGuests' : ''}`, {
+    userId,
+  });
+
+  return modules.users.count(params);
+}

package/src/resolvers/queries/warehousing/warehousingInterfaces.ts

@@ -0,0 +1,13 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { WarehousingProviderType } from '@unchainedshop/types/warehousing';
+import { log } from '@unchainedshop/logger';
+
+export default async function warehousingInterfaces(
+  root: Root,
+  params: { type: WarehousingProviderType },
+  { modules, userId }: Context,
+) {
+  log(`query warehousingInterfaces ${params.type}`, { userId });
+
+  return modules.warehousing.findInterfaces(params);
+}

package/src/resolvers/queries/warehousing/warehousingProvider.ts

@@ -0,0 +1,17 @@
+import { log } from '@unchainedshop/logger';
+import { Context, Root } from '@unchainedshop/types/api';
+import { InvalidIdError } from '../../../errors';
+
+export default async function warehousingProvider(
+  root: Root,
+  { warehousingProviderId }: { warehousingProviderId: string },
+  { modules, userId }: Context,
+) {
+  log(`query warehousingProvider ${warehousingProviderId}`, { userId });
+
+  if (!warehousingProviderId) throw new InvalidIdError({ warehousingProviderId });
+
+  return modules.warehousing.findProvider({
+    warehousingProviderId,
+  });
+}

package/src/resolvers/queries/warehousing/warehousingProviders.ts

@@ -0,0 +1,13 @@
+import { Context, Root } from '@unchainedshop/types/api';
+import { WarehousingProviderQuery } from '@unchainedshop/types/warehousing';
+import { log } from '@unchainedshop/logger';
+
+export default async function warehousingProviders(
+  root: Root,
+  params: WarehousingProviderQuery,
+  { modules, userId }: Context,
+) {
+  log(`query warehousingProviders ${params.type}`, { userId });
+
+  return modules.warehousing.findProviders(params);
+}