@unchainedshop/api 3.1.10 → 4.0.0-rc.2

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

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

@@ -11,41 +11,41 @@ export const PlanProduct = {
 
   async catalogPrice(
     product: ProductType,
-    { quantity, currency: forcedCurrencyCode }: { quantity?: number; currency?: string },
+    { quantity, currencyCode: forcedCurrencyCode }: { quantity?: number; currencyCode?: string },
     requestContext: Context,
   ): Promise<ProductPrice> {
-    const { modules, countryContext } = requestContext;
-    const currency = forcedCurrencyCode || requestContext.currencyContext;
+    const { modules, countryCode } = requestContext;
+    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
     return modules.products.prices.price(product, {
-      country: countryContext,
-      currency,
+      countryCode,
+      currencyCode,
       quantity,
     });
   },
 
   async simulatedPrice(
-    obj: ProductType,
+    product: ProductType,
     {
-      currency: forcedCurrencyCode,
+      currencyCode: forcedCurrencyCode,
       quantity,
       useNetPrice,
       configuration,
     }: {
       quantity?: number;
-      currency?: string;
+      currencyCode?: string;
       useNetPrice?: boolean;
-      configuration?: Array<ProductConfiguration>;
+      configuration?: ProductConfiguration[];
     },
     requestContext: Context,
   ): Promise<ProductPrice> {
-    const { countryContext, user, services } = requestContext;
-    const currency = forcedCurrencyCode || requestContext.currencyContext;
+    const { countryCode, user, services } = requestContext;
+    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
 
     const pricingContext = {
-      product: obj,
+      product,
       user,
-      country: countryContext,
-      currency,
+      countryCode,
+      currencyCode,
       quantity,
       configuration,
     };
@@ -58,24 +58,24 @@ export const PlanProduct = {
       ...unitPrice,
       isNetPrice: useNetPrice,
       isTaxable: pricing.taxSum() > 0,
-      currencyCode: pricing.currency,
+      currencyCode: pricing.currencyCode,
     };
   },
 
   async leveledCatalogPrices(
-    obj: ProductType,
-    { currency: forcedCurrencyCode }: { currency?: string },
+    product: ProductType,
+    { currencyCode: forcedCurrencyCode }: { currencyCode?: string },
     requestContext: Context,
   ): Promise<
-    Array<{
+    {
       minQuantity: number;
       maxQuantity: number;
       price: ProductPrice;
-    }>
+    }[]
   > {
-    const { countryContext, modules } = requestContext;
-    const currency = forcedCurrencyCode || requestContext.currencyContext;
-    return modules.products.prices.catalogPricesLeveled(obj, { currency, country: countryContext });
+    const { countryCode, modules } = requestContext;
+    const currencyCode = forcedCurrencyCode || requestContext.currencyCode;
+    return modules.products.prices.catalogPricesLeveled(product, { currencyCode, countryCode });
   },
 
   salesUnit({ commerce }: ProductType): string {

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

@@ -13,12 +13,11 @@ export interface ProductReviewHelperTypes {
   author: HelperType<never, Promise<User>>;
   product: HelperType<never, Promise<Product>>;
   voteCount: HelperType<{ type: ProductReviewVoteType }, number>;
-  ownVotes: HelperType<never, Promise<Array<ProductVote>>>;
+  ownVotes: HelperType<never, Promise<ProductVote[]>>;
 }
 export const ProductReview: ProductReviewHelperTypes = {
-  author: async (obj, _, { modules }) => {
-    // TODO: use loader
-    return modules.users.findUserById(obj.authorId);
+  author: async (obj, _, { loaders }) => {
+    return loaders.userLoader.load({ userId: obj.authorId });
   },
 
   product: async (review, _, { loaders }) => {

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

@@ -13,21 +13,16 @@ export const SimpleProduct = {
     params: { referenceDate: Date; quantity: number; deliveryProviderType: DeliveryProviderType },
     requestContext: Context,
   ): Promise<
-    Array<{
+    {
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       shipping?: Date;
       earliestDelivery?: Date;
-    }>
+    }[]
   > {
     const { referenceDate, quantity } = params;
-    const { services, modules } = requestContext;
-
-    // TODO: use loader?
-    const deliveryProviders = await modules.delivery.findProviders({});
-
+    const { services } = requestContext;
     return services.products.simulateProductDispatching({
-      deliveryProviders,
       product: obj,
       quantity,
       referenceDate,
@@ -42,22 +37,15 @@ export const SimpleProduct = {
     },
     requestContext: Context,
   ): Promise<
-    Array<{
+    {
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       quantity?: number;
-    }>
+    }[]
   > {
-    const { modules, services } = requestContext;
-    const { referenceDate, deliveryProviderType } = params;
-
-    // TODO: use loader?
-    const deliveryProviders = await modules.delivery.findProviders({
-      type: deliveryProviderType,
-    });
-
+    const { services } = requestContext;
+    const { referenceDate } = params;
     return services.products.simulateProductInventory({
-      deliveryProviders,
       product: obj,
       referenceDate,
     });

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

@@ -38,20 +38,15 @@ export const TokenizedProduct = {
     },
     requestContext: Context,
   ): Promise<
-    Array<{
+    {
       deliveryProvider?: DeliveryProvider;
       warehousingProvider?: WarehousingProvider;
       quantity?: number;
-    }>
+    }[]
   > {
-    const { modules, services } = requestContext;
+    const { services } = requestContext;
     const { referenceDate } = params;
-
-    // TODO: use loader?
-    const deliveryProviders = await modules.delivery.findProviders({});
-
     return services.products.simulateProductInventory({
-      deliveryProviders,
       product: obj,
       referenceDate,
     });
@@ -59,8 +54,6 @@ export const TokenizedProduct = {
 
   async tokens(product: Product, params: never, requestContext: Context) {
     await checkAction(requestContext, actions.viewTokens, [undefined, params]);
-
-    // TODO: use loader?
     const tokens = await requestContext.modules.warehousing.findTokens({
       productId: product._id,
     });