@unchainedshop/api 3.1.13 → 4.0.0-rc.10

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,
     };
   },
 };

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

@@ -1,35 +1,23 @@
 import { PaymentPricingSheet } from '@unchainedshop/core';
+import { OrderPayment } from '@unchainedshop/core-orders';
 import { Context } from '../../../context.js';
-import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/core-orders';
-import { PaymentProvider } from '@unchainedshop/core-payment';
 
-type HelperType<P, T> = (orderPayment: OrderPayment, params: P, context: Context) => T;
-
-export interface OrderPaymentGenericHelperTypes {
-  discounts: HelperType<never, Promise<Array<OrderPaymentDiscount>>>;
-  provider: HelperType<never, Promise<PaymentProvider>>;
-  status: HelperType<never, string>;
-}
-
-export const OrderPaymentGeneric: OrderPaymentGenericHelperTypes = {
-  status: (obj, _, { modules }) => {
+export const OrderPaymentGeneric = {
+  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-invoice-types.ts

@@ -1,35 +1,23 @@
 import { PaymentPricingSheet } from '@unchainedshop/core';
+import { OrderPayment } from '@unchainedshop/core-orders';
 import { Context } from '../../../context.js';
-import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/core-orders';
-import { PaymentProvider } from '@unchainedshop/core-payment';
 
-type HelperType<T> = (orderPayment: OrderPayment, _: never, context: Context) => T;
-
-export interface OrderPaymentInvoiceHelperTypes {
-  discounts: HelperType<Promise<Array<OrderPaymentDiscount>>>;
-  provider: HelperType<Promise<PaymentProvider>>;
-  status: HelperType<string>;
-}
-
-export const OrderPaymentInvoice: OrderPaymentInvoiceHelperTypes = {
-  status: (obj, _, { modules }) => {
+export const OrderPaymentInvoice = {
+  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-types.ts

@@ -10,9 +10,8 @@ const OrderPaymentMap = {
 };
 
 export const OrderPayment = {
-  __resolveType: async (obj: OrderPaymentType, { modules }: Context) => {
-    // TODO: use loader
-    const provider = await modules.payment.paymentProviders.findProvider({
+  __resolveType: async (obj: OrderPaymentType, { loaders }: Context) => {
+    const provider = await loaders.paymentProviderLoader.load({
       paymentProviderId: obj.paymentProviderId,
     });
 

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

@@ -15,11 +15,7 @@ import { Price } from '@unchainedshop/utils';
 import { OrderPricingSheet } from '@unchainedshop/core';
 
 export const Order = {
-  async supportedDeliveryProviders(
-    order: OrderType,
-    _,
-    context: Context,
-  ): Promise<Array<DeliveryProvider>> {
+  async supportedDeliveryProviders(order: OrderType, _, context: Context): Promise<DeliveryProvider[]> {
     return context.services.orders.supportedDeliveryProviders({
       order,
     });
@@ -31,44 +27,37 @@ export const Order = {
     });
   },
 
-  async currency(order: OrderType, _, { modules }: Context): Promise<Currency> {
-    // TODO: use loader
-    return modules.currencies.findCurrency({ isoCode: order.currency });
+  async currency(order: OrderType, _, { loaders }: Context): Promise<Currency> {
+    return loaders.currencyLoader.load({ isoCode: order.currencyCode });
   },
 
-  async country(order: OrderType, _, { modules }: Context): Promise<Country> {
-    // TODO: use loader
-    return modules.countries.findCountry({ isoCode: order.countryCode });
+  async country(order: OrderType, _, { loaders }: Context): Promise<Country> {
+    return loaders.countryLoader.load({ isoCode: order.countryCode });
   },
 
-  async discounts(order: OrderType, _, { modules }: Context): Promise<Array<OrderDiscount>> {
-    // TODO: use loader?
+  async discounts(order: OrderType, _, { modules }: Context): Promise<OrderDiscount[]> {
     return modules.orders.discounts.findOrderDiscounts({ orderId: order._id });
   },
 
   async delivery(order: OrderType, _, { modules }: Context): Promise<OrderDelivery> {
-    // TODO: use loader
     return modules.orders.deliveries.findDelivery({
       orderDeliveryId: order.deliveryId,
     });
   },
 
   async enrollment(order: OrderType, _, { modules }: Context): Promise<Enrollment> {
-    // TODO: use loader
     return modules.enrollments.findEnrollment({
       orderId: order._id,
     });
   },
 
-  async items(order: OrderType, _, { modules }: Context): Promise<Array<OrderPosition>> {
-    // TODO: use loader?
+  async items(order: OrderType, _, { modules }: Context): Promise<OrderPosition[]> {
     return modules.orders.positions.findOrderPositions({
       orderId: order._id,
     });
   },
 
   async payment(order: OrderType, _, { modules }: Context): Promise<OrderPayment> {
-    // TODO: use loader
     return modules.orders.payments.findOrderPayment({
       orderPaymentId: order.paymentId,
     });
@@ -84,7 +73,7 @@ export const Order = {
   total(order: OrderType, params: { category: string; useNetPrice: boolean }): Price {
     const pricing = OrderPricingSheet({
       calculation: order.calculation,
-      currency: order.currency,
+      currencyCode: order.currencyCode,
     });
 
     if (pricing.isValid()) {
@@ -93,8 +82,7 @@ export const Order = {
     return null;
   },
 
-  async user(order: OrderType, _, { modules }: Context): Promise<User> {
-    // TODO: use loader
-    return modules.users.findUserById(order.userId);
+  async user(order: OrderType, _, { loaders }: Context): Promise<User> {
+    return loaders.userLoader.load({ userId: order.userId });
   },
 };

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

@@ -14,23 +14,19 @@ export interface PaymentCredentialsHelperTypes {
   isValid: HelperType<never, Promise<boolean>>;
 }
 export const PaymentCredentials: PaymentCredentialsHelperTypes = {
-  async user(obj, _, { modules }) {
-    // TODO: use loader
-    return modules.users.findUserById(obj.userId);
+  async user(obj, _, { loaders }) {
+    return loaders.userLoader.load({ userId: obj.userId });
   },
 
-  async paymentProvider(obj, _, { modules }) {
-    // TODO: use loader
-    return modules.payment.paymentProviders.findProvider({
+  async paymentProvider(obj, _, { loaders }) {
+    return loaders.paymentProviderLoader.load({
       paymentProviderId: obj.paymentProviderId,
     });
   },
 
   async isValid(obj, _, requestContext) {
-    const { modules, userId } = requestContext;
-
-    // TODO: use loader
-    const paymentProvider = await modules.payment.paymentProviders.findProvider({
+    const { loaders, userId } = requestContext;
+    const paymentProvider = await loaders.paymentProviderLoader.load({
       paymentProviderId: obj.paymentProviderId,
     });
     const actions = await PaymentDirector.actions(

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

@@ -25,17 +25,16 @@ export const PaymentProvider = {
 
   async simulatedPrice(
     paymentProvider: PaymentProviderType,
-    { currency: currencyCode, orderId, useNetPrice, context: providerContext },
+    { currencyCode: forcedCurrencyCode, orderId, useNetPrice, context: providerContext },
     requestContext: Context,
   ) {
-    const { modules, countryContext: country, user } = requestContext;
+    const { loaders, countryCode, user } = requestContext;
 
-    // TODO: use loader
-    const order = await modules.orders.findOrder({ orderId });
-    const currency = currencyCode || order?.currency || requestContext.currencyContext;
+    const order = await loaders.orderLoader.load({ orderId });
+    const currencyCode = forcedCurrencyCode || order?.currencyCode || requestContext.currencyCode;
     const pricingContext = {
-      country,
-      currency,
+      countryCode,
+      currencyCode,
       provider: paymentProvider,
       order,
       providerContext,
@@ -50,13 +49,13 @@ export const PaymentProvider = {
 
     const orderPrice = pricing.total({ useNetPrice }) as {
       amount: number;
-      currency: string;
+      currencyCode: string;
     };
 
     return {
       amount: orderPrice.amount,
-      currencyCode: orderPrice.currency,
-      countryCode: country,
+      currencyCode: orderPrice.currencyCode,
+      countryCode,
       isTaxable: pricing.taxSum() > 0,
       isNetPrice: useNetPrice,
     };

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

@@ -1,13 +1,13 @@
 import accounting from 'accounting';
 
-type PriceType = {
+export interface PriceType {
   isTaxable?: boolean;
   isNetPrice?: boolean;
   countryCode?: string;
   currencyCode?: string;
   currency?: string;
   amount: number;
-};
+}
 
 export const Price = {
   isTaxable({ isTaxable }: PriceType) {
@@ -16,8 +16,8 @@ export const Price = {
   isNetPrice({ isNetPrice }: PriceType) {
     return isNetPrice || false;
   },
-  currency(obj: PriceType) {
-    return obj?.currencyCode || obj?.currency;
+  currencyCode(obj: PriceType) {
+    return obj?.currencyCode;
   },
   amount(obj: PriceType) {
     if (obj.amount) {

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

@@ -5,7 +5,7 @@ import { AssortmentPathLink, AssortmentProduct } from '@unchainedshop/core-assor
 export type HelperType<P, T> = (product: Product, params: P, context: Context) => T;
 export interface ProductAssortmentPathHelperTypes {
   assortmentProduct: (
-    data: { assortmentId: string; productId: string; links: Array<AssortmentPathLink> },
+    data: { assortmentId: string; productId: string; links: AssortmentPathLink[] },
     _: never,
     context: Context,
   ) => Promise<AssortmentProduct>;

package/src/resolvers/type/product/product-bundle-types.ts

@@ -4,7 +4,7 @@ import { Product } from './product-types.js';
 export const BundleProduct = {
   ...Product,
 
-  bundleItems(product): Array<ProductBundleItem> {
+  bundleItems(product): ProductBundleItem[] {
     return product.bundleItems ? product.bundleItems : [];
   },
 };

package/src/resolvers/type/product/product-catalog-price-types.ts

@@ -25,12 +25,10 @@ export const ProductCatalogPrice: ProductCatalogPriceHelperTypes = {
   isNetPrice: ({ isNetPrice }) => {
     return isNetPrice || false;
   },
-  country: async ({ countryCode }, _, { modules }) => {
-    // TODO: use loader
-    return modules.countries.findCountry({ isoCode: countryCode });
+  country: async ({ countryCode }, _, { loaders }) => {
+    return loaders.countryLoader.load({ isoCode: countryCode });
   },
-  currency: async ({ currencyCode }, _, { modules }) => {
-    // TODO: use loader
-    return modules.currencies.findCurrency({ isoCode: currencyCode });
+  currency: async ({ currencyCode }, _, { loaders }) => {
+    return loaders.currencyLoader.load({ isoCode: currencyCode });
   },
 };

package/src/resolvers/type/product/product-configurable-or-bundle-product-types.ts

@@ -0,0 +1,10 @@
+import { Product as ProductType } from '@unchainedshop/core-products';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { objectInvert } from '@unchainedshop/utils';
+
+export const ConfigurableOrBundleProduct = {
+  __resolveType: (product: ProductType): string => {
+    const invertedProductTypes = objectInvert(ProductTypes);
+    return invertedProductTypes[product.type];
+  },
+};

package/src/resolvers/type/product/product-configurable-types.ts

@@ -18,10 +18,10 @@ export const ConfigurableProduct = {
     },
     { modules }: Context,
   ): Promise<
-    Array<{
+    {
       assignment: ProductAssignment;
       product: typeof product;
-    }>
+    }[]
   > {
     return modules.products.proxyAssignments(product, params);
   },
@@ -32,11 +32,11 @@ export const ConfigurableProduct = {
       vectors,
       includeInactive,
     }: {
-      vectors: Array<ProductConfiguration>;
+      vectors: ProductConfiguration[];
       includeInactive: boolean;
     },
     { modules }: Context,
-  ): Promise<Array<typeof product>> {
+  ): Promise<(typeof product)[]> {
     return modules.products.proxyProducts(product, vectors, {
       includeInactive,
     });
@@ -47,24 +47,23 @@ export const ConfigurableProduct = {
     {
       quantity,
       vectors,
-      currency: forcedCurrencyCode,
+      currencyCode,
       includeInactive,
     }: {
-      currency?: string;
+      currencyCode?: string;
       includeInactive: boolean;
       quantity: number;
-      vectors: Array<ProductConfiguration>;
+      vectors: ProductConfiguration[];
     },
     requestContext: Context,
   ): Promise<ProductPriceRange> {
-    const { countryContext, modules } = requestContext;
-    const currencyCode = forcedCurrencyCode || requestContext.currencyContext;
+    const { countryCode, modules } = requestContext;
     return modules.products.prices.catalogPriceRange(product, {
       quantity,
       vectors,
       includeInactive,
-      country: countryContext,
-      currency: currencyCode,
+      countryCode,
+      currencyCode,
     });
   },
 
@@ -78,8 +77,7 @@ export const ConfigurableProduct = {
       offset: number;
     },
     { modules }: Context,
-  ): Promise<Array<ProductVariation>> {
-    // TODO: use loader?
+  ): Promise<ProductVariation[]> {
     return modules.products.variations.findProductVariations({
       productId: product._id,
       limit,
@@ -90,22 +88,23 @@ export const ConfigurableProduct = {
   async simulatedPriceRange(
     product: ProductType,
     {
-      currency: forcedCurrencyCode,
+      currencyCode: forcedCurrencyCode,
       quantity,
       useNetPrice,
       vectors,
       includeInactive,
     }: {
-      currency?: string;
+      currencyCode?: string;
       includeInactive: boolean;
       quantity?: number;
-      vectors: Array<ProductConfiguration>;
+      vectors: ProductConfiguration[];
       useNetPrice: boolean;
     },
     requestContext: Context,
   ): Promise<ProductPriceRange> {
-    const { countryContext, modules, services } = requestContext;
-    const currency = forcedCurrencyCode || requestContext.currencyContext;
+    const { countryCode, modules, services } = requestContext;
+
+    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
 
     const products = await modules.products.proxyProducts(product, vectors, {
       includeInactive,
@@ -117,8 +116,8 @@ export const ConfigurableProduct = {
           const pricingContext = {
             product: proxyProduct,
             user: requestContext.user,
-            country: countryContext,
-            currency,
+            countryCode,
+            currencyCode,
             quantity,
           };
 
@@ -130,7 +129,7 @@ export const ConfigurableProduct = {
             ...unitPrice,
             isNetPrice: useNetPrice,
             isTaxable: pricing.taxSum() > 0,
-            currencyCode: pricing.currency,
+            currencyCode: pricing.currencyCode,
           };
         }),
       )

package/src/resolvers/type/product/product-discount.ts

@@ -19,7 +19,7 @@ export const ProductDiscount = {
     if (productDiscount.total) {
       return {
         amount: total.amount,
-        currency: total.currency,
+        currencyCode: total.currencyCode,
       };
     }
     return null;

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

@@ -11,10 +11,10 @@ export interface ProductMediaHelperTypes {
 
 export const ProductMedia: ProductMediaHelperTypes = {
   async texts(obj, { forceLocale }, requestContext) {
-    const { localeContext, loaders } = requestContext;
+    const { locale, loaders } = requestContext;
     return loaders.productMediaTextLoader.load({
       productMediaId: obj._id,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },