@unchainedshop/api 1.1.3

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

@@ -0,0 +1,17 @@
+import { Context } from '@unchainedshop/types/api';
+import { PaymentProvider } from '@unchainedshop/types/payments';
+import { Enrollment } from '@unchainedshop/types/enrollments';
+
+type HelperType<T> = (enrollmentPayment: Enrollment['payment'], _: never, context: Context) => T;
+
+type EnrollmentPaymentHelperTypes = {
+  provider: HelperType<Promise<PaymentProvider>>;
+};
+
+export const EnrollmentPayment: EnrollmentPaymentHelperTypes = {
+  provider: async ({ paymentProviderId }, _, { modules }) => {
+    return modules.payment.paymentProviders.findProvider({
+      paymentProviderId,
+    });
+  },
+};

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

@@ -0,0 +1,15 @@
+import { Context } from '@unchainedshop/types/api';
+import { EnrollmentPeriod as EnrollmentPeriodType } from '@unchainedshop/types/enrollments';
+import { Order } from '@unchainedshop/types/orders';
+
+type HelperType<T> = (enrollmentPeriod: EnrollmentPeriodType, _: never, context: Context) => T;
+
+type EnrollmentPeriodHelperTypes = {
+  order: HelperType<Promise<Order>>;
+};
+
+export const EnrollmentPeriod: EnrollmentPeriodHelperTypes = {
+  order: async (period, _, { modules }) => {
+    return modules.orders.findOrder({ orderId: period.orderId });
+  },
+};

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

@@ -0,0 +1,15 @@
+import { Context } from '@unchainedshop/types/api';
+import { EnrollmentPlan as EnrollmentPlanType } from '@unchainedshop/types/enrollments';
+import { Product } from '@unchainedshop/types/products';
+
+type HelperType<T> = (enrollmentPlan: EnrollmentPlanType, _: never, context: Context) => T;
+
+type EnrollmentPlanHelperTypes = {
+  product: HelperType<Promise<Product>>;
+};
+
+export const EnrollmentPlan: EnrollmentPlanHelperTypes = {
+  product: async (plan, _, { modules }) => {
+    return modules.products.findProduct({ productId: plan.productId });
+  },
+};

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

@@ -0,0 +1,35 @@
+import { Context } from '@unchainedshop/types/api';
+import { Country } from '@unchainedshop/types/countries';
+import { Currency } from '@unchainedshop/types/currencies';
+import { Enrollment as EnrollmentType, EnrollmentPlan } from '@unchainedshop/types/enrollments';
+import { User } from '@unchainedshop/types/user';
+
+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 }) => {
+    return modules.enrollments.isExpired(obj, params);
+  },
+
+  plan: ({ quantity, productId, configuration }) => {
+    return {
+      quantity,
+      productId,
+      configuration,
+    };
+  },
+
+  country: (obj, _, { modules }) => modules.countries.findCountry({ isoCode: obj.countryCode }),
+
+  currency: (obj, _, { modules }) => modules.currencies.findCurrency({ isoCode: obj.currencyCode }),
+
+  user: (obj, _, { modules }) => modules.users.findUserById(obj.userId),
+};

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

@@ -0,0 +1,14 @@
+import { Context } from '@unchainedshop/types/api';
+import { Event as EventType } from '@unchainedshop/types/events';
+
+type HelperType<P, T> = (work: EventType, params: P, context: Context) => T;
+
+export interface EventHelperTypes {
+  type: HelperType<never, string>;
+}
+
+export const Event: EventHelperTypes = {
+  type: (obj, _, { modules }) => {
+    return modules.events.type(obj);
+  },
+};

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

@@ -0,0 +1,29 @@
+import { Context } from '@unchainedshop/types/api';
+import { FilterOption as FilterOptionType, FilterText } from '@unchainedshop/types/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) {
+    return `${obj._id}:${obj.filterOption}`;
+  },
+
+  value(obj) {
+    return obj.filterOption;
+  },
+
+  async texts(obj, { forceLocale }, requestContext) {
+    const { localeContext, loaders } = requestContext;
+    return loaders.filterTextLoader.load({
+      filterId: obj._id,
+      filterOptionValue: obj.filterOption,
+      locale: forceLocale || localeContext.normalized,
+    });
+  },
+};

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

@@ -0,0 +1,27 @@
+import { Context } from '@unchainedshop/types/api';
+import { Filter as FilterType, FilterOption, FilterText } from '@unchainedshop/types/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) => {
+    return (obj.options || []).map((filterOption) => ({
+      ...obj,
+      filterOption,
+    }));
+  },
+
+  async texts(obj, { forceLocale }, requestContext) {
+    const { localeContext, loaders } = requestContext;
+    return loaders.filterTextLoader.load({
+      filterId: obj._id,
+      filterOptionValue: null,
+      locale: forceLocale || localeContext.normalized,
+    });
+  },
+};

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

@@ -0,0 +1 @@
+export const LoadedFilterOption = {};

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

@@ -0,0 +1 @@
+export const LoadedFilter = {};

package/src/resolvers/type/index.js

@@ -0,0 +1,133 @@
+import { Assortment } from './assortment/assortment-types';
+import { AssortmentFilter } from './assortment/assortment-filter-types';
+import { AssortmentLink } from './assortment/assortment-link-types';
+import { AssortmentMedia } from './assortment/assortment-media-types';
+import { AssortmentPathLink } from './assortment/assortment-path-link-types';
+import { AssortmentProduct } from './assortment/assortment-product-types';
+import { Bookmark } from './bookmark-types';
+import { BundleProduct } from './product/product-bundle-types';
+import { Color } from './color-types';
+import { ConfigurableProduct } from './product/product-configurable-types';
+import { Country } from './country-types';
+import { DeliveryProvider } from './delivery-provider-types';
+import { Dimensions } from './dimensions-types';
+import { Dispatch } from './dispatch-types';
+import { Enrollment } from './enrollment/enrollment-types';
+import { EnrollmentDelivery } from './enrollment/enrollment-delivery-types';
+import { EnrollmentPayment } from './enrollment/enrollment-payment-types';
+import { EnrollmentPeriod } from './enrollment/enrollment-period-types';
+import { EnrollmentPlan } from './enrollment/enrollment-plan-tyes';
+import { Filter } from './filter/filter-types';
+import { FilterOption } from './filter/filter-option-types';
+import { Language } from './language-types';
+import { LoadedFilter } from './filter/loaded-filter-types';
+import { LoadedFilterOption } from './filter/loaded-filter-option-types';
+import { LoginMethodResponse } from './login-method-response-types';
+import { Order } from './order/order-types';
+import { OrderDelivery } from './order/order-delivery-types';
+import { OrderDeliveryDiscount } from './order/order-delivery-discount-types';
+import { OrderDeliveryPickUp } from './order/order-delivery-pickup-types';
+import { OrderDeliveryShipping } from './order/order-delivery-shipping-types';
+import { OrderDiscount } from './order/order-discount-types';
+import { OrderDiscountable } from './order/order-discountable-types';
+import { OrderGlobalDiscount } from './order/order-global-discount-types';
+import { OrderItem } from './order/order-item-types';
+import { OrderItemDiscount } from './order/order-item-discount-types';
+import { OrderPayment } from './order/order-payment-types';
+import { OrderPaymentCard } from './order/order-payment-card-types';
+import { OrderPaymentDiscount } from './order/order-payment-discount-types';
+import { OrderPaymentGeneric } from './order/order-payment-generic-types';
+import { OrderPaymentInvoice } from './order/order-payment-invoice-types';
+import { PaymentCredentials } from './payment/payment-credentials-types';
+import { PaymentProvider } from './payment/payment-provider-types';
+import { PlanProduct } from './product/product-plan-types';
+import { Price } from './price-types';
+import { Product } from './product/product-types';
+import { ProductAssortmentPath } from './product/product-assortment-path-types';
+import { ProductBundleItem } from './product/product-bundle-item-types';
+import { ProductCatalogPrice } from './product/product-catalog-price-types';
+import { ProductDiscount } from './product/product-discount';
+import { ProductMedia } from './product/product-media-types';
+import { ProductReview } from './product/product-review-types';
+import { ProductVariation } from './product/product-variation-types';
+import { ProductVariationAssignment } from './product/product-variation-assignment-types';
+import { ProductVariationAssignmentVector } from './product/product-variation-assignment-vector';
+import { ProductVariationOption } from './product/product-variation-option-types';
+import { Quotation } from './quotation-types';
+import { Shop } from './shop-types';
+import { SimpleProduct } from './product/product-simple-types';
+import { Stock } from './stock-types';
+import { User } from './user-types';
+import { WarehousingProvider } from './warehousing-provider-types';
+import { Work } from './work-types';
+import { Event } from './event-types';
+import { Media } from './media-types';
+
+const types = {
+  Assortment,
+  AssortmentFilter,
+  AssortmentLink,
+  AssortmentMedia,
+  AssortmentPathLink,
+  AssortmentProduct,
+  Bookmark,
+  BundleProduct,
+  Color,
+  ConfigurableProduct,
+  Country,
+  DeliveryProvider,
+  Dimensions,
+  Dispatch,
+  Enrollment,
+  EnrollmentDelivery,
+  EnrollmentPayment,
+  EnrollmentPeriod,
+  EnrollmentPlan,
+  Filter,
+  FilterOption,
+  Language,
+  LoadedFilter,
+  LoadedFilterOption,
+  LoginMethodResponse,
+  Order,
+  OrderDelivery,
+  OrderDeliveryDiscount,
+  OrderDeliveryPickUp,
+  OrderDeliveryShipping,
+  OrderDiscount,
+  OrderDiscountable,
+  OrderGlobalDiscount,
+  OrderItem,
+  OrderItemDiscount,
+  OrderPayment,
+  OrderPaymentCard,
+  OrderPaymentDiscount,
+  OrderPaymentGeneric,
+  OrderPaymentInvoice,
+  PaymentCredentials,
+  PaymentProvider,
+  PlanProduct,
+  Price,
+  Product,
+  ProductAssortmentPath,
+  ProductBundleItem,
+  ProductCatalogPrice,
+  ProductDiscount,
+  ProductMedia,
+  ProductReview,
+  ProductVariation,
+  ProductVariationAssignment,
+  ProductVariationAssignmentVector,
+  ProductVariationOption,
+  Quotation,
+  Shop,
+  SimpleProduct,
+  Stock,
+  User,
+  WarehousingProvider,
+  Work,
+  Event,
+  Media,
+};
+
+export default types;

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

@@ -0,0 +1,16 @@
+import { Language as LanguageType } from '@unchainedshop/types/languages';
+import { Context } from '@unchainedshop/types/api';
+
+export interface LanguageHelperTypes {
+  isBase: (language: LanguageType, params: never, context: Context) => boolean;
+  name: (language: LanguageType, params: never, context: Context) => string;
+}
+
+export const Language: LanguageHelperTypes = {
+  isBase(language, _, { modules }) {
+    return modules.languages.isBase(language);
+  },
+  name(language, _, { modules }) {
+    return `${language.isoCode}${modules.languages.isBase(language) ? ' (Base)' : ''}`;
+  },
+};

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

@@ -0,0 +1,13 @@
+import { Context } from '@unchainedshop/types/api';
+import { User } from '@unchainedshop/types/user';
+
+export const LoginMethodResponse = {
+  user: async ({ id }: { id: string }, _: never, { modules }: Context) => {
+    const user = (await modules.users.findUserById(id)) as User & {
+      _inLoginMethodResponse: boolean;
+    };
+    user._inLoginMethodResponse = true; // eslint-disable-line
+
+    return user;
+  },
+};

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

@@ -0,0 +1,12 @@
+import { File as FileType } from '@unchainedshop/types/files';
+import { Context } from '@unchainedshop/types/api';
+
+export interface MediaHelperTypes {
+  url: (language: FileType, params: Record<string, any>, context: Context) => string;
+}
+
+export const Media: MediaHelperTypes = {
+  url(root, params, { modules }) {
+    return modules.files.getUrl(root, params);
+  },
+};

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

@@ -0,0 +1,36 @@
+import { Context } from '@unchainedshop/types/api';
+import { OrderDeliveryDiscount as OrderDeliveryDiscountType } from '@unchainedshop/types/orders.deliveries';
+import { OrderDiscount } from '@unchainedshop/types/orders.discounts';
+import { OrderPrice } from '@unchainedshop/types/orders.pricing';
+import crypto from 'crypto';
+
+type HelperType<P, T> = (orderDelivery: OrderDeliveryDiscountType, params: P, context: Context) => T;
+
+interface OrderDeliveryDiscountHelperTypes {
+  _id: HelperType<never, string>;
+  orderDiscount: HelperType<never, Promise<OrderDiscount>>;
+  total: HelperType<never, OrderPrice>;
+}
+
+export const OrderDeliveryDiscount: OrderDeliveryDiscountHelperTypes = {
+  _id(obj) {
+    return `${obj.item._id}:${obj.discountId}`;
+  },
+
+  orderDiscount: async (obj, _, { modules }) => {
+    return modules.orders.discounts.findOrderDiscount({
+      discountId: obj.discountId,
+    });
+  },
+
+  total(obj) {
+    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

@@ -0,0 +1,59 @@
+import { Context } from '@unchainedshop/types/api';
+import { DeliveryLocation, DeliveryProvider } from '@unchainedshop/types/delivery';
+import { OrderDelivery, OrderDeliveryDiscount } from '@unchainedshop/types/orders.deliveries';
+import { DeliveryDirector } from '@unchainedshop/core-delivery';
+
+type HelperType<T> = (orderDelivery: OrderDelivery, _: never, context: Context) => T;
+
+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 (obj, _, context) => {
+    const { orderPickUpLocationId } = obj.context || {};
+    const provider = await context.modules.delivery.findProvider({
+      deliveryProviderId: obj.deliveryProviderId,
+    });
+    const director = await DeliveryDirector.actions(provider, { orderDelivery: obj }, context);
+
+    return director.pickUpLocationById(orderPickUpLocationId);
+  },
+
+  pickUpLocations: async (obj, _, context) => {
+    const provider = await context.modules.delivery.findProvider({
+      deliveryProviderId: obj.deliveryProviderId,
+    });
+    const director = await DeliveryDirector.actions(provider, { orderDelivery: obj }, context);
+
+    return director.pickUpLocations();
+  },
+
+  provider: async (obj, _, { modules }) => {
+    return modules.delivery.findProvider({
+      deliveryProviderId: obj.deliveryProviderId,
+    });
+  },
+
+  status: (obj, _, { modules }) => {
+    return modules.orders.deliveries.normalizedStatus(obj);
+  },
+
+  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()) {
+      // IMPORTANT: Do not send any parameter to obj.discounts!
+      return pricingSheet.discountPrices().map((discount) => ({
+        item: obj,
+        ...discount,
+      }));
+    }
+    return [];
+  },
+};

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

@@ -0,0 +1,43 @@
+import { Context } from '@unchainedshop/types/api';
+import { Address } from '@unchainedshop/types/common';
+import { DeliveryProvider } from '@unchainedshop/types/delivery';
+import { OrderDelivery, OrderDeliveryDiscount } from '@unchainedshop/types/orders.deliveries';
+
+type HelperType<T> = (orderDelivery: OrderDelivery, _: never, context: Context) => T;
+
+interface OrderDeliveryShippingHelperTypes {
+  address: HelperType<Address>;
+  discounts: HelperType<Promise<Array<OrderDeliveryDiscount>>>;
+  provider: HelperType<Promise<DeliveryProvider>>;
+  status: HelperType<string>;
+}
+
+export const OrderDeliveryShipping: OrderDeliveryShippingHelperTypes = {
+  address: (obj) => {
+    return obj.context?.address;
+  },
+
+  status: (obj, _, { modules }) => {
+    return modules.orders.deliveries.normalizedStatus(obj);
+  },
+
+  provider: async (obj, _, { modules }) => {
+    return modules.delivery.findProvider({
+      deliveryProviderId: obj.deliveryProviderId,
+    });
+  },
+
+  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()) {
+      // IMPORTANT: Do not send any parameter to obj.discounts!
+      return pricingSheet.discountPrices().map((discount) => ({
+        item: obj,
+        ...discount,
+      }));
+    }
+    return [];
+  },
+};

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

@@ -0,0 +1,23 @@
+import { OrderDelivery as OrderDeliveryType } from '@unchainedshop/types/orders.deliveries';
+import { DeliveryProviderType } from '@unchainedshop/core-delivery';
+import { objectInvert } from '@unchainedshop/utils';
+import { Context } from '@unchainedshop/types/api';
+
+const OrderDeliveryMap = {
+  OrderDeliveryShipping: DeliveryProviderType.SHIPPING,
+  OrderDeliveryPickUp: DeliveryProviderType.PICKUP,
+};
+
+export const OrderDelivery = {
+  __resolveType: async (obj: OrderDeliveryType, { modules }: Context) => {
+    const provider = await modules.delivery.findProvider({
+      deliveryProviderId: obj.deliveryProviderId,
+    });
+
+    const invertedProductTypes = objectInvert(OrderDeliveryMap);
+    if (provider) {
+      return invertedProductTypes[provider.type];
+    }
+    return invertedProductTypes[DeliveryProviderType.SHIPPING];
+  },
+};

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

@@ -0,0 +1,57 @@
+import { Context } from '@unchainedshop/types/api';
+import { Order } from '@unchainedshop/types/orders';
+import { OrderDiscount as OrderDiscountType } from '@unchainedshop/types/orders.discounts';
+import { OrderPrice, OrderPricingDiscount } from '@unchainedshop/types/orders.pricing';
+import { OrderDiscountDirector } from '@unchainedshop/core-orders';
+
+type HelperType<P, T> = (orderDiscount: OrderDiscountType, params: P, context: Context) => T;
+
+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<OrderPrice>>;
+}
+
+export const OrderDiscount: OrderDiscountHelperTypes = {
+  interface: async (obj) => {
+    const Interface = OrderDiscountDirector.getAdapter(obj.discountKey);
+    if (!Interface) return null;
+
+    return {
+      _id: Interface.key,
+      label: Interface.label,
+      version: Interface.version,
+      isManualAdditionAllowed: await Interface.isManualAdditionAllowed(obj.code),
+      isManualRemovalAllowed: await Interface.isManualRemovalAllowed(),
+    };
+  },
+
+  order: async (obj, _, { modules }) => {
+    return modules.orders.findOrder({ orderId: obj.orderId });
+  },
+
+  total: async (obj, _, context) => {
+    const order = await context.modules.orders.findOrder({
+      orderId: obj.orderId,
+    });
+    return context.modules.orders.discountTotal(order, obj, context);
+  },
+
+  discounted: async (obj, _, context) => {
+    const order = await context.modules.orders.findOrder({
+      orderId: obj.orderId,
+    });
+    return context.modules.orders.discounted(order, obj, context);
+  },
+};

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

@@ -0,0 +1,36 @@
+import { Order } from '@unchainedshop/types/orders';
+import { OrderDelivery } from '@unchainedshop/types/orders.deliveries';
+import { OrderDiscount } from '@unchainedshop/types/orders.discounts';
+import { OrderPayment } from '@unchainedshop/types/orders.payments';
+import { OrderPosition } from '@unchainedshop/types/orders.positions';
+import { OrderPrice } from '@unchainedshop/types/orders.pricing';
+
+const OrderDiscountableType = {
+  OrderItemDiscount: 'OrderItemDiscount',
+  OrderPaymentDiscount: 'OrderPaymentDiscount',
+  OrderDeliveryDiscount: 'OrderDeliveryDiscount',
+  OrderGlobalDiscount: 'OrderGlobalDiscount',
+};
+
+export const OrderDiscountable = {
+  __resolveType(obj: {
+    _id: string;
+    delivery?: OrderDelivery;
+    item?: OrderPosition;
+    order?: Order;
+    orderDiscount: OrderDiscount;
+    payment?: OrderPayment;
+    total: OrderPrice;
+  }) {
+    if (obj.delivery) {
+      return OrderDiscountableType.OrderDeliveryDiscount;
+    }
+    if (obj.payment) {
+      return OrderDiscountableType.OrderPaymentDiscount;
+    }
+    if (obj.item) {
+      return OrderDiscountableType.OrderItemDiscount;
+    }
+    return OrderDiscountableType.OrderGlobalDiscount;
+  },
+};

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

@@ -0,0 +1,43 @@
+import crypto from 'crypto';
+import { OrderPrice } from '@unchainedshop/types/orders.pricing';
+import { Order } from '@unchainedshop/types/orders';
+import { OrderDiscount } from '@unchainedshop/types/orders.discounts';
+import { Context } from '@unchainedshop/types/api';
+
+type HelperType<P, T> = (
+  orderGlobalDiscount: OrderPrice & {
+    order: Order;
+    discountId: string;
+  },
+  params: P,
+  context: Context,
+) => T;
+
+interface OrderGlobalDiscountHelperTypes {
+  _id: HelperType<never, string>;
+  orderDiscount: HelperType<never, Promise<OrderDiscount>>;
+  total: HelperType<never, OrderPrice>;
+}
+
+export const OrderGlobalDiscount: OrderGlobalDiscountHelperTypes = {
+  _id(obj) {
+    return `${obj.order._id}:${obj.discountId}`;
+  },
+
+  orderDiscount: async (obj, _, { modules }) => {
+    return modules.orders.discounts.findOrderDiscount({
+      discountId: obj.discountId,
+    });
+  },
+
+  total: (obj) => {
+    return {
+      _id: crypto
+        .createHash('sha256')
+        .update([`${obj.order._id}:${obj.discountId}`, obj.amount, obj.currency].join(''))
+        .digest('hex'),
+      amount: obj.amount,
+      currency: obj.currency,
+    };
+  },
+};