@unchainedshop/core 4.3.5 → 4.4.0

package/src/directors/OrderPricingAdapter.ts

@@ -1,63 +0,0 @@
-import {
-  IOrderPricingSheet,
-  OrderPricingCalculation,
-  OrderPricingSheet,
-  BasePricingAdapter,
-  IPricingAdapter,
-  BasePricingAdapterContext,
-} from '../directors/index.js';
-import {
-  Order,
-  OrderDelivery,
-  OrderDiscount,
-  OrderPayment,
-  OrderPosition,
-} from '@unchainedshop/core-orders';
-import { User } from '@unchainedshop/core-users';
-import { Modules } from '../modules.js';
-
-export interface OrderPricingAdapterContext extends BasePricingAdapterContext {
-  currencyCode?: string;
-  discounts: OrderDiscount[];
-  order: Order;
-  orderPositions: OrderPosition[];
-  orderDelivery: OrderDelivery | null;
-  orderPayment: OrderPayment | null;
-  user: User;
-}
-
-export type IOrderPricingAdapter<DiscountConfiguration = unknown> = IPricingAdapter<
-  OrderPricingAdapterContext & { modules: Modules },
-  OrderPricingCalculation,
-  IOrderPricingSheet,
-  DiscountConfiguration
->;
-
-const basePricingAdapter = BasePricingAdapter<OrderPricingAdapterContext, OrderPricingCalculation>();
-
-export const OrderPricingAdapter: IOrderPricingAdapter = {
-  ...basePricingAdapter,
-
-  isActivatedFor: () => {
-    return false;
-  },
-
-  actions: (params) => {
-    const { context } = params;
-    const { currencyCode } = context;
-    const baseActions = basePricingAdapter.actions(params);
-    const resultSheet = OrderPricingSheet({ currencyCode });
-
-    return {
-      ...baseActions,
-      calculate: async () => {
-        const resultRaw = resultSheet.getRawPricingSheet();
-        resultRaw.forEach(({ amount, category }) =>
-          basePricingAdapter.log(`Order Pricing Calculation -> ${category} ${amount}`),
-        );
-        return resultRaw;
-      },
-      resultSheet: () => resultSheet,
-    };
-  },
-};

package/src/directors/OrderPricingDirector.ts

@@ -1,74 +0,0 @@
-import {
-  IOrderPricingSheet,
-  OrderPricingCalculation,
-  OrderPricingSheet,
-  IOrderPricingAdapter,
-  OrderPricingAdapterContext,
-  BasePricingDirector,
-  PricingDiscount,
-  IPricingDirector,
-} from '../directors/index.js';
-import { Order, OrderDelivery, OrderPayment, OrderPosition } from '@unchainedshop/core-orders';
-
-export interface OrderPricingContext {
-  currencyCode: string;
-  order: Order;
-  orderDelivery: OrderDelivery | null;
-  orderPositions: OrderPosition[];
-  orderPayment: OrderPayment | null;
-}
-
-export type OrderPricingDiscount = PricingDiscount & {
-  delivery?: OrderDelivery;
-  item?: OrderPosition;
-  order?: Order;
-  payment?: OrderPayment;
-};
-
-export type IOrderPricingDirector<DiscountConfiguration = unknown> = IPricingDirector<
-  OrderPricingContext,
-  OrderPricingCalculation,
-  OrderPricingAdapterContext,
-  IOrderPricingSheet,
-  IOrderPricingAdapter<DiscountConfiguration>
->;
-
-const baseDirector = BasePricingDirector<
-  OrderPricingContext,
-  OrderPricingAdapterContext,
-  OrderPricingCalculation,
-  IOrderPricingAdapter
->('OrderPricingDirector');
-
-export const OrderPricingDirector: IOrderPricingDirector<any> = {
-  ...baseDirector,
-
-  buildPricingContext: async (context, unchainedAPI) => {
-    const { modules } = unchainedAPI;
-    const { order, currencyCode } = context;
-
-    const user = await modules.users.findUserById(order.userId);
-    const discounts = await modules.orders.discounts.findOrderDiscounts({
-      orderId: order._id,
-    });
-
-    return {
-      ...unchainedAPI,
-      countryCode: order.countryCode,
-      currencyCode,
-      discounts,
-      order,
-      orderDelivery: context.orderDelivery,
-      orderPayment: context.orderPayment,
-      orderPositions: context.orderPositions,
-      user: user!,
-    };
-  },
-
-  calculationSheet(pricingContext, calculation) {
-    return OrderPricingSheet({
-      calculation,
-      currencyCode: pricingContext.currencyCode,
-    });
-  },
-};

package/src/directors/OrderPricingSheet.ts

@@ -1,148 +0,0 @@
-import { PricingCalculation } from '@unchainedshop/utils';
-
-import {
-  BasePricingSheet,
-  IPricingSheet,
-  IBasePricingSheet,
-  PricingSheetParams,
-} from '../directors/index.js';
-
-export interface OrderPricingCalculation extends PricingCalculation {
-  discountId?: string;
-}
-
-export enum OrderPricingRowCategory {
-  Items = 'ITEMS',
-  Discounts = 'DISCOUNTS',
-  Taxes = 'TAXES',
-  Delivery = 'DELIVERY',
-  Payment = 'PAYMENT',
-}
-
-export interface IOrderPricingSheet extends IPricingSheet<OrderPricingCalculation> {
-  addDelivery: (params: { amount: number; taxAmount: number; meta?: any }) => void;
-  addDiscount: (params: { amount: number; taxAmount: number; discountId: string; meta?: any }) => void;
-  addItems: (params: { amount: number; taxAmount: number; meta?: any }) => void;
-  addPayment: (params: { amount: number; taxAmount: number; meta?: any }) => void;
-}
-
-export const OrderPricingSheet = (
-  params: PricingSheetParams<OrderPricingCalculation>,
-): IOrderPricingSheet => {
-  const basePricingSheet: IBasePricingSheet<OrderPricingCalculation> = BasePricingSheet(params);
-
-  const addTaxIfAvailabile = (category: string, taxAmount?: number, meta?: any, discountId?: string) => {
-    if (taxAmount) {
-      basePricingSheet.calculation.push({
-        category: OrderPricingRowCategory.Taxes,
-        amount: taxAmount,
-        baseCategory: category,
-        discountId,
-        meta,
-      });
-    }
-  };
-
-  const pricingSheet: IOrderPricingSheet = {
-    ...basePricingSheet,
-
-    addItems({ amount, taxAmount, meta }) {
-      basePricingSheet.calculation.push({
-        category: OrderPricingRowCategory.Items,
-        amount,
-        meta,
-      });
-
-      addTaxIfAvailabile(OrderPricingRowCategory.Items, taxAmount, meta);
-    },
-
-    addDiscount({ amount, taxAmount, discountId, meta }) {
-      basePricingSheet.calculation.push({
-        category: OrderPricingRowCategory.Discounts,
-        amount,
-        discountId,
-        meta,
-      });
-
-      addTaxIfAvailabile(OrderPricingRowCategory.Discounts, taxAmount, meta, discountId);
-    },
-
-    addDelivery({ amount, taxAmount, meta }) {
-      basePricingSheet.calculation.push({
-        category: OrderPricingRowCategory.Delivery,
-        amount,
-        meta,
-      });
-
-      addTaxIfAvailabile(OrderPricingRowCategory.Delivery, taxAmount, meta);
-    },
-
-    addPayment({ amount, taxAmount, meta }) {
-      basePricingSheet.calculation.push({
-        category: OrderPricingRowCategory.Payment,
-        amount,
-        meta,
-      });
-
-      addTaxIfAvailabile(OrderPricingRowCategory.Payment, taxAmount, meta);
-    },
-
-    taxSum(filter) {
-      return basePricingSheet.sum({
-        category: OrderPricingRowCategory.Taxes,
-        ...(filter || {}),
-      });
-    },
-
-    gross() {
-      // tax is included 2 times, this is only true for Order Pricing!
-      return basePricingSheet.sum() - this.taxSum();
-    },
-
-    net() {
-      return basePricingSheet.sum() - this.taxSum() - this.taxSum();
-    },
-
-    total({ category, useNetPrice, discountId } = { useNetPrice: false }) {
-      const taxAmount = this.taxSum({ baseCategory: category, discountId });
-      const amount = this.sum({ category, discountId }) - taxAmount;
-
-      // Sum does not contain taxes when filtering by category, it's net in that case and gross if there is no category
-      const netAmount = !category ? amount - taxAmount : amount;
-
-      return {
-        amount: Math.round(useNetPrice ? netAmount : netAmount + taxAmount),
-        currencyCode: this.currencyCode,
-      };
-    },
-
-    discountPrices(explicitDiscountId) {
-      const discountIds = pricingSheet
-        .filterBy({
-          category: OrderPricingRowCategory.Discounts,
-          discountId: explicitDiscountId,
-        })
-        .map(({ discountId }) => discountId)
-        .filter(Boolean) as string[];
-
-      return [...new Set(discountIds)]
-        .map((discountId) => {
-          const amount = basePricingSheet.sum({
-            category: OrderPricingRowCategory.Discounts,
-            discountId,
-          });
-          if (!amount) {
-            return null;
-          }
-          return {
-            discountId,
-            amount: Math.round(amount),
-            currencyCode: basePricingSheet.currencyCode,
-          };
-        })
-        .filter(Boolean) as { discountId: string; amount: number; currencyCode: string }[];
-    },
-  };
-
-  return pricingSheet;
-};

package/src/directors/PaymentAdapter.ts

@@ -1,118 +0,0 @@
-import { BaseAdapter } from '@unchainedshop/utils';
-import type { IBaseAdapter } from '@unchainedshop/utils';
-import type { Order, OrderPayment } from '@unchainedshop/core-orders';
-import type {
-  PaymentConfiguration,
-  PaymentProvider,
-  PaymentProviderType,
-} from '@unchainedshop/core-payment';
-import type { Modules } from '../modules.js';
-
-export enum PaymentError {
-  ADAPTER_NOT_FOUND = 'ADAPTER_NOT_FOUND',
-  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
-  INCOMPLETE_CONFIGURATION = 'INCOMPLETE_CONFIGURATION',
-  WRONG_CREDENTIALS = 'WRONG_CREDENTIALS',
-}
-
-export interface ChargeResult {
-  transactionId?: string;
-  [key: string]: any;
-}
-
-export type PaymentChargeActionResult = ChargeResult & {
-  credentials?: {
-    token: string;
-    [key: string]: any;
-  };
-};
-export interface IPaymentActions {
-  charge: (transactionContext?: any) => Promise<PaymentChargeActionResult | false>;
-  configurationError: (transactionContext?: any) => PaymentError | null;
-  isActive: (transactionContext?: any) => boolean;
-  isPayLaterAllowed: (transactionContext?: any) => boolean;
-  register: (transactionContext?: any) => Promise<any>;
-  sign: (transactionContext?: any) => Promise<string | null>;
-  validate: (token?: any) => Promise<boolean>;
-  cancel: (transactionContext?: any) => Promise<boolean>;
-  confirm: (transactionContext?: any) => Promise<boolean>;
-}
-export interface PaymentContext {
-  userId?: string;
-  order?: Order;
-  orderPayment?: OrderPayment;
-  transactionContext?: any; // User for singing and charging a payment
-  token?: any; // Used for validation
-  meta?: any;
-}
-
-export type IPaymentAdapter = IBaseAdapter & {
-  initialConfiguration: PaymentConfiguration;
-
-  typeSupported: (type: PaymentProviderType) => boolean;
-
-  actions: (
-    config: PaymentConfiguration,
-    context: PaymentContext & {
-      paymentProvider: PaymentProvider;
-      modules: Modules;
-    },
-  ) => IPaymentActions;
-};
-
-export const PaymentAdapter: Omit<IPaymentAdapter, 'key' | 'label' | 'version'> = {
-  ...BaseAdapter,
-  initialConfiguration: [],
-
-  typeSupported: () => {
-    return false;
-  },
-
-  actions: () => {
-    return {
-      configurationError: () => {
-        return PaymentError.NOT_IMPLEMENTED;
-      },
-
-      isActive: () => {
-        return false;
-      },
-
-      isPayLaterAllowed: () => {
-        return false;
-      },
-
-      charge: async () => {
-        // if you return true, the status will be changed to PAID
-
-        // if you return false, the order payment status stays the
-        // same but the order status might change
-
-        // if you throw an error, you cancel the checkout process
-        return false;
-      },
-
-      register: async () => {
-        return {
-          token: '',
-        };
-      },
-
-      sign: async () => {
-        return null;
-      },
-
-      validate: async () => {
-        return false;
-      },
-
-      cancel: async () => {
-        return false;
-      },
-
-      confirm: async () => {
-        return false;
-      },
-    };
-  },
-};

package/src/directors/PaymentDirector.ts

@@ -1,297 +0,0 @@
-import { BaseDirector, IBaseDirector } from '@unchainedshop/utils';
-import { createLogger } from '@unchainedshop/logger';
-import { PaymentError, IPaymentActions, IPaymentAdapter, PaymentContext } from './PaymentAdapter.js';
-import { PaymentProvider } from '@unchainedshop/core-payment';
-import { Order, OrderPayment, OrderPaymentStatus } from '@unchainedshop/core-orders';
-
-const buildPaymentProviderActionsContext = (
-  orderPayment: OrderPayment,
-  { transactionContext, ...rest }: { transactionContext: any; userId: string },
-): PaymentContext => ({
-  ...rest,
-  orderPayment,
-  transactionContext: {
-    ...(transactionContext || {}),
-    ...(orderPayment.context || {}),
-  },
-});
-
-export type IPaymentDirector = IBaseDirector<IPaymentAdapter> & {
-  confirmOrderPayment: (
-    order: Order,
-    paymentContext: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI,
-  ) => Promise<OrderPayment>;
-
-  cancelOrderPayment: (
-    order: Order,
-    paymentContext: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI,
-  ) => Promise<OrderPayment>;
-
-  chargeOrderPayment: (
-    order: Order,
-    context: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI,
-  ) => Promise<OrderPayment>;
-
-  actions: (
-    paymentProvider: PaymentProvider,
-    paymentContext: PaymentContext,
-    unchainedAPI,
-  ) => Promise<IPaymentActions>;
-};
-const logger = createLogger('unchained:core:payment');
-const baseDirector = BaseDirector<IPaymentAdapter>('PaymentDirector');
-
-export const PaymentDirector: IPaymentDirector = {
-  ...baseDirector,
-
-  actions: async (paymentProvider, paymentContext, unchainedAPI) => {
-    const Adapter = baseDirector.getAdapter(paymentProvider.adapterKey) as IPaymentAdapter;
-
-    if (!Adapter) {
-      throw new Error(`Payment Plugin ${paymentProvider.adapterKey} not available`);
-    }
-
-    const newPaymentContext: PaymentContext = {
-      ...paymentContext,
-    };
-
-    if (paymentContext?.orderPayment) {
-      const { modules } = unchainedAPI;
-      const { orderId } = paymentContext.orderPayment;
-      const order =
-        paymentContext?.order ||
-        (await modules.orders.findOrder({
-          orderId,
-        }));
-
-      newPaymentContext.order = order;
-    }
-
-    const context = { ...newPaymentContext, ...unchainedAPI, paymentProvider };
-    const adapter = Adapter.actions(paymentProvider.configuration, context);
-
-    return {
-      configurationError: () => {
-        try {
-          const error = adapter.configurationError();
-          return error;
-        } catch {
-          return PaymentError.ADAPTER_NOT_FOUND;
-        }
-      },
-
-      isActive: () => {
-        try {
-          return adapter.isActive(paymentContext.transactionContext);
-        } catch (error) {
-          logger.error(error);
-          return false;
-        }
-      },
-
-      isPayLaterAllowed: () => {
-        try {
-          return adapter.isPayLaterAllowed(paymentContext.transactionContext);
-        } catch (error) {
-          logger.error(error);
-          return false;
-        }
-      },
-
-      charge: async () => {
-        return adapter.charge(paymentContext.transactionContext);
-      },
-
-      register: async () => {
-        return adapter.register(paymentContext.transactionContext);
-      },
-
-      sign: async () => {
-        return adapter.sign(paymentContext.transactionContext);
-      },
-
-      validate: async () => {
-        const validated = await adapter.validate(paymentContext.token);
-        return !!validated;
-      },
-
-      cancel: async () => {
-        return adapter.cancel(paymentContext.transactionContext);
-      },
-
-      confirm: async () => {
-        return adapter.confirm(paymentContext.transactionContext);
-      },
-    };
-  },
-
-  confirmOrderPayment: async (
-    order: Order,
-    paymentContext: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI,
-  ): Promise<OrderPayment> => {
-    const { modules } = unchainedAPI;
-
-    const orderPayment =
-      order.paymentId &&
-      (await modules.orders.payments.findOrderPayment({
-        orderPaymentId: order.paymentId,
-      }));
-
-    if (!orderPayment) throw new Error('Order payment not set');
-
-    if (modules.orders.payments.normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
-      return orderPayment;
-    }
-
-    const paymentProvider = await modules.payment.paymentProviders.findProvider({
-      paymentProviderId: orderPayment.paymentProviderId,
-    });
-    const actions = await PaymentDirector.actions(
-      paymentProvider,
-      buildPaymentProviderActionsContext(orderPayment, paymentContext),
-      unchainedAPI,
-    );
-
-    const arbitraryResponseData = await actions.confirm();
-
-    if (arbitraryResponseData) {
-      return modules.orders.payments.updateStatus(orderPayment._id, {
-        status: OrderPaymentStatus.PAID,
-        info: JSON.stringify(arbitraryResponseData),
-      });
-    }
-
-    return orderPayment;
-  },
-
-  cancelOrderPayment: async (
-    order: Order,
-    paymentContext: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI,
-  ): Promise<OrderPayment> => {
-    const { modules } = unchainedAPI;
-
-    const orderPayment =
-      order.paymentId &&
-      (await modules.orders.payments.findOrderPayment({
-        orderPaymentId: order.paymentId,
-      }));
-
-    if (!orderPayment) throw new Error('Order payment not set');
-
-    if (modules.orders.payments.normalizedStatus(orderPayment) !== OrderPaymentStatus.PAID) {
-      return orderPayment;
-    }
-
-    const paymentProvider = await modules.payment.paymentProviders.findProvider({
-      paymentProviderId: orderPayment.paymentProviderId,
-    });
-    const actions = await PaymentDirector.actions(
-      paymentProvider,
-      buildPaymentProviderActionsContext(orderPayment, paymentContext),
-      unchainedAPI,
-    );
-    const arbitraryResponseData = await actions.cancel();
-
-    if (arbitraryResponseData) {
-      return modules.orders.payments.updateStatus(orderPayment._id, {
-        status: OrderPaymentStatus.REFUNDED,
-        info: JSON.stringify(arbitraryResponseData),
-      });
-    }
-
-    return orderPayment;
-  },
-
-  chargeOrderPayment: async (
-    order: Order,
-    context: {
-      transactionContext: any;
-      userId: string;
-    },
-    unchainedAPI,
-  ): Promise<OrderPayment> => {
-    const { modules } = unchainedAPI;
-
-    const orderPayment =
-      order.paymentId &&
-      (await modules.orders.payments.findOrderPayment({
-        orderPaymentId: order.paymentId,
-      }));
-
-    if (!orderPayment) throw new Error('Order payment not set');
-
-    if (modules.orders.payments.normalizedStatus(orderPayment) !== OrderPaymentStatus.OPEN) {
-      return orderPayment;
-    }
-
-    const paymentCredentials =
-      context.transactionContext?.paymentCredentials ||
-      (await modules.payment.paymentCredentials.findPaymentCredential({
-        userId: context.userId,
-        paymentProviderId: orderPayment.paymentProviderId,
-        isPreferred: true,
-      }));
-
-    const paymentProvider = await modules.payment.paymentProviders.findProvider({
-      paymentProviderId: orderPayment.paymentProviderId,
-    });
-
-    const actions = await PaymentDirector.actions(
-      paymentProvider,
-      buildPaymentProviderActionsContext(orderPayment, {
-        ...context,
-        transactionContext: {
-          ...context.transactionContext,
-          paymentCredentials,
-        },
-      }),
-      unchainedAPI,
-    );
-    const result = await actions.charge();
-
-    if (!result) return orderPayment;
-
-    const { credentials, ...arbitraryResponseData } = result;
-
-    if (credentials) {
-      const { token, ...meta } = credentials;
-      await modules.payment.paymentCredentials.upsertCredentials({
-        userId: context.userId,
-        paymentProviderId: orderPayment.paymentProviderId,
-        token,
-        ...meta,
-      });
-    }
-
-    if (arbitraryResponseData) {
-      const { transactionId, ...info } = arbitraryResponseData;
-      return modules.orders.payments.updateStatus(orderPayment._id, {
-        transactionId,
-        status: OrderPaymentStatus.PAID,
-        info: JSON.stringify(info),
-      });
-    }
-
-    return orderPayment;
-  },
-};