@unchainedshop/api 3.0.0-alpha6 → 3.0.0-rc1

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { OrderPayment as OrderPaymentType } from '@unchainedshop/core-orders';
 import { PaymentProviderType } from '@unchainedshop/core-payment';
 import { objectInvert } from '@unchainedshop/utils';

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

@@ -1,16 +1,18 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Country } from '@unchainedshop/core-countries';
 import { Currency } from '@unchainedshop/core-currencies';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Enrollment } from '@unchainedshop/core-enrollments';
-import { Order as OrderType } from '@unchainedshop/core-orders';
-import { OrderDelivery } from '@unchainedshop/core-orders';
-import { OrderDiscount } from '@unchainedshop/core-orders';
-import { OrderPayment } from '@unchainedshop/core-orders';
-import { OrderPosition } from '@unchainedshop/core-orders';
-import { OrderPrice } from '@unchainedshop/core-orders';
+import {
+  Order as OrderType,
+  OrderPosition,
+  OrderPayment,
+  OrderDiscount,
+  OrderDelivery,
+} from '@unchainedshop/core-orders';
 import { User } from '@unchainedshop/core-users';
+import { Price, sha256 } from '@unchainedshop/utils';
+import { OrderPricingSheet } from '@unchainedshop/core';
 
 export const Order = {
   async supportedDeliveryProviders(
@@ -18,21 +20,15 @@ export const Order = {
     _,
     context: Context,
   ): Promise<Array<DeliveryProvider>> {
-    return context.modules.delivery.findSupported(
-      {
-        order,
-      },
-      context,
-    );
+    return context.services.orders.supportedDeliveryProviders({
+      order,
+    });
   },
 
   async supportedPaymentProviders(order: OrderType, _, context: Context) {
-    return context.modules.payment.paymentProviders.findSupported(
-      {
-        order,
-      },
-      context,
-    );
+    return context.services.orders.supportedPaymentProviders({
+      order,
+    });
   },
 
   async currency(order: OrderType, _, { modules }: Context): Promise<Currency> {
@@ -78,20 +74,16 @@ export const Order = {
     return order.status;
   },
 
-  async total(
-    order: OrderType,
-    params: { category: string; useNetPrice: boolean },
-    { modules }: Context,
-  ): Promise<OrderPrice> {
-    const pricingSheet = modules.orders.pricingSheet(order);
+  async total(order: OrderType, params: { category: string; useNetPrice: boolean }): Promise<Price> {
+    const pricing = OrderPricingSheet({
+      calculation: order.calculation,
+      currency: order.currency,
+    });
 
-    if (pricingSheet.isValid()) {
-      const price = pricingSheet.total(params);
+    if (pricing.isValid()) {
+      const price = pricing.total(params);
       return {
-        _id: crypto
-          .createHash('sha256')
-          .update([order._id, JSON.stringify(params), JSON.stringify(price)].join(''))
-          .digest('hex'),
+        _id: await sha256([order._id, JSON.stringify(params), JSON.stringify(price)].join('')),
         ...price,
       };
     }

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

@@ -1,4 +1,5 @@
-import { Context } from '@unchainedshop/api';
+import { PaymentDirector } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import {
   PaymentCredentials as PaymentCredentialsType,
   PaymentProvider,
@@ -23,13 +24,17 @@ export const PaymentCredentials: PaymentCredentialsHelperTypes = {
     });
   },
 
-  async isValid(obj, _, context) {
-    const { modules, userId } = context;
+  async isValid(obj, _, requestContext) {
+    const { modules, userId } = requestContext;
 
-    return modules.payment.paymentProviders.validate(
-      obj.paymentProviderId,
+    const paymentProvider = await modules.payment.paymentProviders.findProvider({
+      paymentProviderId: obj.paymentProviderId,
+    });
+    const actions = await PaymentDirector.actions(
+      paymentProvider,
       { userId, token: obj },
-      context,
+      requestContext,
     );
+    return actions.validate();
   },
 };

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

@@ -1,85 +1,51 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
-import { PaymentError, PaymentProvider as PaymentProviderType } from '@unchainedshop/core-payment';
-import { PaymentPricingDirector } from '@unchainedshop/core-payment';
+import { Context } from '../../../context.js';
+import { PaymentProvider as PaymentProviderType } from '@unchainedshop/core-payment';
+import { PaymentDirector, PaymentPricingDirector } from '@unchainedshop/core';
+import { sha256 } from '@unchainedshop/utils';
 
-export interface PaymentProviderHelperTypes {
-  interface: (
-    provider: PaymentProviderType,
-    _: never,
-    context: Context,
-  ) => {
-    _id: string;
-    label: string;
-    version: string;
-  };
-  isActive: (provider: PaymentProviderType, _: never, context: Context) => Promise<boolean>;
-  configurationError: (
-    provider: PaymentProviderType,
-    _: never,
-    context: Context,
-  ) => Promise<PaymentError>;
-  simulatedPrice: (
-    provider: PaymentProviderType,
-    params: {
-      currency?: string;
-      orderId: string;
-      useNetPrice?: boolean;
-      context: any;
-    },
-    context: Context,
-  ) => Promise<{
-    _id: string;
-    amount: number;
-    currencyCode: string;
-    countryCode: string;
-    isTaxable: boolean;
-    isNetPrice: boolean;
-  }>;
-}
-export const PaymentProvider: PaymentProviderHelperTypes = {
-  interface(obj, _, { modules }) {
-    const Interface = modules.payment.paymentProviders.findInterface(obj);
-    if (!Interface) return null;
-    return Interface;
+export const PaymentProvider = {
+  interface(provider: PaymentProviderType) {
+    const Adapter = PaymentDirector.getAdapter(provider.adapterKey);
+    if (!Adapter) return null;
+    return {
+      _id: Adapter.key,
+      label: Adapter.label,
+      version: Adapter.version,
+    };
   },
 
-  configurationError(obj, _, requestContext) {
-    const { modules } = requestContext;
-    return modules.payment.paymentProviders.configurationError(obj, requestContext);
+  async configurationError(paymentProvider: PaymentProviderType, _, requestContext: Context) {
+    const adapter = await PaymentDirector.actions(paymentProvider, {}, requestContext);
+    return adapter.configurationError();
   },
 
-  isActive(obj, _, requestContext) {
-    const { modules } = requestContext;
-    return modules.payment.paymentProviders.isActive(obj, requestContext);
+  async isActive(paymentProvider: PaymentProviderType, _, requestContext: Context) {
+    const adapter = await PaymentDirector.actions(paymentProvider, {}, requestContext);
+    return adapter.isActive();
   },
 
   async simulatedPrice(
-    paymentProvider,
+    paymentProvider: PaymentProviderType,
     { currency: currencyCode, orderId, useNetPrice, context: providerContext },
-    requestContext,
+    requestContext: Context,
   ) {
     const { modules, countryContext: country, user } = requestContext;
     const order = await modules.orders.findOrder({ orderId });
+    const currency = currencyCode || order?.currency || requestContext.currencyContext;
+    const pricingContext = {
+      country,
+      currency,
+      provider: paymentProvider,
+      order,
+      providerContext,
+      user,
+    };
 
-    const currency = currencyCode || requestContext.currencyContext;
-
-    const pricingDirector = await PaymentPricingDirector.actions(
-      {
-        country,
-        currency,
-        provider: paymentProvider,
-        order,
-        providerContext,
-        user,
-      },
-      requestContext,
-    );
+    const calculated = await PaymentPricingDirector.rebuildCalculation(pricingContext, requestContext);
 
-    const calculated = await pricingDirector.calculate();
     if (!calculated || !calculated.length) return null;
 
-    const pricing = pricingDirector.calculationSheet();
+    const pricing = PaymentPricingDirector.calculationSheet(pricingContext, calculated);
 
     const orderPrice = pricing.total({ useNetPrice }) as {
       amount: number;
@@ -87,10 +53,7 @@ export const PaymentProvider: PaymentProviderHelperTypes = {
     };
 
     return {
-      _id: crypto
-        .createHash('sha256')
-        .update([paymentProvider._id, country, useNetPrice, order ? order._id : ''].join(''))
-        .digest('hex'),
+      _id: await sha256([paymentProvider._id, country, useNetPrice, order ? order._id : ''].join('')),
       amount: orderPrice.amount,
       currencyCode: orderPrice.currency,
       countryCode: country,

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

@@ -1,5 +1,5 @@
 import { Product } from '@unchainedshop/core-products';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 import { AssortmentPathLink, AssortmentProduct } from '@unchainedshop/core-assortments';
 
 export type HelperType<P, T> = (product: Product, params: P, context: Context) => T;

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

@@ -1,5 +1,5 @@
 import { Product, ProductBundleItem as ProductBundleItemType } from '@unchainedshop/core-products';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export interface ProductBundleItemHelperTypes {
   product: (bundleItem: ProductBundleItemType, _: never, context: Context) => Promise<Product>;

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

@@ -1,7 +1,7 @@
 import { Country } from '@unchainedshop/core-countries';
 import { Currency } from '@unchainedshop/core-currencies';
 import { ProductPrice } from '@unchainedshop/core-products';
-import { Context } from '../../../types.js';
+import { Context } from '../../../context.js';
 
 export type ProductCatalogHelperType<P, T> = (
   productPrice: ProductPrice,

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

@@ -3,10 +3,12 @@ import {
   ProductAssignment,
   ProductConfiguration,
   ProductPriceRange,
+  ProductVariation,
 } from '@unchainedshop/core-products';
-import { Context } from '@unchainedshop/api';
-import { ProductVariation } from '@unchainedshop/core-products';
+import { Context } from '../../../context.js';
 import { Product } from './product-types.js';
+import { sha256 } from '@unchainedshop/utils';
+import { ProductPricingDirector } from '@unchainedshop/core';
 
 export const ConfigurableProduct = {
   ...Product,
@@ -106,18 +108,87 @@ export const ConfigurableProduct = {
     const { countryContext, modules } = requestContext;
     const currency = forcedCurrencyCode || requestContext.currencyContext;
 
-    return modules.products.prices.simulatedPriceRange(
-      product,
-      {
-        quantity,
-        currency,
-        userId: requestContext.userId,
-        country: countryContext,
-        useNetPrice,
-        vectors,
-        includeInactive,
-      },
-      requestContext,
+    const products = await modules.products.proxyProducts(product, vectors, {
+      includeInactive,
+    });
+
+    const filteredPrices = (
+      await Promise.all(
+        products.map(async (proxyProduct) => {
+          const pricingContext = {
+            product: proxyProduct,
+            user: requestContext.user,
+            country: countryContext,
+            currency,
+            quantity,
+          };
+
+          const calculated = await ProductPricingDirector.rebuildCalculation(
+            pricingContext,
+            requestContext,
+          );
+
+          if (!calculated || !calculated.length) return null;
+
+          const pricing = ProductPricingDirector.calculationSheet(pricingContext, calculated);
+          const unitPrice = pricing.unitPrice({ useNetPrice });
+
+          return {
+            _id: await sha256(
+              [
+                proxyProduct._id,
+                countryContext,
+                quantity,
+                useNetPrice,
+                requestContext.userId || 'ANONYMOUS',
+              ].join(''),
+            ),
+            ...unitPrice,
+            isNetPrice: useNetPrice,
+            isTaxable: pricing.taxSum() > 0,
+            currencyCode: pricing.currency,
+          };
+        }),
+      )
+    ).filter(Boolean);
+
+    if (!filteredPrices.length) return null;
+
+    const { minPrice, maxPrice } = modules.products.prices.priceRange({
+      productId: product._id as string,
+      prices: filteredPrices,
+    });
+
+    const minPriceHash = await sha256(
+      [
+        product._id,
+        minPrice?.isTaxable,
+        minPrice?.isNetPrice,
+        minPrice?.amount,
+        minPrice?.currencyCode,
+      ].join(''),
+    );
+
+    const maxPriceHash = await sha256(
+      [
+        product._id,
+        maxPrice?.isTaxable,
+        maxPrice?.isNetPrice,
+        maxPrice?.amount,
+        maxPrice?.currencyCode,
+      ].join(''),
     );
+
+    return {
+      _id: await sha256([product._id, minPriceHash, maxPriceHash].join('')),
+      minPrice: {
+        _id: minPriceHash,
+        ...minPrice,
+      },
+      maxPrice: {
+        _id: maxPriceHash,
+        ...maxPrice,
+      },
+    };
   },
 };

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

@@ -1,47 +1,25 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
 import { ProductDiscount as ProductDiscountType } from '@unchainedshop/core-products';
+import { ProductDiscountDirector } from '@unchainedshop/core';
+import { sha256 } from '@unchainedshop/utils';
 
-type HelperType<T> = (product: ProductDiscountType, _: never, context: Context) => T;
-
-export interface ProductDiscountHelperTypes {
-  interface: HelperType<
-    Promise<{
-      _id: string;
-      label: string;
-      version: string;
-      isManualAdditionAllowed: boolean;
-      isManualRemovalAllowed: boolean;
-    } | null>
-  >;
-  total: HelperType<{
-    _id: string;
-    amount: number;
-    currency: string;
-  } | null>;
-}
-
-export const ProductDiscount: ProductDiscountHelperTypes = {
-  interface: async (obj, _, { modules }) => {
-    const Interface = modules.products.interface(obj);
+export const ProductDiscount = {
+  interface: async (productDiscount: ProductDiscountType) => {
+    const Interface = ProductDiscountDirector.getAdapter(productDiscount.discountKey);
     if (!Interface) return null;
     return {
       _id: Interface.key,
       label: Interface.label,
       version: Interface.version,
-      isManualAdditionAllowed: await Interface.isManualAdditionAllowed(obj.code),
+      isManualAdditionAllowed: await Interface.isManualAdditionAllowed(productDiscount.code),
       isManualRemovalAllowed: await Interface.isManualRemovalAllowed(),
     };
   },
 
-  total: (obj) => {
-    const { total } = obj;
-    if (total) {
+  async total(productDiscount: ProductDiscountType) {
+    const { total, _id } = productDiscount;
+    if (productDiscount.total) {
       return {
-        _id: crypto
-          .createHash('sha256')
-          .update([`${obj._id}`, total.amount, total.currency].join(''))
-          .digest('hex'),
+        _id: await sha256([`${_id}`, total.amount, total.currency].join('')),
         amount: total.amount,
         currency: total.currency,
       };

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

@@ -1,4 +1,4 @@
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { File } from '@unchainedshop/core-files';
 import { ProductMedia as ProductMediaType, ProductMediaText } from '@unchainedshop/core-products';
 

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

@@ -3,8 +3,10 @@ import {
   ProductPrice,
   Product as ProductType,
 } from '@unchainedshop/core-products';
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { Product } from './product-types.js';
+import { ProductPricingDirector } from '@unchainedshop/core';
+import { sha256 } from '@unchainedshop/utils';
 
 export const PlanProduct = {
   ...Product,
@@ -38,21 +40,34 @@ export const PlanProduct = {
     },
     requestContext: Context,
   ): Promise<ProductPrice> {
-    const { countryContext, modules } = requestContext;
+    const { countryContext, user } = requestContext;
     const currency = forcedCurrencyCode || requestContext.currencyContext;
 
-    return modules.products.prices.userPrice(
-      obj,
-      {
-        quantity,
-        userId: requestContext.userId,
-        currency,
-        country: countryContext,
-        useNetPrice,
-        configuration,
-      },
-      requestContext,
-    );
+    const pricingContext = {
+      product: obj,
+      user,
+      country: countryContext,
+      currency,
+      quantity,
+      configuration,
+    };
+
+    const calculated = await ProductPricingDirector.rebuildCalculation(pricingContext, requestContext);
+
+    if (!calculated || !calculated.length) return null;
+
+    const pricing = ProductPricingDirector.calculationSheet(pricingContext, calculated);
+    const unitPrice = pricing.unitPrice({ useNetPrice });
+
+    return {
+      _id: await sha256(
+        [obj._id, countryContext, quantity, useNetPrice, user ? user._id : 'ANONYMOUS'].join(''),
+      ),
+      ...unitPrice,
+      isNetPrice: useNetPrice,
+      isTaxable: pricing.taxSum() > 0,
+      currencyCode: pricing.currency,
+    };
   },
 
   async leveledCatalogPrices(

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

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

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

@@ -1,9 +1,10 @@
 import { Product, ProductSupply } from '@unchainedshop/core-products';
-import { WarehousingContext, WarehousingProvider } from '@unchainedshop/core-warehousing';
-import { Context } from '@unchainedshop/api';
+import { WarehousingContext, WarehousingDirector } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import { DeliveryProviderType } from '@unchainedshop/core-delivery';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { PlanProduct } from './product-plan-types.js';
+import { WarehousingProvider } from '@unchainedshop/core-warehousing';
 
 export const SimpleProduct = {
   ...PlanProduct,
@@ -22,7 +23,7 @@ export const SimpleProduct = {
     }>
   > {
     const { deliveryProviderType, referenceDate, quantity } = params;
-    const { modules } = requestContext;
+    const { modules, services } = requestContext;
 
     const deliveryProviders = await modules.delivery.findProviders({
       type: deliveryProviderType,
@@ -31,13 +32,10 @@ export const SimpleProduct = {
     return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
       const result = await oldResult;
 
-      const warehousingProviders = await modules.warehousing.findSupported(
-        {
-          product: obj,
-          deliveryProvider,
-        },
-        requestContext,
-      );
+      const warehousingProviders = await services.orders.supportedWarehousingProviders({
+        product: obj,
+        deliveryProvider,
+      });
 
       const mappedWarehousingProviders = await Promise.all(
         warehousingProviders.map(async (warehousingProvider) => {
@@ -48,11 +46,12 @@ export const SimpleProduct = {
             referenceDate,
           };
 
-          const dispatch = await modules.warehousing.estimatedDispatch(
+          const director = await WarehousingDirector.actions(
             warehousingProvider,
             warehousingContext,
             requestContext,
           );
+          const dispatch = await director.estimatedDispatch();
 
           return {
             warehousingProvider,
@@ -81,7 +80,7 @@ export const SimpleProduct = {
       quantity?: number;
     }>
   > {
-    const { modules } = requestContext;
+    const { modules, services } = requestContext;
     const { referenceDate, deliveryProviderType } = params;
 
     const deliveryProviders = await modules.delivery.findProviders({
@@ -91,13 +90,10 @@ export const SimpleProduct = {
     return deliveryProviders.reduce(async (oldResult, deliveryProvider) => {
       const result = await oldResult;
 
-      const warehousingProviders = await modules.warehousing.findSupported(
-        {
-          product: obj,
-          deliveryProvider,
-        },
-        requestContext,
-      );
+      const warehousingProviders = await services.orders.supportedWarehousingProviders({
+        product: obj,
+        deliveryProvider,
+      });
 
       const mappedWarehousingProviders = await Promise.all(
         warehousingProviders.map(async (warehousingProvider) => {
@@ -107,11 +103,12 @@ export const SimpleProduct = {
             referenceDate,
           };
 
-          const stock = await modules.warehousing.estimatedStock(
+          const director = await WarehousingDirector.actions(
             warehousingProvider,
             warehousingContext,
             requestContext,
           );
+          const stock = await director.estimatedStock();
 
           return {
             warehousingProvider,