@unchainedshop/api 3.0.0-alpha7 → 3.0.0-rc10

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

@@ -1,11 +1,7 @@
-import { Context } from '@unchainedshop/api';
-import {
-  Order,
-  OrderPrice,
-  OrderPricingDiscount,
-  OrderDiscount as OrderDiscountType,
-  OrderDiscountDirector,
-} from '@unchainedshop/core-orders';
+import { Price } from '@unchainedshop/utils';
+import { Context } from '../../../context.js';
+import { Order, OrderDiscount as OrderDiscountType } from '@unchainedshop/core-orders';
+import { OrderDiscountDirector, OrderPricingDiscount } from '@unchainedshop/core';
 
 type HelperType<P, T> = (orderDiscount: OrderDiscountType, params: P, context: Context) => T;
 
@@ -23,7 +19,7 @@ export interface OrderDiscountHelperTypes {
 
   discounted: HelperType<never, Promise<Array<OrderPricingDiscount>>>;
   order: HelperType<never, Promise<Order>>;
-  total: HelperType<never, Promise<OrderPrice>>;
+  total: HelperType<never, Promise<Price>>;
 }
 
 export const OrderDiscount: OrderDiscountHelperTypes = {
@@ -48,13 +44,13 @@ export const OrderDiscount: OrderDiscountHelperTypes = {
     const order = await context.modules.orders.findOrder({
       orderId: obj.orderId,
     });
-    return context.modules.orders.discountTotal(order, obj, context);
+    return context.services.orders.calculateDiscountTotal(order, obj);
   },
 
   discounted: async (obj, _, context) => {
     const order = await context.modules.orders.findOrder({
       orderId: obj.orderId,
     });
-    return context.modules.orders.discounted(order, obj, context);
+    return context.services.orders.discountedEntities(order, obj);
   },
 };

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

@@ -1,8 +1,11 @@
-import { Order, OrderPosition } from '@unchainedshop/core-orders';
-import { OrderDelivery } from '@unchainedshop/core-orders';
-import { OrderDiscount } from '@unchainedshop/core-orders';
-import { OrderPayment } from '@unchainedshop/core-orders';
-import { OrderPrice } from '@unchainedshop/core-orders';
+import {
+  Order,
+  OrderPosition,
+  OrderDelivery,
+  OrderDiscount,
+  OrderPayment,
+} from '@unchainedshop/core-orders';
+import { Price } from '@unchainedshop/utils';
 
 export const OrderDiscountableType = {
   OrderItemDiscount: 'OrderItemDiscount',
@@ -19,7 +22,7 @@ export const OrderDiscountable = {
     order?: Order;
     orderDiscount: OrderDiscount;
     payment?: OrderPayment;
-    total: OrderPrice;
+    total: Price;
   }) {
     if (obj.delivery) {
       return OrderDiscountableType.OrderDeliveryDiscount;

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

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

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

@@ -1,34 +1,19 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
-import { OrderDiscount } from '@unchainedshop/core-orders';
-import { OrderPrice } from '@unchainedshop/core-orders';
+import { Context } from '../../../context.js';
 import { OrderPositionDiscount } from '@unchainedshop/core-orders';
 
-type HelperType<P, T> = (orderPositionDiscount: OrderPositionDiscount, params: P, context: Context) => T;
-
-export interface OrderItemDiscountHelperTypes {
-  _id: HelperType<never, string>;
-  orderDiscount: HelperType<never, Promise<OrderDiscount>>;
-  total: HelperType<never, OrderPrice>;
-}
-
-export const OrderItemDiscount: OrderItemDiscountHelperTypes = {
-  _id: (obj) => {
+export const OrderItemDiscount = {
+  _id: (obj: OrderPositionDiscount) => {
     return `${obj.item._id}:${obj.discountId}`;
   },
 
-  orderDiscount: async (obj, _, { modules }) => {
+  orderDiscount: async (obj: OrderPositionDiscount, _, { modules }: Context) => {
     return modules.orders.discounts.findOrderDiscount({
       discountId: obj.discountId,
     });
   },
 
-  total(obj) {
+  total(obj: OrderPositionDiscount) {
     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-item-types.ts

@@ -1,12 +1,12 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
+import { Context } from '../../../context.js';
 import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Order } from '@unchainedshop/core-orders';
 import { OrderPosition, OrderPositionDiscount } from '@unchainedshop/core-orders';
-import { OrderPrice } from '@unchainedshop/core-orders';
 import { Product } from '@unchainedshop/core-products';
 import { Quotation } from '@unchainedshop/core-quotations';
 import { TokenSurrogate, WarehousingProvider } from '@unchainedshop/core-warehousing';
+import { Price } from '@unchainedshop/utils';
+import { ProductPricingSheet } from '@unchainedshop/core';
 
 const getPricingSheet = async (orderPosition: OrderPosition, context: Context) => {
   const { modules } = context;
@@ -14,9 +14,11 @@ const getPricingSheet = async (orderPosition: OrderPosition, context: Context) =
   const order = await modules.orders.findOrder({
     orderId: orderPosition.orderId,
   });
-  const pricingSheet = modules.orders.positions.pricingSheet(orderPosition, order.currency, context);
-
-  return pricingSheet;
+  return ProductPricingSheet({
+    calculation: orderPosition.calculation,
+    currency: order.currency,
+    quantity: orderPosition.quantity,
+  });
 };
 
 export const OrderItem = {
@@ -25,11 +27,11 @@ export const OrderItem = {
     _,
     context: Context,
   ): Promise<Array<OrderPositionDiscount>> {
-    const pricingSheet = await getPricingSheet(orderPosition, context);
+    const pricing = await getPricingSheet(orderPosition, context);
 
-    if (pricingSheet.isValid()) {
+    if (pricing.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!
-      return pricingSheet.discountPrices().map((discount) => ({
+      return pricing.discountPrices().map((discount) => ({
         item: orderPosition,
         ...discount,
       }));
@@ -114,18 +116,11 @@ export const OrderItem = {
     orderPosition: OrderPosition,
     params: { category: string; useNetPrice: boolean },
     context: Context,
-  ): Promise<OrderPrice> {
-    const pricingSheet = await getPricingSheet(orderPosition, context);
-
-    if (pricingSheet.isValid()) {
-      const price = pricingSheet.total(params);
-      return {
-        _id: crypto
-          .createHash('sha256')
-          .update([orderPosition._id, JSON.stringify(params), JSON.stringify(price)].join(''))
-          .digest('hex'),
-        ...price,
-      };
+  ): Promise<Price> {
+    const pricing = await getPricingSheet(orderPosition, context);
+
+    if (pricing.isValid()) {
+      return pricing.total(params);
     }
     return null;
   },
@@ -134,18 +129,11 @@ export const OrderItem = {
     orderPosition: OrderPosition,
     params: { useNetPrice: boolean },
     context: Context,
-  ): Promise<OrderPrice> {
-    const pricingSheet = await getPricingSheet(orderPosition, context);
-
-    if (pricingSheet.isValid()) {
-      const price = pricingSheet.unitPrice(params);
-      return {
-        _id: crypto
-          .createHash('sha256')
-          .update([`${orderPosition._id}-unit`, price.amount, pricingSheet.currency].join(''))
-          .digest('hex'),
-        ...price,
-      };
+  ): Promise<Price> {
+    const pricing = await getPricingSheet(orderPosition, context);
+
+    if (pricing.isValid()) {
+      return pricing.unitPrice(params);
     }
     return null;
   },

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

@@ -1,4 +1,5 @@
-import { Context } from '@unchainedshop/api';
+import { PaymentPricingSheet } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/core-orders';
 import { PaymentProvider } from '@unchainedshop/core-payment';
 
@@ -24,10 +25,13 @@ export const OrderPaymentCard: OrderPaymentCardHelperTypes = {
   discounts: async (obj, _, context) => {
     const { modules } = context;
     const order = await modules.orders.findOrder({ orderId: obj.orderId });
-    const pricingSheet = modules.orders.payments.pricingSheet(obj, order.currency, context);
-    if (pricingSheet.isValid()) {
+    const pricing = PaymentPricingSheet({
+      calculation: obj.calculation,
+      currency: order.currency,
+    });
+    if (pricing.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!
-      return pricingSheet.discountPrices().map((discount) => ({
+      return pricing.discountPrices().map((discount) => ({
         item: obj,
         ...discount,
       }));

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

@@ -1,35 +1,24 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
-import { OrderDiscount } from '@unchainedshop/core-orders';
+import { Context } from '../../../context.js';
 import { OrderPayment } from '@unchainedshop/core-orders';
-import { OrderPrice } from '@unchainedshop/core-orders';
+import { Price } from '@unchainedshop/utils';
 
-type HelperType<P, T> = (
-  orderDelivery: OrderPrice & { discountId: string; item: OrderPayment },
-  params: P,
-  context: Context,
-) => T;
+export const OrderPaymentDiscount = {
+  _id: (orderDelivery: Price & { discountId: string; item: OrderPayment }) =>
+    `${orderDelivery.item._id}:${orderDelivery.discountId}`,
 
-export interface OrderPaymentDiscountHelperTypes {
-  _id: HelperType<never, string>;
-  orderDiscount: HelperType<never, Promise<OrderDiscount>>;
-  total: HelperType<never, OrderPrice>;
-}
-
-export const OrderPaymentDiscount: OrderPaymentDiscountHelperTypes = {
-  _id: (obj) => `${obj.item._id}:${obj.discountId}`,
-
-  orderDiscount: (obj, _, { modules }) =>
+  orderDiscount: (
+    orderDelivery: Price & { discountId: string; item: OrderPayment },
+    _,
+    { modules }: Context,
+  ) =>
     modules.orders.discounts.findOrderDiscount({
-      discountId: obj.discountId,
+      discountId: orderDelivery.discountId,
     }),
 
-  total: (obj) => ({
-    _id: crypto
-      .createHash('sha256')
-      .update([`${obj.item._id}-${obj.discountId}`, obj.amount, obj.currency].join(''))
-      .digest('hex'),
-    amount: obj.amount,
-    currency: obj.currency,
-  }),
+  total(orderDelivery: Price & { discountId: string; item: OrderPayment }) {
+    return {
+      amount: orderDelivery.amount,
+      currency: orderDelivery.currency,
+    };
+  },
 };

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

@@ -1,4 +1,5 @@
-import { Context } from '@unchainedshop/api';
+import { PaymentPricingSheet } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/core-orders';
 import { PaymentProvider } from '@unchainedshop/core-payment';
 
@@ -24,10 +25,13 @@ export const OrderPaymentGeneric: OrderPaymentGenericHelperTypes = {
   discounts: async (obj, _, context) => {
     const { modules } = context;
     const order = await modules.orders.findOrder({ orderId: obj.orderId });
-    const pricingSheet = modules.orders.payments.pricingSheet(obj, order.currency, context);
-    if (pricingSheet.isValid()) {
+    const pricing = PaymentPricingSheet({
+      calculation: obj.calculation,
+      currency: order.currency,
+    });
+    if (pricing.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!
-      return pricingSheet.discountPrices().map((discount) => ({
+      return pricing.discountPrices().map((discount) => ({
         item: obj,
         ...discount,
       }));

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

@@ -1,4 +1,5 @@
-import { Context } from '@unchainedshop/api';
+import { PaymentPricingSheet } from '@unchainedshop/core';
+import { Context } from '../../../context.js';
 import { OrderPayment, OrderPaymentDiscount } from '@unchainedshop/core-orders';
 import { PaymentProvider } from '@unchainedshop/core-payment';
 
@@ -24,10 +25,13 @@ export const OrderPaymentInvoice: OrderPaymentInvoiceHelperTypes = {
   discounts: async (obj, _, context) => {
     const { modules } = context;
     const order = await modules.orders.findOrder({ orderId: obj.orderId });
-    const pricingSheet = modules.orders.payments.pricingSheet(obj, order.currency, context);
-    if (pricingSheet.isValid()) {
+    const pricing = PaymentPricingSheet({
+      calculation: obj.calculation,
+      currency: order.currency,
+    });
+    if (pricing.isValid()) {
       // IMPORTANT: Do not send any parameter to obj.discounts!
-      return pricingSheet.discountPrices().map((discount) => ({
+      return pricing.discountPrices().map((discount) => ({
         item: obj,
         ...discount,
       }));

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 } 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,22 +74,14 @@ 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);
+  total(order: OrderType, params: { category: string; useNetPrice: boolean }): Price {
+    const pricing = OrderPricingSheet({
+      calculation: order.calculation,
+      currency: order.currency,
+    });
 
-    if (pricingSheet.isValid()) {
-      const price = pricingSheet.total(params);
-      return {
-        _id: crypto
-          .createHash('sha256')
-          .update([order._id, JSON.stringify(params), JSON.stringify(price)].join(''))
-          .digest('hex'),
-        ...price,
-      };
+    if (pricing.isValid()) {
+      return pricing.total(params);
     }
     return null;
   },

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,50 @@
-import crypto from 'crypto';
-import { Context } from '@unchainedshop/api';
-import { PaymentError, PaymentProvider as PaymentProviderType } from '@unchainedshop/core-payment';
-import { PaymentPricingDirector } from '@unchainedshop/core-payment';
-
-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;
+import { Context } from '../../../context.js';
+import { PaymentProvider as PaymentProviderType } from '@unchainedshop/core-payment';
+import { PaymentDirector, PaymentPricingDirector } from '@unchainedshop/core';
+
+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 +52,6 @@ export const PaymentProvider: PaymentProviderHelperTypes = {
     };
 
     return {
-      _id: crypto
-        .createHash('sha256')
-        .update([paymentProvider._id, country, useNetPrice, order ? order._id : ''].join(''))
-        .digest('hex'),
       amount: orderPrice.amount,
       currencyCode: orderPrice.currency,
       countryCode: country,

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

@@ -1,7 +1,6 @@
 import accounting from 'accounting';
 
 type PriceType = {
-  _id?: string;
   isTaxable?: boolean;
   isNetPrice?: boolean;
   countryCode?: string;

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;