@unchainedshop/api 3.0.0-alpha7 → 3.0.0-rc10

package/src/resolvers/type/assortment/assortment-types.ts

@@ -1,66 +1,30 @@
-import { Context } from '../../../types.js';
-import {
-  Assortment as AssortmentType,
-  AssortmentFilter,
-  AssortmentLink,
-  AssortmentPathLink,
-  AssortmentProduct,
-  AssortmentText,
-} from '@unchainedshop/core-assortments';
-import { AssortmentMediaType } from '@unchainedshop/core-assortments';
-import { SearchFilterQuery, SearchProducts } from '@unchainedshop/core-filters';
+import { Context } from '../../../context.js';
+import { Assortment } from '@unchainedshop/core-assortments';
+import { SearchFilterQuery } from '@unchainedshop/core-filters';
 
-type HelperType<P, T> = (assortment: AssortmentType, params: P, context: Context) => T;
-
-export interface AssortmentHelperTypes {
-  assortmentPaths: HelperType<never, Promise<Array<{ links: Array<AssortmentPathLink> }>>>;
-
-  children: HelperType<{ includeInactive: boolean }, Promise<Array<AssortmentType>>>;
-  childrenCount: HelperType<{ includeInactive: boolean }, Promise<number>>;
-
-  filterAssignments: HelperType<never, Promise<Array<AssortmentFilter>>>;
-  linkedAssortments: HelperType<never, Promise<Array<AssortmentLink>>>;
-
-  media: HelperType<
-    {
-      limit: number;
-      offset: number;
-      tags?: Array<string>;
-    },
-    Promise<Array<AssortmentMediaType>>
-  >;
-
-  productAssignments: HelperType<never, Promise<Array<AssortmentProduct>>>;
-
-  searchProducts: HelperType<
-    {
-      queryString?: string;
-      filterQuery?: SearchFilterQuery;
-      includeInactive: boolean;
-      ignoreChildAssortments: boolean;
-      orderBy?: string;
-    },
-    Promise<SearchProducts>
-  >;
-
-  texts: HelperType<{ forceLocale?: string }, Promise<AssortmentText>>;
-}
-
-export const Assortment: AssortmentHelperTypes = {
-  assortmentPaths: (obj, _, { modules }) => {
+export const AssortmentTypes = {
+  assortmentPaths: (obj: Assortment, _, { modules }: Context) => {
     return modules.assortments.breadcrumbs({
       assortmentId: obj._id,
     });
   },
 
-  children: async (obj, { includeInactive }, { modules }) => {
+  children: async (
+    obj: Assortment,
+    { includeInactive }: { includeInactive: boolean },
+    { modules }: Context,
+  ) => {
     return modules.assortments.children({
       assortmentId: obj._id,
       includeInactive,
     });
   },
 
-  childrenCount: async (assortment, { includeInactive = false }, { modules, loaders }) => {
+  childrenCount: async (
+    assortment: Assortment,
+    { includeInactive = false }: { includeInactive: boolean },
+    { modules, loaders }: Context,
+  ) => {
     const assortmentChildLinks = await loaders.assortmentLinksLoader.load({
       parentAssortmentId: assortment._id,
     });
@@ -74,7 +38,7 @@ export const Assortment: AssortmentHelperTypes = {
     });
   },
 
-  filterAssignments: async (obj, _, { modules }) => {
+  filterAssignments: async (obj: Assortment, _, { modules }: Context) => {
     // TODO: Loader & move default sort to module
     return modules.assortments.filters.findFilters(
       {
@@ -86,21 +50,34 @@ export const Assortment: AssortmentHelperTypes = {
     );
   },
 
-  async linkedAssortments(assortment, _, { loaders }) {
+  async linkedAssortments(assortment: Assortment, _, { loaders }: Context) {
     return loaders.assortmentLinksLoader.load({
       assortmentId: assortment._id,
     });
   },
 
-  // TODO: Use a loader!
-  async media(obj, params, { modules }) {
-    return modules.assortments.media.findAssortmentMedias({
-      assortmentId: obj._id,
-      ...params,
-    });
+  async media(
+    obj: Assortment,
+    params: {
+      limit: number;
+      offset: number;
+      tags?: Array<string>;
+    },
+    { modules, loaders }: Context,
+  ) {
+    if (params.offset || params.tags) {
+      return modules.assortments.media.findAssortmentMedias({
+        assortmentId: obj._id,
+        ...params,
+      });
+    }
+    return (await loaders.assortmentMediasLoader.load({ assortmentId: obj._id })).slice(
+      params.offset,
+      params.offset + params.limit,
+    );
   },
 
-  async productAssignments(obj, _, { modules }) {
+  async productAssignments(obj: Assortment, _, { modules }: Context) {
     // TODO: Loader & move default sort to core module
     return modules.assortments.products.findProducts(
       {
@@ -112,7 +89,7 @@ export const Assortment: AssortmentHelperTypes = {
     );
   },
 
-  async texts(obj, { forceLocale }, requestContext) {
+  async texts(obj: Assortment, { forceLocale }: { forceLocale?: string }, requestContext: Context) {
     const { localeContext, loaders } = requestContext;
     return loaders.assortmentTextLoader.load({
       assortmentId: obj._id,
@@ -120,19 +97,26 @@ export const Assortment: AssortmentHelperTypes = {
     });
   },
 
-  searchProducts: async (obj, query, context) => {
-    const productIds = await context.modules.assortments.findProductIds({
+  searchProducts: async (
+    obj: Assortment,
+    query: {
+      queryString?: string;
+      filterQuery?: SearchFilterQuery;
+      includeInactive: boolean;
+      ignoreChildAssortments: boolean;
+      orderBy?: string;
+    },
+    requestContext: Context,
+  ) => {
+    const { modules, services } = requestContext;
+    const productIds = await modules.assortments.findProductIds({
       assortmentId: obj._id,
       ignoreChildAssortments: query.ignoreChildAssortments,
     });
 
-    const filterIds = await context.modules.assortments.filters.findFilterIds({
+    const filterIds = await modules.assortments.filters.findFilterIds({
       assortmentId: obj._id,
     });
-    return context.modules.filters.search.searchProducts(
-      { ...query, productIds, filterIds },
-      {},
-      context,
-    );
+    return services.filters.searchProducts({ ...query, productIds, filterIds }, {});
   },
 };

package/src/resolvers/type/bookmark-types.ts

@@ -1,8 +1,8 @@
-import type { Bookmark as BookmarkType } from '@unchainedshop/core-bookmarks';
-import type { Product } from '@unchainedshop/core-products';
-import type { User } from '@unchainedshop/core-users';
+import { Bookmark as BookmarkType } from '@unchainedshop/core-bookmarks';
+import { Product } from '@unchainedshop/core-products';
+import { User } from '@unchainedshop/core-users';
 
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../context.js';
 
 export type HelperType<T> = (bookmark: BookmarkType, _: never, context: Context) => T;
 

package/src/resolvers/type/country-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../context.js';
 import { Country as CountryType } from '@unchainedshop/core-countries';
 import { Currency } from '@unchainedshop/core-currencies';
 

package/src/resolvers/type/delivery-provider-types.ts

@@ -1,7 +1,6 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
-import { DeliveryError, DeliveryProvider as DeliveryProviderType } from '@unchainedshop/core-delivery';
-import { DeliveryPricingDirector } from '@unchainedshop/core-delivery';
+import { Context } from '../../context.js';
+import { DeliveryProvider as DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { DeliveryDirector, DeliveryError, DeliveryPricingDirector } from '@unchainedshop/core';
 
 export type HelperType<P, T> = (provider: DeliveryProviderType, params: P, context: Context) => T;
 
@@ -24,7 +23,6 @@ export interface DeliveryProviderHelperTypes {
       context: any;
     },
     Promise<{
-      _id: string;
       amount: number;
       currencyCode: string;
       countryCode: string;
@@ -35,20 +33,24 @@ export interface DeliveryProviderHelperTypes {
 }
 
 export const DeliveryProvider: DeliveryProviderHelperTypes = {
-  interface(obj, _, { modules }) {
-    const Interface = modules.delivery.findInterface(obj);
-    if (!Interface) return null;
-    return Interface;
+  interface(deliveryProvider) {
+    const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
+    if (!Adapter) return null;
+    return {
+      _id: Adapter.key,
+      label: Adapter.label,
+      version: Adapter.version,
+    };
   },
 
   async isActive(deliveryProvider, _, requestContext) {
-    const { modules } = requestContext;
-    return modules.delivery.isActive(deliveryProvider, requestContext);
+    const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
+    return Boolean(director.isActive());
   },
 
   async configurationError(deliveryProvider, _, requestContext) {
-    const { modules } = requestContext;
-    return modules.delivery.configurationError(deliveryProvider, requestContext);
+    const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
+    return director.configurationError();
   },
 
   async simulatedPrice(
@@ -58,24 +60,21 @@ export const DeliveryProvider: DeliveryProviderHelperTypes = {
   ) {
     const { modules, countryContext: country, user } = requestContext;
     const order = await modules.orders.findOrder({ orderId });
-    const currency = currencyCode || requestContext.currencyContext;
+    const currency = currencyCode || order?.currency || requestContext.currencyContext;
+    const pricingContext = {
+      country,
+      currency,
+      provider: deliveryProvider,
+      order,
+      providerContext,
+      user,
+    };
 
-    const pricingDirector = await DeliveryPricingDirector.actions(
-      {
-        country,
-        currency,
-        provider: deliveryProvider,
-        order,
-        providerContext,
-        user,
-      },
-      requestContext,
-    );
+    const calculated = await DeliveryPricingDirector.rebuildCalculation(pricingContext, requestContext);
 
-    const calculated = await pricingDirector.calculate();
     if (!calculated || !calculated.length) return null;
 
-    const pricing = pricingDirector.calculationSheet();
+    const pricing = DeliveryPricingDirector.calculationSheet(pricingContext, calculated);
 
     const orderPrice = pricing.total({ useNetPrice }) as {
       amount: number;
@@ -83,10 +82,6 @@ export const DeliveryProvider: DeliveryProviderHelperTypes = {
     };
 
     return {
-      _id: crypto
-        .createHash('sha256')
-        .update([deliveryProvider._id, country, useNetPrice, order ? order._id : ''].join(''))
-        .digest('hex'),
       amount: orderPrice.amount,
       currencyCode: orderPrice.currency,
       countryCode: country,

package/src/resolvers/type/enrollment/enrollment-delivery-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 

package/src/resolvers/type/enrollment/enrollment-payment-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { PaymentProvider } from '@unchainedshop/core-payment';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 

package/src/resolvers/type/enrollment/enrollment-period-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { EnrollmentPeriod as EnrollmentPeriodType } from '@unchainedshop/core-enrollments';
 import { Order } from '@unchainedshop/core-orders';
 

package/src/resolvers/type/enrollment/enrollment-plan-tyes.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { EnrollmentPlan as EnrollmentPlanType } from '@unchainedshop/core-enrollments';
 import { Product } from '@unchainedshop/core-products';
 

package/src/resolvers/type/enrollment/enrollment-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Country } from '@unchainedshop/core-countries';
 import { Currency } from '@unchainedshop/core-currencies';
 import { Enrollment as EnrollmentType, EnrollmentPlan } from '@unchainedshop/core-enrollments';

package/src/resolvers/type/event-types.ts

@@ -1,5 +1,5 @@
-import { Context } from '@unchainedshop/api';
-import type { Event as EventType } from '@unchainedshop/core-events';
+import { Context } from '../../context.js';
+import { Event as EventType } from '@unchainedshop/core-events';
 
 export type HelperType<P, T> = (work: EventType, params: P, context: Context) => T;
 

package/src/resolvers/type/filter/filter-option-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { FilterOption as FilterOptionType, FilterText } from '@unchainedshop/core-filters';
 
 type HelperType<P, T> = (filterOption: FilterOptionType, params: P, context: Context) => T;

package/src/resolvers/type/filter/filter-types.ts

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Filter as FilterType, FilterOption, FilterText } from '@unchainedshop/core-filters';
 
 type HelperType<P, T> = (filter: FilterType, params: P, context: Context) => T;

package/src/resolvers/type/filter/loaded-filter-option-types.ts

@@ -1 +1,18 @@
-export const LoadedFilterOption = {};
+import { FilterDirector } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
+
+export const LoadedFilterOption = {
+  filteredProductsCount: async ({ filteredProductIdSet, searchQuery }, _: never, context: Context) => {
+    if (!filteredProductIdSet?.size) {
+      return 0;
+    }
+    const filterActions = await FilterDirector.actions({ searchQuery }, context);
+    return filterActions.aggregateProductIds({
+      productIds: Array.from(filteredProductIdSet),
+    }).length;
+  },
+
+  definition: ({ filter, value }) => {
+    return { filterOption: value, ...filter };
+  },
+};

package/src/resolvers/type/filter/loaded-filter-types.ts

@@ -1 +1,58 @@
-export const LoadedFilter = {};
+import { Context } from '../../../context.js';
+import { Filter, SearchQuery } from '@unchainedshop/core-filters';
+import { FilterDirector } from '@unchainedshop/core';
+
+type LoadedFilterData = {
+  forceLiveCollection: boolean;
+  searchQuery: SearchQuery;
+  filter: Filter;
+  examinedProductIdSet: Set<string>;
+  filteredByOtherFiltersSet: Set<string>;
+  filteredByThisFilterSet: Set<string>;
+};
+
+export const LoadedFilter = {
+  definition: ({ filter }: LoadedFilterData) => {
+    return filter;
+  },
+  isSelected: ({ searchQuery, filter }: LoadedFilterData) => {
+    return searchQuery?.filterQuery?.some((q) => q.key === filter.key);
+  },
+  filteredProductsCount: async (
+    { filteredByOtherFiltersSet, filteredByThisFilterSet, searchQuery }: LoadedFilterData,
+    _: never,
+    context: Context,
+  ) => {
+    const filterActions = await FilterDirector.actions({ searchQuery }, context);
+    return filterActions.aggregateProductIds({
+      productIds: Array.from(filteredByOtherFiltersSet.intersection(filteredByThisFilterSet)),
+    }).length;
+  },
+  productsCount: async (
+    { examinedProductIdSet, searchQuery }: LoadedFilterData,
+    _: never,
+    context: Context,
+  ) => {
+    const filterActions = await FilterDirector.actions({ searchQuery }, context);
+    return filterActions.aggregateProductIds({
+      productIds: Array.from(examinedProductIdSet),
+    }).length;
+  },
+  options: async (
+    { filter, filteredByOtherFiltersSet, forceLiveCollection, searchQuery }: LoadedFilterData,
+    _: never,
+    context: Context,
+  ) => {
+    const { services } = context;
+    // The current base for options should be an array of product id's that:
+    // - Are part of the preselected product id array
+    // - Fit this filter generally
+    // - Are filtered by all other filters
+    // - Are not filtered by the currently selected value of this filter
+    return services.filters.loadFilterOptions(filter, {
+      searchQuery,
+      forceLiveCollection,
+      productIdSet: filteredByOtherFiltersSet,
+    });
+  },
+};

package/src/resolvers/type/index.ts

@@ -1,4 +1,4 @@
-import { Assortment } from './assortment/assortment-types.js';
+import { AssortmentTypes as Assortment } from './assortment/assortment-types.js';
 import { AssortmentFilter } from './assortment/assortment-filter-types.js';
 import { AssortmentLink } from './assortment/assortment-link-types.js';
 import { AssortmentMedia } from './assortment/assortment-media-types.js';
@@ -12,7 +12,6 @@ import { Country } from './country-types.js';
 import { Currency } from './currency-types.js';
 import { DeliveryProvider } from './delivery-provider-types.js';
 import { Dimensions } from './dimensions-types.js';
-import { Dispatch } from './dispatch-types.js';
 import { Enrollment } from './enrollment/enrollment-types.js';
 import { EnrollmentDelivery } from './enrollment/enrollment-delivery-types.js';
 import { EnrollmentPayment } from './enrollment/enrollment-payment-types.js';
@@ -57,7 +56,6 @@ import { Quotation } from './quotation-types.js';
 import { Shop } from './shop-types.js';
 import { SimpleProduct } from './product/product-simple-types.js';
 import { TokenizedProduct } from './product/product-tokenized-types.js';
-import { Stock } from './stock-types.js';
 import { User } from './user-types.js';
 import { WebAuthnCredentials } from './webauthn-credentials-types.js';
 import { WarehousingProvider } from './warehousing-provider-types.js';
@@ -67,6 +65,7 @@ import { Media } from './media-types.js';
 import { Token } from './token-types.js';
 import { Web3Address } from './web3-address.js';
 import { LoginMethodResponse } from './login-method-response-types.js';
+import { ProductSearchResult } from './product-search-result-types.js';
 
 const types = {
   Assortment,
@@ -83,7 +82,6 @@ const types = {
   Currency,
   DeliveryProvider,
   Dimensions,
-  Dispatch,
   Enrollment,
   EnrollmentDelivery,
   EnrollmentPayment,
@@ -124,12 +122,12 @@ const types = {
   ProductVariationAssignment,
   ProductVariationAssignmentVector,
   ProductVariationOption,
+  ProductSearchResult,
   Quotation,
   Shop,
   SimpleProduct,
   TokenizedProduct,
   Token,
-  Stock,
   User,
   WebAuthnCredentials,
   WarehousingProvider,

package/src/resolvers/type/language-types.ts

@@ -1,5 +1,5 @@
 import { Language as LanguageType } from '@unchainedshop/core-languages';
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../context.js';
 
 export interface LanguageHelperTypes {
   isBase: (language: LanguageType, params: never, context: Context) => boolean;

package/src/resolvers/type/media-types.ts

@@ -1,12 +1,23 @@
-import { File as FileType } from '@unchainedshop/core-files';
-import { Context } from '@unchainedshop/api';
-
+import { File as FileType, getFileAdapter } from '@unchainedshop/core-files';
+import { Context } from '../../context.js';
+import { checkAction } from '../../acl.js';
+import { actions } from '../../roles/index.js';
 export interface MediaHelperTypes {
-  url: (language: FileType, params: Record<string, any>, context: Context) => string;
+  url: (language: FileType, params: Record<string, any>, context: Context) => Promise<string>;
 }
 
 export const Media: MediaHelperTypes = {
-  url(root, params, { modules }) {
-    return modules.files.getUrl(root, params);
+  url: async (file, params, context) => {
+    const { modules } = context;
+    try {
+      await checkAction(context, actions.downloadFile, [file, params]);
+      if (!file) return null;
+      const fileUploadAdapter = getFileAdapter();
+      const url = await fileUploadAdapter.createDownloadURL(file, params?.expires);
+      return modules.files.normalizeUrl(url, params);
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
   },
 };

package/src/resolvers/type/order/order-delivery-discount-types.ts

@@ -1,36 +1,19 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
-import {
-  OrderDiscount,
-  OrderPrice,
-  OrderDeliveryDiscount as OrderDeliveryDiscountType,
-} from '@unchainedshop/core-orders';
+import { Context } from '../../../context.js';
+import { OrderDeliveryDiscount as OrderDeliveryDiscountType } from '@unchainedshop/core-orders';
 
-type HelperType<P, T> = (orderDelivery: OrderDeliveryDiscountType, params: P, context: Context) => T;
-
-export interface OrderDeliveryDiscountHelperTypes {
-  _id: HelperType<never, string>;
-  orderDiscount: HelperType<never, Promise<OrderDiscount>>;
-  total: HelperType<never, OrderPrice>;
-}
-
-export const OrderDeliveryDiscount: OrderDeliveryDiscountHelperTypes = {
-  _id(obj) {
+export const OrderDeliveryDiscount = {
+  _id(obj: OrderDeliveryDiscountType) {
     return `${obj.item._id}:${obj.discountId}`;
   },
 
-  orderDiscount: async (obj, _, { modules }) => {
+  orderDiscount: async (obj: OrderDeliveryDiscountType, _, { modules }: Context) => {
     return modules.orders.discounts.findOrderDiscount({
       discountId: obj.discountId,
     });
   },
 
-  total(obj) {
+  total(obj: OrderDeliveryDiscountType) {
     return {
-      _id: crypto
-        .createHash('sha256')
-        .update([`${obj.item._id}:${obj.discountId}`, obj.amount, obj.currency].join(''))
-        .digest('hex'),
       amount: obj.amount,
       currency: obj.currency,
     };

package/src/resolvers/type/order/order-delivery-pickup-types.ts

@@ -1,7 +1,7 @@
-import { Context } from '@unchainedshop/api';
+import { DeliveryDirector, DeliveryPricingSheet } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import { DeliveryLocation, DeliveryProvider } from '@unchainedshop/core-delivery';
 import { OrderDelivery, OrderDeliveryDiscount } from '@unchainedshop/core-orders';
-import { DeliveryDirector } from '@unchainedshop/core-delivery';
 
 type HelperType<T> = (orderDelivery: OrderDelivery, _: never, context: Context) => T;
 
@@ -14,9 +14,19 @@ export interface OrderDeliveryPickupHelperTypes {
 }
 
 export const OrderDeliveryPickUp: OrderDeliveryPickupHelperTypes = {
-  activePickUpLocation: async (obj, _, context) => {
-    const { modules } = context;
-    return modules.orders.deliveries.activePickUpLocation(obj, context);
+  activePickUpLocation: async (orderDelivery, _, requestContext) => {
+    const { orderPickUpLocationId } = orderDelivery.context || {};
+
+    const provider = await requestContext.modules.delivery.findProvider({
+      deliveryProviderId: orderDelivery.deliveryProviderId,
+    });
+    const director = await DeliveryDirector.actions(
+      provider,
+      { orderDelivery: orderDelivery },
+      requestContext,
+    );
+
+    return director.pickUpLocationById(orderPickUpLocationId);
   },
 
   pickUpLocations: async (obj, _, context) => {
@@ -41,10 +51,15 @@ export const OrderDeliveryPickUp: OrderDeliveryPickupHelperTypes = {
   discounts: async (obj, _, context) => {
     const { modules } = context;
     const order = await modules.orders.findOrder({ orderId: obj.orderId });
-    const pricingSheet = modules.orders.deliveries.pricingSheet(obj, order.currency, context);
-    if (pricingSheet.isValid()) {
+
+    const pricing = DeliveryPricingSheet({
+      calculation: obj.calculation,
+      currency: order.currency,
+    });
+
+    if (pricing.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!
-      return pricingSheet.discountPrices().map((discount) => ({
+      return pricing.discountPrices().map((discount) => ({
         item: obj,
         ...discount,
       }));

package/src/resolvers/type/order/order-delivery-shipping-types.ts

@@ -1,7 +1,8 @@
-import { Context } from '@unchainedshop/api';
+import { DeliveryPricingSheet } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { OrderDelivery, OrderDeliveryDiscount } from '@unchainedshop/core-orders';
-import type { Address } from '@unchainedshop/mongodb';
+import { Address } from '@unchainedshop/mongodb';
 
 type HelperType<T> = (orderDelivery: OrderDelivery, _: never, context: Context) => T;
 
@@ -30,10 +31,13 @@ export const OrderDeliveryShipping: OrderDeliveryShippingHelperTypes = {
   discounts: async (obj, _, context) => {
     const { modules } = context;
     const order = await modules.orders.findOrder({ orderId: obj.orderId });
-    const pricingSheet = modules.orders.deliveries.pricingSheet(obj, order.currency, context);
-    if (pricingSheet.isValid()) {
+    const pricing = DeliveryPricingSheet({
+      calculation: obj.calculation,
+      currency: order.currency,
+    });
+    if (pricing.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!
-      return pricingSheet.discountPrices().map((discount) => ({
+      return pricing.discountPrices().map((discount) => ({
         item: obj,
         ...discount,
       }));

package/src/resolvers/type/order/order-delivery-types.ts

@@ -1,7 +1,7 @@
 import { OrderDelivery as OrderDeliveryType } from '@unchainedshop/core-orders';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 import { objectInvert } from '@unchainedshop/utils';
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 
 const OrderDeliveryMap = {
   OrderDeliveryShipping: DeliveryProviderType.SHIPPING,