@unchainedshop/api 3.1.10 → 4.0.0-rc.2

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

@@ -1,16 +1,8 @@
 import { Context } from '../../../context.js';
 import { EnrollmentPeriod as EnrollmentPeriodType } from '@unchainedshop/core-enrollments';
-import { Order } from '@unchainedshop/core-orders';
 
-type HelperType<T> = (enrollmentPeriod: EnrollmentPeriodType, _: never, context: Context) => T;
-
-type EnrollmentPeriodHelperTypes = {
-  order: HelperType<Promise<Order>>;
-};
-
-export const EnrollmentPeriod: EnrollmentPeriodHelperTypes = {
-  order: async (period, _, { modules }) => {
-    // TODO: use loader
-    return modules.orders.findOrder({ orderId: period.orderId });
+export const EnrollmentPeriod = {
+  async order(period: EnrollmentPeriodType, _: never, { loaders }: Context) {
+    return loaders.orderLoader.load({ orderId: period.orderId });
   },
 };

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

@@ -1,18 +1,10 @@
 import { Context } from '../../../context.js';
 import { EnrollmentPlan as EnrollmentPlanType } from '@unchainedshop/core-enrollments';
-import { Product } from '@unchainedshop/core-products';
 
-type HelperType<T> = (enrollmentPlan: EnrollmentPlanType, _: never, context: Context) => T;
-
-type EnrollmentPlanHelperTypes = {
-  product: HelperType<Promise<Product>>;
-};
-
-export const EnrollmentPlan: EnrollmentPlanHelperTypes = {
-  product: async (plan, _, { loaders }) => {
-    const product = await loaders.productLoader.load({
+export const EnrollmentPlan = {
+  async product(plan: EnrollmentPlanType, _: never, { loaders }: Context) {
+    return loaders.productLoader.load({
       productId: plan.productId,
     });
-    return product;
   },
 };

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

@@ -1,25 +1,12 @@
 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';
-import { User } from '@unchainedshop/core-users';
+import { Enrollment as EnrollmentType } from '@unchainedshop/core-enrollments';
 
-type HelperType<P, T> = (enrollment: EnrollmentType, params: P, context: Context) => T;
-
-type EnrollmentHelperTypes = {
-  isExpired: HelperType<{ referenceDate?: Date }, boolean>;
-  plan: HelperType<never, EnrollmentPlan>;
-  user: HelperType<never, Promise<User>>;
-  country: HelperType<never, Promise<Country>>;
-  currency: HelperType<never, Promise<Currency>>;
-};
-
-export const Enrollment: EnrollmentHelperTypes = {
-  isExpired: (obj, params, { modules }) => {
+export const Enrollment = {
+  isExpired: (obj: EnrollmentType, params: { referenceDate?: Date }, { modules }: Context) => {
     return modules.enrollments.isExpired(obj, params);
   },
 
-  plan: ({ quantity, productId, configuration }) => {
+  plan: ({ quantity, productId, configuration }: EnrollmentType) => {
     return {
       quantity,
       productId,
@@ -27,12 +14,10 @@ export const Enrollment: EnrollmentHelperTypes = {
     };
   },
 
-  // TODO: use loader
-  country: (obj, _, { modules }) => modules.countries.findCountry({ isoCode: obj.countryCode }),
-
-  // TODO: use loader
-  currency: (obj, _, { modules }) => modules.currencies.findCurrency({ isoCode: obj.currencyCode }),
-
-  // TODO: use loader
-  user: (obj, _, { modules }) => modules.users.findUserById(obj.userId),
+  country: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
+    loaders.currencyLoader.load({ isoCode: obj.countryCode }),
+  currency: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
+    loaders.currencyLoader.load({ isoCode: obj.currencyCode }),
+  user: async (obj: EnrollmentType, _: never, { loaders }: Context) =>
+    loaders.userLoader.load({ userId: obj.userId }),
 };

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

@@ -1,29 +1,24 @@
 import { Context } from '../../../context.js';
-import { FilterOption as FilterOptionType, FilterText } from '@unchainedshop/core-filters';
+import { FilterOption as FilterOptionType } from '@unchainedshop/core-filters';
 
-type HelperType<P, T> = (filterOption: FilterOptionType, params: P, context: Context) => T;
-
-type FilterOptionHelperTypes = {
-  _id: HelperType<never, string>;
-  texts: HelperType<{ forceLocale?: string }, Promise<FilterText>>;
-  value: HelperType<never, string>;
-};
-
-export const FilterOption: FilterOptionHelperTypes = {
-  _id(obj) {
+export const FilterOption = {
+  _id(obj: FilterOptionType) {
     return `${obj._id}:${obj.filterOption}`;
   },
 
-  value(obj) {
+  value(obj: FilterOptionType) {
     return obj.filterOption;
   },
 
-  async texts(obj, { forceLocale }, requestContext) {
-    const { localeContext, loaders } = requestContext;
+  async texts(
+    obj: FilterOptionType,
+    { forceLocale }: { forceLocale?: string },
+    { locale, loaders }: Context,
+  ) {
     return loaders.filterTextLoader.load({
       filterId: obj._id,
       filterOptionValue: obj.filterOption,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 };

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

@@ -1,27 +1,19 @@
 import { Context } from '../../../context.js';
-import { Filter as FilterType, FilterOption, FilterText } from '@unchainedshop/core-filters';
+import { Filter as FilterType } from '@unchainedshop/core-filters';
 
-type HelperType<P, T> = (filter: FilterType, params: P, context: Context) => T;
-
-type FilterHelperTypes = {
-  options: HelperType<never, Array<FilterOption>>;
-  texts: HelperType<{ forceLocale?: string }, Promise<FilterText>>;
-};
-
-export const Filter: FilterHelperTypes = {
-  options: (obj) => {
+export const Filter = {
+  options: (obj: FilterType) => {
     return (obj.options || []).map((filterOption) => ({
       ...obj,
       filterOption,
     }));
   },
 
-  async texts(obj, { forceLocale }, requestContext) {
-    const { localeContext, loaders } = requestContext;
+  async texts(obj: FilterType, { forceLocale }: { forceLocale?: string }, { locale, loaders }: Context) {
     return loaders.filterTextLoader.load({
       filterId: obj._id,
       filterOptionValue: null,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 };

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

@@ -2,14 +2,14 @@ import { Context } from '../../../context.js';
 import { Filter, SearchQuery } from '@unchainedshop/core-filters';
 import { FilterDirector } from '@unchainedshop/core';
 
-type LoadedFilterData = {
+export interface LoadedFilterData {
   forceLiveCollection: boolean;
   searchQuery: SearchQuery;
   filter: Filter;
   examinedProductIdSet: Set<string>;
   filteredByOtherFiltersSet: Set<string>;
   filteredByThisFilterSet: Set<string>;
-};
+}
 
 export const LoadedFilter = {
   definition: ({ filter }: LoadedFilterData) => {

package/src/resolvers/type/login-method-response-types.ts

@@ -1,6 +1,6 @@
 export const LoginMethodResponse = {
   user({ user }) {
-    user._inLoginMethodResponse = true; // eslint-disable-line
+    user._inLoginMethodResponse = true;
     return user;
   },
 };

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

@@ -7,7 +7,6 @@ export const OrderDeliveryDiscount = {
   },
 
   orderDiscount: async (obj: OrderDeliveryDiscountType, _, { modules }: Context) => {
-    // TODO: use loader
     return modules.orders.discounts.findOrderDiscount({
       discountId: obj.discountId,
     });
@@ -16,7 +15,7 @@ export const OrderDeliveryDiscount = {
   total(obj: OrderDeliveryDiscountType) {
     return {
       amount: obj.amount,
-      currency: obj.currency,
+      currencyCode: obj.currencyCode,
     };
   },
 };

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

@@ -1,24 +1,12 @@
 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 { OrderDelivery } from '@unchainedshop/core-orders';
 
-type HelperType<T> = (orderDelivery: OrderDelivery, _: never, context: Context) => T;
-
-export interface OrderDeliveryPickupHelperTypes {
-  activePickUpLocation: HelperType<Promise<DeliveryLocation>>;
-  discounts: HelperType<Promise<Array<OrderDeliveryDiscount>>>;
-  pickUpLocations: HelperType<Promise<Array<DeliveryLocation>>>;
-  provider: HelperType<Promise<DeliveryProvider>>;
-  status: HelperType<string>;
-}
-
-export const OrderDeliveryPickUp: OrderDeliveryPickupHelperTypes = {
-  activePickUpLocation: async (orderDelivery, _, requestContext) => {
+export const OrderDeliveryPickUp = {
+  async activePickUpLocation(orderDelivery: OrderDelivery, _: never, requestContext: Context) {
     const { orderPickUpLocationId } = orderDelivery.context || {};
 
-    // TODO: use loader
-    const provider = await requestContext.modules.delivery.findProvider({
+    const provider = await requestContext.loaders.deliveryProviderLoader.load({
       deliveryProviderId: orderDelivery.deliveryProviderId,
     });
     const director = await DeliveryDirector.actions(
@@ -30,9 +18,8 @@ export const OrderDeliveryPickUp: OrderDeliveryPickupHelperTypes = {
     return director.pickUpLocationById(orderPickUpLocationId);
   },
 
-  pickUpLocations: async (obj, _, context) => {
-    // TODO: use loader
-    const provider = await context.modules.delivery.findProvider({
+  async pickUpLocations(obj: OrderDelivery, _: never, context: Context) {
+    const provider = await context.loaders.deliveryProviderLoader.load({
       deliveryProviderId: obj.deliveryProviderId,
     });
     const director = await DeliveryDirector.actions(provider, { orderDelivery: obj }, context);
@@ -40,24 +27,21 @@ export const OrderDeliveryPickUp: OrderDeliveryPickupHelperTypes = {
     return director.pickUpLocations();
   },
 
-  provider: async (obj, _, { modules }) => {
-    return modules.delivery.findProvider({
+  async provider(obj: OrderDelivery, _: never, { loaders }: Context) {
+    return loaders.deliveryProviderLoader.load({
       deliveryProviderId: obj.deliveryProviderId,
     });
   },
 
-  status: (obj, _, { modules }) => {
+  status(obj: OrderDelivery, _: never, { modules }: Context) {
     return modules.orders.deliveries.normalizedStatus(obj);
   },
 
-  discounts: async (obj, _, context) => {
-    const { modules } = context;
-    // TODO: use loader
-    const order = await modules.orders.findOrder({ orderId: obj.orderId });
-
+  async discounts(obj: OrderDelivery, _: never, { loaders }: Context) {
+    const order = await loaders.orderLoader.load({ orderId: obj.orderId });
     const pricing = DeliveryPricingSheet({
       calculation: obj.calculation,
-      currency: order.currency,
+      currencyCode: order.currencyCode,
     });
 
     if (pricing.isValid()) {

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

@@ -1,41 +1,27 @@
 import { DeliveryPricingSheet } from '@unchainedshop/core';
 import { Context } from '../../../context.js';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
-import { OrderDelivery, OrderDeliveryDiscount } from '@unchainedshop/core-orders';
-import { Address } from '@unchainedshop/mongodb';
+import { OrderDelivery } from '@unchainedshop/core-orders';
 
-type HelperType<T> = (orderDelivery: OrderDelivery, _: never, context: Context) => T;
-
-export interface OrderDeliveryShippingHelperTypes {
-  address: HelperType<Address>;
-  discounts: HelperType<Promise<Array<OrderDeliveryDiscount>>>;
-  provider: HelperType<Promise<DeliveryProvider>>;
-  status: HelperType<string>;
-}
-
-export const OrderDeliveryShipping: OrderDeliveryShippingHelperTypes = {
-  address: (obj) => {
+export const OrderDeliveryShipping = {
+  address(obj: OrderDelivery) {
     return obj.context?.address;
   },
 
-  status: (obj, _, { modules }) => {
+  status(obj: OrderDelivery, _: never, { modules }: Context) {
     return modules.orders.deliveries.normalizedStatus(obj);
   },
 
-  provider: async (obj, _, { modules }) => {
-    // TODO: use loader
-    return modules.delivery.findProvider({
+  async provider(obj: OrderDelivery, _: never, { loaders }: Context) {
+    return loaders.deliveryProviderLoader.load({
       deliveryProviderId: obj.deliveryProviderId,
     });
   },
 
-  discounts: async (obj, _, context) => {
-    const { modules } = context;
-    // TODO: use loader
-    const order = await modules.orders.findOrder({ orderId: obj.orderId });
+  async discounts(obj: OrderDelivery, _: never, { loaders }: Context) {
+    const order = await loaders.orderLoader.load({ orderId: obj.orderId });
     const pricing = DeliveryPricingSheet({
       calculation: obj.calculation,
-      currency: order.currency,
+      currencyCode: order.currencyCode,
     });
     if (pricing.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!

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

@@ -9,9 +9,8 @@ const OrderDeliveryMap = {
 };
 
 export const OrderDelivery = {
-  __resolveType: async (obj: OrderDeliveryType, { modules }: Context) => {
-    // TODO: use loader
-    const provider = await modules.delivery.findProvider({
+  __resolveType: async (obj: OrderDeliveryType, { loaders }: Context) => {
+    const provider = await loaders.deliveryProviderLoader.load({
       deliveryProviderId: obj.deliveryProviderId,
     });
 

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

@@ -1,29 +1,9 @@
-import { Price } from '@unchainedshop/utils';
 import { Context } from '../../../context.js';
-import { Order, OrderDiscount as OrderDiscountType } from '@unchainedshop/core-orders';
-import { OrderDiscountDirector, OrderPricingDiscount } from '@unchainedshop/core';
+import { OrderDiscount as OrderDiscountType } from '@unchainedshop/core-orders';
+import { OrderDiscountDirector } from '@unchainedshop/core';
 
-type HelperType<P, T> = (orderDiscount: OrderDiscountType, params: P, context: Context) => T;
-
-export interface OrderDiscountHelperTypes {
-  interface: HelperType<
-    never,
-    Promise<{
-      _id: string;
-      label: string;
-      version: string;
-      isManualAdditionAllowed: boolean;
-      isManualRemovalAllowed: boolean;
-    }>
-  >;
-
-  discounted: HelperType<never, Promise<Array<OrderPricingDiscount>>>;
-  order: HelperType<never, Promise<Order>>;
-  total: HelperType<never, Promise<Price>>;
-}
-
-export const OrderDiscount: OrderDiscountHelperTypes = {
-  interface: async (obj) => {
+export const OrderDiscount = {
+  async interface(obj: OrderDiscountType) {
     const Interface = OrderDiscountDirector.getAdapter(obj.discountKey);
     if (!Interface) return null;
 
@@ -36,24 +16,17 @@ export const OrderDiscount: OrderDiscountHelperTypes = {
     };
   },
 
-  order: async (obj, _, { modules }) => {
-    // TODO: use loader
-    return modules.orders.findOrder({ orderId: obj.orderId });
+  async order(obj: OrderDiscountType, _: never, { loaders }: Context) {
+    return loaders.orderLoader.load({ orderId: obj.orderId });
   },
 
-  total: async (obj, _, context) => {
-    // TODO: use loader
-    const order = await context.modules.orders.findOrder({
-      orderId: obj.orderId,
-    });
-    return context.services.orders.calculateDiscountTotal(order, obj);
+  async total(obj: OrderDiscountType, _: never, { loaders, services }: Context) {
+    const order = await loaders.orderLoader.load({ orderId: obj.orderId });
+    return services.orders.calculateDiscountTotal(order, obj);
   },
 
-  discounted: async (obj, _, context) => {
-    // TODO: use loader
-    const order = await context.modules.orders.findOrder({
-      orderId: obj.orderId,
-    });
-    return context.services.orders.discountedEntities(order, obj);
+  async discounted(obj: OrderDiscountType, _: never, { loaders, services }: Context) {
+    const order = await loaders.orderLoader.load({ orderId: obj.orderId });
+    return services.orders.discountedEntities(order, obj);
   },
 };

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

@@ -20,7 +20,6 @@ export const OrderGlobalDiscount = {
     _,
     { modules }: Context,
   ) => {
-    // TODO: use loader
     return modules.orders.discounts.findOrderDiscount({
       discountId: obj.discountId,
     });
@@ -34,7 +33,7 @@ export const OrderGlobalDiscount = {
   ) {
     return {
       amount: obj.amount,
-      currency: obj.currency,
+      currencyCode: obj.currencyCode,
     };
   },
 };

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

@@ -7,7 +7,6 @@ export const OrderItemDiscount = {
   },
 
   orderDiscount: async (obj: OrderPositionDiscount, _, { modules }: Context) => {
-    // TODO: use loader
     return modules.orders.discounts.findOrderDiscount({
       discountId: obj.discountId,
     });
@@ -16,7 +15,7 @@ export const OrderItemDiscount = {
   total(obj: OrderPositionDiscount) {
     return {
       amount: obj.amount,
-      currency: obj.currency,
+      currencyCode: obj.currencyCode,
     };
   },
 };

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

@@ -8,26 +8,19 @@ import { TokenSurrogate, WarehousingProvider } from '@unchainedshop/core-warehou
 import { Price } from '@unchainedshop/utils';
 import { ProductPricingSheet } from '@unchainedshop/core';
 
-const getPricingSheet = async (orderPosition: OrderPosition, context: Context) => {
-  const { modules } = context;
-
-  // TODO: use loader
-  const order = await modules.orders.findOrder({
+const getPricingSheet = async (orderPosition: OrderPosition, { loaders }: Context) => {
+  const order = await loaders.orderLoader.load({
     orderId: orderPosition.orderId,
   });
   return ProductPricingSheet({
     calculation: orderPosition.calculation,
-    currency: order.currency,
+    currencyCode: order.currencyCode,
     quantity: orderPosition.quantity,
   });
 };
 
 export const OrderItem = {
-  async discounts(
-    orderPosition: OrderPosition,
-    _,
-    context: Context,
-  ): Promise<Array<OrderPositionDiscount>> {
+  async discounts(orderPosition: OrderPosition, _, context: Context): Promise<OrderPositionDiscount[]> {
     const pricing = await getPricingSheet(orderPosition, context);
 
     if (pricing.isValid()) {
@@ -42,29 +35,28 @@ export const OrderItem = {
 
   async dispatches(
     orderPosition: OrderPosition,
-    _,
+    _: never,
     { modules, loaders }: Context,
   ): Promise<
-    Array<{
+    {
       _id: string;
       deliveryProvider: DeliveryProvider;
       warehousingProvider: WarehousingProvider;
       shipping: Date;
       earliestDelivery: Date;
-    }>
+    }[]
   > {
     const scheduling = orderPosition.scheduling || [];
-    // TODO: use loader
-    const order = await modules.orders.findOrder({ orderId: orderPosition.orderId });
+    const order = await loaders.orderLoader.load({
+      orderId: orderPosition.orderId,
+    });
     const { countryCode, userId } = order;
 
-    // TODO: use loader
     const orderDelivery = await modules.orders.deliveries.findDelivery({
       orderDeliveryId: order.deliveryId,
     });
 
-    // TODO: use loader
-    const deliveryProvider = await modules.delivery.findProvider({
+    const deliveryProvider = await loaders.deliveryProviderLoader.load({
       deliveryProviderId: orderDelivery.deliveryProviderId,
     });
     const product = await loaders.productLoader.load({
@@ -73,7 +65,7 @@ export const OrderItem = {
 
     return Promise.all(
       scheduling.map(async (schedule) => {
-        // TODO: use loader
+        // TODO: use warehousing provider loader
         const warehousingProvider = await modules.warehousing.findProvider({
           warehousingProviderId: schedule.warehousingProviderId,
         });
@@ -83,7 +75,7 @@ export const OrderItem = {
           deliveryProvider,
           product,
           quantity: orderPosition.quantity,
-          country: countryCode,
+          countryCode,
           userId,
           // referenceDate,
         };
@@ -95,9 +87,10 @@ export const OrderItem = {
     );
   },
 
-  async order(orderPosition: OrderPosition, _, { modules }: Context): Promise<Order> {
-    // TODO: use loader
-    return modules.orders.findOrder({ orderId: orderPosition.orderId });
+  async order(orderPosition: OrderPosition, _, { loaders }: Context): Promise<Order> {
+    return loaders.orderLoader.load({
+      orderId: orderPosition.orderId,
+    });
   },
 
   async originalProduct(orderPosition: OrderPosition, _, { loaders }: Context): Promise<Product> {
@@ -116,7 +109,7 @@ export const OrderItem = {
 
   async quotation(orderPosition: OrderPosition, _, { modules }: Context): Promise<Quotation> {
     if (!orderPosition.quotationId) return null;
-    // TODO: use loader
+    // TODO: use quotation loader
     return modules.quotations.findQuotation({ quotationId: orderPosition.quotationId });
   },
 
@@ -150,8 +143,7 @@ export const OrderItem = {
     orderPosition: OrderPosition,
     params: never,
     { modules }: Context,
-  ): Promise<Array<TokenSurrogate>> {
-    // TODO: use loader?
+  ): Promise<TokenSurrogate[]> {
     return modules.warehousing.findTokens({
       orderPositionId: orderPosition._id,
     });

package/src/resolvers/type/order/order-payment-card-types.ts

@@ -1,36 +1,23 @@
 import { PaymentPricingSheet } from '@unchainedshop/core';
 import { Context } from '../../../context.js';
-import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/core-orders';
-import { PaymentProvider } from '@unchainedshop/core-payment';
+import { OrderPayment } from '@unchainedshop/core-orders';
 
-type HelperType<T> = (orderPayment: OrderPayment, _: never, context: Context) => T;
-
-export interface OrderPaymentCardHelperTypes {
-  discounts: HelperType<Promise<Array<OrderPaymentDiscount>>>;
-  provider: HelperType<Promise<PaymentProvider>>;
-  status: HelperType<string>;
-}
-
-export const OrderPaymentCard: OrderPaymentCardHelperTypes = {
-  status: (obj, _, { modules }) => {
+export const OrderPaymentCard = {
+  status(obj: OrderPayment, _: never, { modules }: Context) {
     return modules.orders.payments.normalizedStatus(obj);
   },
 
-  provider: async (obj, _, { modules }) => {
-    // TODO: use loader
-    return modules.payment.paymentProviders.findProvider({
+  async provider(obj: OrderPayment, _: never, { loaders }: Context) {
+    return loaders.paymentProviderLoader.load({
       paymentProviderId: obj.paymentProviderId,
     });
   },
 
-  discounts: async (obj, _, context) => {
-    const { modules } = context;
-
-    // TODO: use loader
-    const order = await modules.orders.findOrder({ orderId: obj.orderId });
+  async discounts(obj: OrderPayment, _: never, { loaders }: Context) {
+    const order = await loaders.orderLoader.load({ orderId: obj.orderId });
     const pricing = PaymentPricingSheet({
       calculation: obj.calculation,
-      currency: order.currency,
+      currencyCode: order.currencyCode,
     });
     if (pricing.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!

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

@@ -11,7 +11,6 @@ export const OrderPaymentDiscount = {
     _,
     { modules }: Context,
   ) =>
-    // TODO: use loader
     modules.orders.discounts.findOrderDiscount({
       discountId: orderDelivery.discountId,
     }),
@@ -19,7 +18,7 @@ export const OrderPaymentDiscount = {
   total(orderDelivery: Price & { discountId: string; item: OrderPayment }) {
     return {
       amount: orderDelivery.amount,
-      currency: orderDelivery.currency,
+      currencyCode: orderDelivery.currencyCode,
     };
   },
 };