@unchainedshop/core-payment 3.0.0-alpha7 → 3.0.0-rc1

package/src/module/configurePaymentProvidersModule.ts

@@ -1,108 +1,12 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import {
-  PaymentChargeActionResult,
-  PaymentContext,
-  PaymentCredentials,
-  PaymentError,
-  PaymentInterface,
-  PaymentProvider,
-} from '../types.js';
 import { emit, registerEvents } from '@unchainedshop/events';
 import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
-import { PaymentPricingContext, PaymentPricingDirector } from '../director/PaymentPricingDirector.js';
-import { PaymentPricingSheet } from '../director/PaymentPricingSheet.js';
-import { PaymentDirector } from '../director/PaymentDirector.js';
-import { paymentSettings } from '../payment-settings.js';
-import { Order } from '@unchainedshop/core-orders';
-import {
-  IPaymentPricingSheet,
-  PaymentPricingCalculation,
-  PaymentProviderType,
-} from '../payment-index.js';
+import { PaymentProvider } from '../db/PaymentProvidersCollection.js';
 
-export type PaymentProvidersModules = {
-  // Queries
-  create: (doc: PaymentProvider) => Promise<PaymentProvider>;
-  update: (_id: string, doc: PaymentProvider) => Promise<PaymentProvider>;
-  delete: (_id: string) => Promise<PaymentProvider>;
-  count: (query: mongodb.Filter<PaymentProvider>) => Promise<number>;
-  findProvider: (
-    query: mongodb.Filter<PaymentProvider> & {
-      paymentProviderId: string;
-    },
-    options?: mongodb.FindOptions,
-  ) => Promise<PaymentProvider>;
-  findProviders: (
-    query: mongodb.Filter<PaymentProvider>,
-    options?: mongodb.FindOptions,
-  ) => Promise<Array<PaymentProvider>>;
-
-  providerExists: (query: { paymentProviderId: string }) => Promise<boolean>;
-
-  // Payment adapter
-  findSupported: (
-    query: { order: Order },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<Array<PaymentProvider>>;
-  determineDefault: (
-    paymentProviders: Array<PaymentProvider>,
-    params: { order: Order; paymentCredentials?: Array<PaymentCredentials> },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<PaymentProvider>;
-
-  findInterface: (query: PaymentProvider) => PaymentInterface;
-  findInterfaces: (query: { type: PaymentProviderType }) => Array<PaymentInterface>;
-
-  pricingSheet: (params: {
-    calculation: Array<PaymentPricingCalculation>;
-    currency: string;
-  }) => IPaymentPricingSheet;
-
-  configurationError: (
-    paymentProvider: PaymentProvider,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<PaymentError>;
-
-  isActive: (paymentProvider: PaymentProvider, unchainedAPI: UnchainedCore) => Promise<boolean>;
-
-  isPayLaterAllowed: (paymentProvider: PaymentProvider, unchainedAPI: UnchainedCore) => Promise<boolean>;
-
-  calculate: (
-    pricingContext: PaymentPricingContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<Array<PaymentPricingCalculation>>;
-
-  charge: (
-    paymentProviderId: string,
-    paymentContext: PaymentContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<PaymentChargeActionResult | false>;
-  register: (
-    paymentProviderId: string,
-    paymentContext: PaymentContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<any>;
-  sign: (
-    paymentProviderId: string,
-    paymentContext: PaymentContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<string>;
-  validate: (
-    paymentProviderId: string,
-    paymentContext: PaymentContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<boolean>;
-  cancel: (
-    paymentProviderId: string,
-    paymentContext: PaymentContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<boolean>;
-  confirm: (
-    paymentProviderId: string,
-    paymentContext: PaymentContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<boolean>;
-};
+export interface PaymentInterface {
+  _id: string;
+  label: string;
+  version: string;
+}
 
 const PAYMENT_PROVIDER_EVENTS: string[] = [
   'PAYMENT_PROVIDER_CREATE',
@@ -114,47 +18,42 @@ export const buildFindSelector = ({ type }: mongodb.Filter<PaymentProvider> = {}
   return { ...(type ? { type } : {}), deleted: null };
 };
 
-const asyncFilter = async (arr, predicate) => {
-  const results = await Promise.all(arr.map(predicate));
-
-  return arr.filter((_v, index) => results[index]);
-};
-
 export const configurePaymentProvidersModule = (
   PaymentProviders: mongodb.Collection<PaymentProvider>,
-): PaymentProvidersModules => {
+) => {
   registerEvents(PAYMENT_PROVIDER_EVENTS);
 
-  const getPaymentAdapter = async (
-    paymentProviderId: string,
-    paymentContext: PaymentContext,
-    unchainedAPI: UnchainedCore,
-  ) => {
-    const provider = await PaymentProviders.findOne(generateDbFilterById(paymentProviderId), {});
-
-    return PaymentDirector.actions(provider, paymentContext, unchainedAPI);
-  };
-
   return {
     // Queries
-    count: async (query) => {
+    count: async (query: mongodb.Filter<PaymentProvider>): Promise<number> => {
       const providerCount = await PaymentProviders.countDocuments(buildFindSelector(query));
       return providerCount;
     },
 
-    findProvider: async ({ paymentProviderId, ...query }, options) => {
+    findProvider: async (
+      {
+        paymentProviderId,
+        ...query
+      }: mongodb.Filter<PaymentProvider> & {
+        paymentProviderId: string;
+      },
+      options?: mongodb.FindOptions,
+    ): Promise<PaymentProvider> => {
       return PaymentProviders.findOne(
         paymentProviderId ? generateDbFilterById(paymentProviderId) : query,
         options,
       );
     },
 
-    findProviders: async (query, options = { sort: { created: 1 } }) => {
+    findProviders: async (
+      query: mongodb.Filter<PaymentProvider>,
+      options: mongodb.FindOptions = { sort: { created: 1 } },
+    ): Promise<Array<PaymentProvider>> => {
       const providers = PaymentProviders.find(buildFindSelector(query), options);
       return providers.toArray();
     },
 
-    providerExists: async ({ paymentProviderId }) => {
+    providerExists: async ({ paymentProviderId }: { paymentProviderId: string }): Promise<boolean> => {
       const providerCount = await PaymentProviders.countDocuments(
         generateDbFilterById(paymentProviderId, { deleted: null }),
         { limit: 1 },
@@ -162,124 +61,11 @@ export const configurePaymentProvidersModule = (
       return !!providerCount;
     },
 
-    findInterface: (paymentProvider) => {
-      const Adapter = PaymentDirector.getAdapter(paymentProvider.adapterKey);
-      if (!Adapter) return null;
-      return {
-        _id: Adapter.key,
-        label: Adapter.label,
-        version: Adapter.version,
-      };
-    },
-
-    pricingSheet: (params) => {
-      return PaymentPricingSheet(params);
-    },
-
-    findInterfaces: ({ type }) => {
-      return PaymentDirector.getAdapters()
-        .filter((Adapter) => Adapter.typeSupported(type))
-        .map((Adapter) => ({
-          _id: Adapter.key,
-          label: Adapter.label,
-          version: Adapter.version,
-        }));
-    },
-
-    findSupported: async (paymentContext, unchainedAPI) => {
-      const allProviders = await PaymentProviders.find({ deleted: null }).toArray();
-      const providers: PaymentProvider[] = await asyncFilter(
-        allProviders,
-        async (provider: PaymentProvider) => {
-          try {
-            const director = await PaymentDirector.actions(provider, paymentContext, unchainedAPI);
-            return director.isActive();
-          } catch {
-            return false;
-          }
-        },
-      );
-
-      return paymentSettings.filterSupportedProviders(
-        {
-          providers,
-          order: paymentContext.order,
-        },
-        unchainedAPI,
-      );
-    },
-
-    determineDefault: async (paymentProviders, deliveryContext, unchainedAPI) => {
-      return paymentSettings.determineDefaultProvider(
-        {
-          providers: paymentProviders,
-          ...deliveryContext,
-        },
-        unchainedAPI,
-      );
-    },
-
-    // Payment Adapter
-
-    configurationError: async (paymentProvider, unchainedAPI) => {
-      const actions = await PaymentDirector.actions(paymentProvider, {}, unchainedAPI);
-      return actions.configurationError();
-    },
-
-    calculate: async (pricingContext, unchainedAPI) => {
-      const pricing = await PaymentPricingDirector.actions(pricingContext, unchainedAPI);
-      return pricing.calculate();
-    },
-
-    isActive: async (paymentProvider, unchainedAPI) => {
-      const actions = await PaymentDirector.actions(paymentProvider, {}, unchainedAPI);
-      return actions.isActive();
-    },
-
-    isPayLaterAllowed: async (paymentProvider, unchainedAPI) => {
-      const actions = await PaymentDirector.actions(paymentProvider, {}, unchainedAPI);
-      return actions.isPayLaterAllowed();
-    },
-
-    charge: async (paymentProviderId, paymentContext, unchainedAPI) => {
-      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, unchainedAPI);
-      return adapter.charge();
-    },
-
-    register: async (paymentProviderId, paymentContext, unchainedAPI) => {
-      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, unchainedAPI);
-      return adapter.register();
-    },
-
-    sign: async (paymentProviderId, paymentContext, unchainedAPI) => {
-      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, unchainedAPI);
-      return adapter.sign();
-    },
-
-    validate: async (paymentProviderId, paymentContext, unchainedAPI) => {
-      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, unchainedAPI);
-      return adapter.validate();
-    },
-
-    cancel: async (paymentProviderId, paymentContext, unchainedAPI) => {
-      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, unchainedAPI);
-      return adapter.cancel();
-    },
-
-    confirm: async (paymentProviderId, paymentContext, unchainedAPI) => {
-      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, unchainedAPI);
-      return adapter.confirm();
-    },
-
     // Mutations
-    create: async (doc) => {
-      const Adapter = PaymentDirector.getAdapter(doc.adapterKey);
-      if (!Adapter) return null;
-
+    create: async (doc: PaymentProvider): Promise<PaymentProvider> => {
       const { insertedId: paymentProviderId } = await PaymentProviders.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
-        configuration: Adapter.initialConfiguration,
         ...doc,
       });
 
@@ -291,7 +77,7 @@ export const configurePaymentProvidersModule = (
       return paymentProvider;
     },
 
-    update: async (_id: string, doc: PaymentProvider) => {
+    update: async (_id: string, doc: PaymentProvider): Promise<PaymentProvider> => {
       const paymentProvider = await PaymentProviders.findOneAndUpdate(
         generateDbFilterById(_id),
         {
@@ -306,7 +92,7 @@ export const configurePaymentProvidersModule = (
       return paymentProvider;
     },
 
-    delete: async (_id) => {
+    delete: async (_id: string): Promise<PaymentProvider> => {
       const paymentProvider = await PaymentProviders.findOneAndUpdate(
         generateDbFilterById(_id),
         {
@@ -321,3 +107,5 @@ export const configurePaymentProvidersModule = (
     },
   };
 };
+
+export type PaymentProvidersModule = ReturnType<typeof configurePaymentProvidersModule>;

package/src/module/payment-index.test.ts

@@ -1,4 +1,4 @@
-import { PaymentProviderType } from '../payment-index.js';
+import { PaymentProviderType } from '../db/PaymentProvidersCollection.js';
 import { buildFindSelector } from './configurePaymentProvidersModule.js';
 
 describe('Payment', () => {

package/src/payment-index.ts

@@ -1,12 +1,4 @@
-export * from './types.js';
 export * from './module/configurePaymentModule.js';
 export * from './payment-settings.js';
-
-export * from './director/PaymentDirector.js';
-export * from './director/PaymentAdapter.js';
-export * from './director/PaymentPricingAdapter.js';
-export * from './director/PaymentPricingDirector.js';
-export * from './director/PaymentPricingSheet.js';
-
-export { PaymentError } from './director/PaymentError.js';
-export { PaymentProviderType } from './director/PaymentProviderType.js';
+export * from './db/PaymentCredentialsCollection.js';
+export * from './db/PaymentProvidersCollection.js';

package/src/payment-settings.ts

@@ -1,22 +1,21 @@
-import { Order } from '@unchainedshop/core-orders';
-import { PaymentCredentials, PaymentProvider } from './types.js';
-import { UnchainedCore } from '@unchainedshop/core';
+import { PaymentCredentials } from './db/PaymentCredentialsCollection.js';
+import { PaymentProvider } from './db/PaymentProvidersCollection.js';
 
-export type FilterProviders = (
+export type FilterProviders<Order = unknown, UnchainedAPI = unknown> = (
   params: {
     providers: Array<PaymentProvider>;
     order: Order;
   },
-  context: UnchainedCore,
+  unchainedAPI: UnchainedAPI,
 ) => Promise<Array<PaymentProvider>>;
 
-export type DetermineDefaultProvider = (
+export type DetermineDefaultProvider<Order = unknown, UnchainedAPI = unknown> = (
   params: {
     providers: Array<PaymentProvider>;
     order: Order;
     paymentCredentials?: Array<PaymentCredentials>;
   },
-  context: UnchainedCore,
+  unchainedAPI: UnchainedAPI,
 ) => Promise<PaymentProvider>;
 export interface PaymentSettingsOptions {
   sortProviders?: (a: PaymentProvider, b: PaymentProvider) => number;

package/tsconfig.json

@@ -1,11 +1,9 @@
 {
   "extends": "../shared/base.tsconfig.json",
   "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "lib",
+    "declarationDir": "./lib",
+    "rootDir": "./src",
+    "outDir": "./lib"
   },
-  "exclude": ["**/*.test.ts", "**/*.test.js", "tests"],
-  "include": [
-    "./src"
-  ]
-}
+  "exclude": ["**/*.test.ts", "**/*.test.js", "tests", "lib"]
+}

package/src/director/PaymentAdapter.ts

@@ -1,63 +0,0 @@
-import { IPaymentAdapter } from '@unchainedshop/core-payment';
-import { log, LogLevel } from '@unchainedshop/logger';
-import { PaymentError } from './PaymentError.js';
-
-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/director/PaymentDirector.ts

@@ -1,99 +0,0 @@
-import { IPaymentAdapter, IPaymentDirector, PaymentContext } from '@unchainedshop/core-payment';
-import { BaseDirector } from '@unchainedshop/utils';
-import { createLogger } from '@unchainedshop/logger';
-import { PaymentError } from './PaymentError.js';
-
-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({
-      config: paymentProvider.configuration,
-      paymentContext: {
-        paymentProvider,
-        paymentProviderId: paymentProvider._id,
-        ...newPaymentContext,
-      },
-      context: 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);
-      },
-    };
-  },
-};

package/src/director/PaymentError.ts

@@ -1,6 +0,0 @@
-export enum PaymentError {
-  ADAPTER_NOT_FOUND = 'ADAPTER_NOT_FOUND',
-  NOT_IMPLEMENTED = 'NOT_IMPLEMENTED',
-  INCOMPLETE_CONFIGURATION = 'INCOMPLETE_CONFIGURATION',
-  WRONG_CREDENTIALS = 'WRONG_CREDENTIALS',
-}

package/src/director/PaymentPricingAdapter.ts

@@ -1,87 +0,0 @@
-import {
-  BasePricingAdapterContext,
-  IPricingAdapter,
-  IPricingSheet,
-  PricingCalculation,
-} from '@unchainedshop/utils';
-import { BasePricingAdapter } from '@unchainedshop/utils';
-import { PaymentPricingSheet } from './PaymentPricingSheet.js';
-import { User } from '@unchainedshop/core-users';
-import { OrderPayment } from '@unchainedshop/core-orders';
-import { Order } from '@unchainedshop/core-orders';
-import { PaymentProvider } from '../types.js';
-import { OrderDiscount } from '@unchainedshop/core-orders';
-
-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,
-  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,
-    };
-  },
-};