@unchainedshop/core 3.0.0-alpha7 → 3.0.0-rc2

package/src/directors/PaymentAdapter.ts

@@ -0,0 +1,118 @@
+import { log, LogLevel } from '@unchainedshop/logger';
+import { IBaseAdapter } from '@unchainedshop/utils';
+import { Order, OrderPayment } from '@unchainedshop/core-orders';
+import { PaymentConfiguration, PaymentProvider, PaymentProviderType } from '@unchainedshop/core-payment';
+import { 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 type 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;
+  isActive: (transactionContext?: any) => boolean;
+  isPayLaterAllowed: (transactionContext?: any) => boolean;
+  register: (transactionContext?: any) => Promise<any>;
+  sign: (transactionContext?: any) => Promise<string>;
+  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 & {
+      paymentProviderId: string;
+      paymentProvider: PaymentProvider;
+      modules: Modules;
+    },
+  ) => IPaymentActions;
+};
+
+export const PaymentAdapter: Omit<IPaymentAdapter, 'key' | 'label' | 'version'> = {
+  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;
+      },
+    };
+  },
+
+  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
+    return log(message, { level, ...options });
+  },
+};

package/src/directors/PaymentDirector.ts

@@ -0,0 +1,275 @@
+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 { OrderPayment, OrderPaymentStatus } from '@unchainedshop/core-orders';
+
+const buildPaymentProviderActionsContext = (
+  orderPayment: OrderPayment,
+  { transactionContext, ...rest }: { transactionContext: any; userId: string },
+) => ({
+  ...rest,
+  orderPayment,
+  paymentProviderId: orderPayment.paymentProviderId,
+  transactionContext: {
+    ...(transactionContext || {}),
+    ...(orderPayment.context || {}),
+  },
+});
+
+export type IPaymentDirector = IBaseDirector<IPaymentAdapter> & {
+  confirmOrderPayment: (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI,
+  ) => Promise<OrderPayment>;
+
+  cancelOrderPayment: (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI,
+  ) => Promise<OrderPayment>;
+
+  chargeOrderPayment: (
+    orderPayment: OrderPayment,
+    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 adapter = Adapter.actions(paymentProvider.configuration, {
+      paymentProvider,
+      paymentProviderId: paymentProvider._id,
+      ...newPaymentContext,
+      ...unchainedAPI,
+    });
+
+    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.message);
+          return false;
+        }
+      },
+
+      isPayLaterAllowed: () => {
+        try {
+          return adapter.isPayLaterAllowed(paymentContext.transactionContext);
+        } catch (error) {
+          logger.error(error.message);
+          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 (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI,
+  ): Promise<OrderPayment> => {
+    const { modules } = unchainedAPI;
+
+    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 (
+    orderPayment: OrderPayment,
+    paymentContext: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI,
+  ): Promise<OrderPayment> => {
+    const { modules } = unchainedAPI;
+
+    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 (
+    orderPayment: OrderPayment,
+    context: {
+      transactionContext: any;
+      userId: string;
+    },
+    unchainedAPI,
+  ): Promise<OrderPayment> => {
+    const { modules } = unchainedAPI;
+
+    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 paymentContext = buildPaymentProviderActionsContext(orderPayment, {
+      ...context,
+      transactionContext: {
+        ...context.transactionContext,
+        paymentCredentials,
+      },
+    });
+
+    const paymentProvider = await modules.payment.paymentProviders.findProvider({
+      paymentProviderId: orderPayment.paymentProviderId,
+    });
+    const actions = await PaymentDirector.actions(paymentProvider, paymentContext, 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: paymentContext.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;
+  },
+};

package/src/directors/PaymentPricingAdapter.ts

@@ -0,0 +1,86 @@
+import { PricingCalculation } from '@unchainedshop/utils';
+import {
+  BasePricingAdapter,
+  BasePricingAdapterContext,
+  IPricingAdapter,
+  IPricingSheet,
+} from '../directors/index.js';
+import { PaymentPricingSheet } from './PaymentPricingSheet.js';
+import { PaymentProvider } from '@unchainedshop/core-payment';
+import { OrderDiscount, OrderPayment, Order } from '@unchainedshop/core-orders';
+import { User } from '@unchainedshop/core-users';
+import { Modules } from '../modules.js';
+
+export interface PaymentPricingCalculation extends PricingCalculation {
+  discountId?: string;
+  isTaxable: boolean;
+  isNetPrice: boolean;
+  rate?: number;
+}
+export interface PaymentPricingAdapterContext extends BasePricingAdapterContext {
+  country?: string;
+  currency?: string;
+  user: User;
+  orderPayment: OrderPayment;
+  order: Order;
+  provider: PaymentProvider;
+  discounts: Array<OrderDiscount>;
+}
+
+export type IPaymentPricingSheet = IPricingSheet<PaymentPricingCalculation> & {
+  addFee: (params: { amount: number; isTaxable: boolean; isNetPrice: boolean; meta?: any }) => void;
+  addTax: (params: {
+    amount: number;
+    rate: number;
+    baseCategory?: string;
+    discountId?: string;
+    meta?: any;
+  }) => void;
+  addDiscount: (params: {
+    amount: number;
+    isTaxable: boolean;
+    isNetPrice: boolean;
+    discountId: string;
+    meta?: any;
+  }) => void;
+};
+
+export type IPaymentPricingAdapter<DiscountConfiguration = unknown> = IPricingAdapter<
+  PaymentPricingAdapterContext & { modules: Modules },
+  PaymentPricingCalculation,
+  IPaymentPricingSheet,
+  DiscountConfiguration
+>;
+
+const basePricingAdapter = BasePricingAdapter<PaymentPricingAdapterContext, PaymentPricingCalculation>();
+
+export const PaymentPricingAdapter: IPricingAdapter<
+  PaymentPricingAdapterContext,
+  PaymentPricingCalculation,
+  IPaymentPricingSheet
+> = {
+  ...basePricingAdapter,
+
+  isActivatedFor: () => {
+    return false;
+  },
+
+  actions: (params) => {
+    const { context } = params;
+    const { currency } = context.order;
+    const baseActions = basePricingAdapter.actions(params);
+    const resultSheet = PaymentPricingSheet({ currency });
+
+    return {
+      ...baseActions,
+      calculate: async () => {
+        const resultRaw = resultSheet.getRawPricingSheet();
+        resultRaw.forEach(({ amount, category }) =>
+          basePricingAdapter.log(`Payment Calculation -> ${category} ${amount}`),
+        );
+        return resultRaw;
+      },
+      resultSheet: () => resultSheet,
+    };
+  },
+};

package/src/directors/PaymentPricingDirector.ts

@@ -0,0 +1,94 @@
+import {
+  BasePricingDirector,
+  IPricingDirector,
+  IPaymentPricingAdapter,
+  IPaymentPricingSheet,
+  PaymentPricingAdapterContext,
+  PaymentPricingCalculation,
+} from '../directors/index.js';
+import { PaymentPricingSheet } from './PaymentPricingSheet.js';
+import { PaymentProvider } from '@unchainedshop/core-payment';
+import { OrderPayment, Order } from '@unchainedshop/core-orders';
+import { User } from '@unchainedshop/core-users';
+
+export type PaymentPricingContext =
+  | {
+      country?: string;
+      currency?: string;
+      user: User;
+      order: Order;
+      provider: PaymentProvider;
+      providerContext?: any;
+    }
+  | {
+      currency: string;
+      item: OrderPayment;
+    };
+
+export type IPaymentPricingDirector<DiscountConfiguration = unknown> = IPricingDirector<
+  PaymentPricingContext,
+  PaymentPricingCalculation,
+  PaymentPricingAdapterContext,
+  IPaymentPricingSheet,
+  IPaymentPricingAdapter<DiscountConfiguration>
+>;
+
+const baseDirector = BasePricingDirector<
+  PaymentPricingContext,
+  PaymentPricingAdapterContext,
+  PaymentPricingCalculation,
+  IPaymentPricingAdapter
+>('PaymentPricingDirector');
+
+export const PaymentPricingDirector: IPaymentPricingDirector<any> = {
+  ...baseDirector,
+
+  async buildPricingContext(context, unchainedAPI) {
+    const { modules } = unchainedAPI;
+
+    if ('item' in context) {
+      const { item, currency } = context;
+      const order = await modules.orders.findOrder({
+        orderId: item.orderId,
+      });
+      const provider = await modules.payment.paymentProviders.findProvider({
+        paymentProviderId: item.paymentProviderId,
+      });
+      const user = await modules.users.findUserById(order.userId);
+      const discounts = await modules.orders.discounts.findOrderDiscounts({
+        orderId: item.orderId,
+      });
+
+      return {
+        ...unchainedAPI,
+        country: order.countryCode,
+        currency,
+        order,
+        provider,
+        user,
+        discounts,
+        orderPayment: item,
+        providerContext: null,
+      };
+    }
+
+    return {
+      ...unchainedAPI,
+      country: context.country,
+      currency: context.currency,
+      order: context.order,
+      provider: context.provider,
+      user: context.user,
+      discounts: [],
+      orderPayment: null,
+      providerContext: context.providerContext,
+    };
+  },
+
+  calculationSheet(pricingContext, calculation) {
+    return PaymentPricingSheet({
+      calculation,
+      currency: pricingContext.currency,
+    });
+  },
+};

package/src/directors/PaymentPricingSheet.ts

@@ -0,0 +1,91 @@
+import {
+  PaymentPricingCalculation,
+  IPaymentPricingSheet,
+  BasePricingSheet,
+  IBasePricingSheet,
+  PricingSheetParams,
+} from '../directors/index.js';
+
+export enum PaymentPricingRowCategory {
+  Item = 'ITEM',
+  Payment = 'PAYMENT',
+  Discount = 'DISCOUNT',
+  Tax = 'TAX',
+}
+
+export const PaymentPricingSheet = (
+  params: PricingSheetParams<PaymentPricingCalculation>,
+): IPaymentPricingSheet => {
+  const basePricingSheet: IBasePricingSheet<PaymentPricingCalculation> = BasePricingSheet(params);
+
+  const pricingSheet: IPaymentPricingSheet = {
+    ...basePricingSheet,
+
+    addDiscount({ amount, isTaxable, isNetPrice, discountId, meta }) {
+      basePricingSheet.calculation.push({
+        category: PaymentPricingRowCategory.Discount,
+        amount,
+        isTaxable,
+        isNetPrice,
+        discountId,
+        meta,
+      });
+    },
+
+    addFee({ amount, isTaxable, isNetPrice, meta }) {
+      basePricingSheet.calculation.push({
+        category: PaymentPricingRowCategory.Payment,
+        amount,
+        isTaxable,
+        isNetPrice,
+        meta,
+      });
+    },
+
+    addTax({ amount, rate, meta }) {
+      basePricingSheet.calculation.push({
+        category: PaymentPricingRowCategory.Tax,
+        amount,
+        isTaxable: false,
+        isNetPrice: false,
+        rate,
+        meta,
+      });
+    },
+
+    taxSum(filter) {
+      return basePricingSheet.sum({
+        category: PaymentPricingRowCategory.Tax,
+        ...(filter || {}),
+      });
+    },
+
+    discountPrices(explicitDiscountId) {
+      const discountIds = pricingSheet
+        .filterBy({
+          category: PaymentPricingRowCategory.Discount,
+          discountId: explicitDiscountId,
+        })
+        .map(({ discountId }) => discountId);
+
+      return [...new Set(discountIds)]
+        .map((discountId) => {
+          const amount = basePricingSheet.sum({
+            category: PaymentPricingRowCategory.Discount,
+            discountId,
+          });
+          if (!amount) {
+            return null;
+          }
+          return {
+            discountId,
+            amount: Math.round(amount),
+            currency: basePricingSheet.currency,
+          };
+        })
+        .filter(Boolean);
+    },
+  };
+
+  return pricingSheet;
+};

package/src/directors/ProductDiscountAdapter.ts

@@ -0,0 +1,10 @@
+import {
+  BaseDiscountAdapter,
+  IDiscountAdapter,
+  ProductDiscountConfiguration,
+} from '../directors/index.js';
+
+export const ProductDiscountAdapter: Omit<
+  IDiscountAdapter<ProductDiscountConfiguration, any>,
+  'key' | 'label' | 'version'
+> = BaseDiscountAdapter;

package/src/directors/ProductDiscountConfiguration.ts

@@ -0,0 +1,18 @@
+import { Product, ProductConfiguration } from '@unchainedshop/core-products';
+
+type ResolvedConfiguration = {
+  fixedRate?: number;
+  rate?: number;
+  isNetPrice?: boolean;
+  taxRate?: number;
+} & Record<string, any>;
+
+export type PriceConfigurationResolver = (
+  product: Product,
+  quantity: number,
+  configuration: Array<ProductConfiguration>,
+) => ResolvedConfiguration | null;
+
+export interface ProductDiscountConfiguration extends ResolvedConfiguration {
+  customPriceConfigurationResolver?: PriceConfigurationResolver;
+}

package/src/directors/ProductDiscountDirector.ts

@@ -0,0 +1,5 @@
+import { BaseDiscountDirector, ProductDiscountConfiguration } from '../directors/index.js';
+
+export const ProductDiscountDirector = BaseDiscountDirector<ProductDiscountConfiguration, any>(
+  'ProductDiscountDirector',
+);