@unchainedshop/core-payment 1.1.3

package/src/module/configurePaymentProvidersModule.ts

@@ -0,0 +1,230 @@
+import { Context } from '@unchainedshop/types/api';
+import { Collection, ModuleMutations } from '@unchainedshop/types/common';
+import {
+  PaymentContext,
+  PaymentModule,
+  PaymentProvider,
+  PaymentProviderQuery,
+} from '@unchainedshop/types/payments';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { generateDbFilterById, generateDbMutations } from '@unchainedshop/utils';
+import { PaymentPricingDirector } from '../director/PaymentPricingDirector';
+import { PaymentPricingSheet } from '../director/PaymentPricingSheet';
+import { PaymentProvidersSchema } from '../db/PaymentProvidersSchema';
+import { PaymentDirector } from '../director/PaymentDirector';
+import { paymentSettings } from '../payment-settings';
+
+const PAYMENT_PROVIDER_EVENTS: string[] = [
+  'PAYMENT_PROVIDER_CREATE',
+  'PAYMENT_PROVIDER_UPDATE',
+  'PAYMENT_PROVIDER_REMOVE',
+];
+
+const buildFindSelector = ({ type }: PaymentProviderQuery = {}) => {
+  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: Collection<PaymentProvider>,
+): PaymentModule['paymentProviders'] => {
+  registerEvents(PAYMENT_PROVIDER_EVENTS);
+
+  const mutations = generateDbMutations<PaymentProvider>(
+    PaymentProviders,
+    PaymentProvidersSchema,
+  ) as ModuleMutations<PaymentProvider>;
+
+  const getPaymentAdapter = async (
+    paymentProviderId: string,
+    paymentContext: PaymentContext,
+    requestContext: Context,
+  ) => {
+    const provider = await PaymentProviders.findOne(generateDbFilterById(paymentProviderId), {});
+
+    return PaymentDirector.actions(provider, paymentContext, requestContext);
+  };
+
+  return {
+    // Queries
+    count: async (query) => {
+      const providerCount = await PaymentProviders.countDocuments(buildFindSelector(query));
+      return providerCount;
+    },
+
+    findProvider: async ({ paymentProviderId, ...query }, options) => {
+      return PaymentProviders.findOne(
+        paymentProviderId ? generateDbFilterById(paymentProviderId) : query,
+        options,
+      );
+    },
+
+    findProviders: async (query, options) => {
+      const providers = PaymentProviders.find(buildFindSelector(query), options);
+      return providers.toArray();
+    },
+
+    providerExists: async ({ paymentProviderId }) => {
+      const providerCount = await PaymentProviders.countDocuments(
+        generateDbFilterById(paymentProviderId, { deleted: null }),
+        { limit: 1 },
+      );
+      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, requestContext) => {
+      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, requestContext);
+            return director.isActive();
+          } catch {
+            return false;
+          }
+        },
+      );
+
+      return paymentSettings.filterSupportedProviders(
+        {
+          providers,
+          order: paymentContext.order,
+        },
+        requestContext,
+      );
+    },
+
+    determineDefault: async (paymentProviders, deliveryContext, requestContext) => {
+      return paymentSettings.determineDefaultProvider(
+        {
+          providers: paymentProviders,
+          ...deliveryContext,
+        },
+        requestContext,
+      );
+    },
+
+    // Payment Adapter
+
+    configurationError: async (paymentProvider, requestContext) => {
+      const actions = await PaymentDirector.actions(paymentProvider, {}, requestContext);
+      return actions.configurationError();
+    },
+
+    calculate: async (pricingContext, requestContext) => {
+      const pricing = await PaymentPricingDirector.actions(pricingContext, requestContext);
+      return pricing.calculate();
+    },
+
+    isActive: async (paymentProvider, requestContext) => {
+      const actions = await PaymentDirector.actions(paymentProvider, {}, requestContext);
+      return actions.isActive();
+    },
+
+    isPayLaterAllowed: async (paymentProvider, requestContext) => {
+      const actions = await PaymentDirector.actions(paymentProvider, {}, requestContext);
+      return actions.isPayLaterAllowed();
+    },
+
+    charge: async (paymentProviderId, paymentContext, requestContext) => {
+      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, requestContext);
+      return adapter.charge();
+    },
+
+    register: async (paymentProviderId, paymentContext, requestContext) => {
+      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, requestContext);
+      return adapter.register();
+    },
+
+    sign: async (paymentProviderId, paymentContext, requestContext) => {
+      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, requestContext);
+      return adapter.sign();
+    },
+
+    validate: async (paymentProviderId, paymentContext, requestContext) => {
+      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, requestContext);
+      return adapter.validate();
+    },
+
+    cancel: async (paymentProviderId, paymentContext, requestContext) => {
+      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, requestContext);
+      return adapter.cancel();
+    },
+
+    confirm: async (paymentProviderId, paymentContext, requestContext) => {
+      const adapter = await getPaymentAdapter(paymentProviderId, paymentContext, requestContext);
+      return adapter.confirm();
+    },
+
+    // Mutations
+    create: async (doc, userId) => {
+      const Adapter = PaymentDirector.getAdapter(doc.adapterKey);
+      if (!Adapter) return null;
+
+      const paymentProviderId = await mutations.create(
+        {
+          configuration: Adapter.initialConfiguration,
+          ...doc,
+        },
+        userId,
+      );
+
+      const paymentProvider = await PaymentProviders.findOne(
+        generateDbFilterById(paymentProviderId),
+        {},
+      );
+      emit('PAYMENT_PROVIDER_CREATE', { paymentProvider });
+      return paymentProvider;
+    },
+
+    update: async (_id: string, doc: PaymentProvider, userId: string) => {
+      await mutations.update(_id, doc, userId);
+      const paymentProvider = await PaymentProviders.findOne(generateDbFilterById(_id), {});
+      emit('PAYMENT_PROVIDER_UPDATE', { paymentProvider });
+      return paymentProvider;
+    },
+
+    delete: async (_id, userId) => {
+      await mutations.delete(_id, userId);
+      const paymentProvider = await PaymentProviders.findOne(generateDbFilterById(_id), {});
+      emit('PAYMENT_PROVIDER_REMOVE', { paymentProvider });
+      return paymentProvider;
+    },
+
+    deletePermanently: async (_id, userId) => {
+      const deliveryProvider = await PaymentProviders.findOne(generateDbFilterById(_id), {});
+      await mutations.deletePermanently(_id, userId);
+      return deliveryProvider;
+    },
+  };
+};

package/src/payment-index.ts

@@ -0,0 +1,12 @@
+export { configurePaymentModule } from './module/configurePaymentModule';
+
+export { paymentServices } from './service/paymentServices';
+export { paymentSettings } from './payment-settings';
+
+export { PaymentDirector } from './director/PaymentDirector';
+export { PaymentAdapter } from './director/PaymentAdapter';
+export { PaymentError } from './director/PaymentError';
+export { PaymentProviderType } from './director/PaymentProviderType';
+
+export { PaymentPricingAdapter } from './director/PaymentPricingAdapter';
+export { PaymentPricingDirector } from './director/PaymentPricingDirector';

package/src/payment-settings.ts

@@ -0,0 +1,52 @@
+import {
+  PaymentProvider,
+  PaymentSettings,
+  FilterProviders,
+  DetermineDefaultProvider,
+} from '@unchainedshop/types/payments';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:core-payment');
+
+const sortByCreationDate = (left: PaymentProvider, right: PaymentProvider) => {
+  return new Date(left.created).getTime() - new Date(right.created).getTime();
+};
+
+const allProviders: FilterProviders = async ({ providers }) => {
+  return providers.sort(sortByCreationDate);
+};
+
+const firstProviderIsDefault: DetermineDefaultProvider = async ({ providers, paymentCredentials }) => {
+  const foundSupportedPreferredProvider = providers.find((supportedPaymentProvider) => {
+    return paymentCredentials.some((paymentCredential) => {
+      return supportedPaymentProvider._id === paymentCredential.paymentProviderId;
+    });
+  });
+  if (foundSupportedPreferredProvider) return foundSupportedPreferredProvider;
+  return providers?.length > 0 && providers[0];
+};
+
+const defaultFilterSupportedProviders =
+  (sortProviders) =>
+  async ({ providers }) => {
+    return providers.sort(sortProviders);
+  };
+
+export const paymentSettings: PaymentSettings = {
+  filterSupportedProviders: null,
+  determineDefaultProvider: null,
+
+  configureSettings({
+    sortProviders = undefined,
+    filterSupportedProviders = allProviders,
+    determineDefaultProvider = firstProviderIsDefault,
+  } = {}) {
+    if (sortProviders) {
+      logger.warn('sortProviders is deprecated, please specifc filterSupportedProviders instead');
+      paymentSettings.filterSupportedProviders = defaultFilterSupportedProviders(sortProviders);
+    } else {
+      paymentSettings.filterSupportedProviders = filterSupportedProviders;
+    }
+    paymentSettings.determineDefaultProvider = determineDefaultProvider;
+  },
+};

package/src/service/cancelService.ts

@@ -0,0 +1,24 @@
+import { CancelService } from '@unchainedshop/types/payments';
+
+export const cancelService: CancelService = async (
+  { paymentContext, paymentProviderId },
+  requestContext,
+) => {
+  const { modules, userId } = requestContext;
+
+  const normalizedContext = {
+    ...paymentContext,
+    userId,
+    paymentProviderId,
+  };
+
+  const result = await modules.payment.paymentProviders.cancel(
+    paymentProviderId,
+    normalizedContext,
+    requestContext,
+  );
+
+  if (!result) return false;
+
+  return result;
+};

package/src/service/chargeService.ts

@@ -0,0 +1,47 @@
+import { ChargeService } from '@unchainedshop/types/payments';
+
+export const chargeService: ChargeService = async (
+  { paymentContext, paymentProviderId },
+  requestContext,
+) => {
+  const { modules, userId } = requestContext;
+
+  const paymentCredentials =
+    paymentContext.transactionContext?.paymentCredentials ||
+    (await modules.payment.paymentCredentials.findPaymentCredential({
+      userId,
+      paymentProviderId,
+      isPreferred: true,
+    }));
+
+  const normalizedContext = {
+    ...paymentContext,
+    userId,
+    paymentProviderId,
+    transactionContext: {
+      ...paymentContext.transactionContext,
+      paymentCredentials,
+    },
+  };
+
+  const result = await modules.payment.paymentProviders.charge(
+    paymentProviderId,
+    normalizedContext,
+    requestContext,
+  );
+
+  if (!result) return false;
+
+  const { credentials, ...strippedResult } = result;
+
+  if (credentials) {
+    const { token, ...meta } = credentials;
+    await modules.payment.paymentCredentials.upsertCredentials({
+      userId,
+      paymentProviderId,
+      token,
+      ...meta,
+    });
+  }
+  return strippedResult;
+};

package/src/service/confirmService.ts

@@ -0,0 +1,24 @@
+import { ConfirmService } from '@unchainedshop/types/payments';
+
+export const confirmService: ConfirmService = async (
+  { paymentContext, paymentProviderId },
+  requestContext,
+) => {
+  const { modules, userId } = requestContext;
+
+  const normalizedContext = {
+    ...paymentContext,
+    userId,
+    paymentProviderId,
+  };
+
+  const result = await modules.payment.paymentProviders.confirm(
+    paymentProviderId,
+    normalizedContext,
+    requestContext,
+  );
+
+  if (!result) return false;
+
+  return result;
+};

package/src/service/paymentServices.ts

@@ -0,0 +1,12 @@
+import { PaymentServices } from '@unchainedshop/types/payments';
+import { chargeService } from './chargeService';
+import { cancelService } from './cancelService';
+import { confirmService } from './confirmService';
+import { registerPaymentCredentialsService } from './registerPaymentCredentialsService';
+
+export const paymentServices: PaymentServices = {
+  charge: chargeService,
+  registerPaymentCredentials: registerPaymentCredentialsService,
+  cancel: cancelService,
+  confirm: confirmService,
+};

package/src/service/registerPaymentCredentialsService.ts

@@ -0,0 +1,28 @@
+import { RegisterPaymentCredentialsService } from '@unchainedshop/types/payments';
+
+export const registerPaymentCredentialsService: RegisterPaymentCredentialsService = async (
+  paymentProviderId,
+  paymentContext,
+  requestContext,
+) => {
+  const { modules, userId } = requestContext;
+  const registration = await modules.payment.paymentProviders.register(
+    paymentProviderId,
+    paymentContext,
+    requestContext,
+  );
+
+  if (!registration) return null;
+
+  const paymentCredentialsId = await modules.payment.paymentCredentials.upsertCredentials({
+    userId,
+    paymentProviderId,
+    ...registration,
+  });
+
+  return modules.payment.paymentCredentials.findPaymentCredential({
+    paymentCredentialsId,
+    userId,
+    paymentProviderId,
+  });
+};

package/tests/payment-index.test.ts

@@ -0,0 +1,47 @@
+import { assert } from 'chai';
+import { initDb } from 'meteor/unchained:mongodb';
+import { configurePaymentModule } from '@unchainedshop/core-payment';
+
+describe('Test exports', () => {
+  let module;
+
+  before(async () => {
+    const db = await initDb();
+    module = await configurePaymentModule({ db });
+  });
+
+  it('Check Bookmarks module', async () => {
+    assert.ok(module);
+    assert.isFunction(module.findCurrency);
+    assert.isFunction(module.findPayment);
+    assert.isFunction(module.currencyExists);
+    assert.isFunction(module.create);
+    assert.isFunction(module.update);
+    assert.isFunction(module.delete);
+  });
+
+  it('Mutate currency', async () => {
+    const currencyId = await module.create(
+      {
+        authorId: 'Test-User-1',
+        isoCode: 'CHF',
+      },
+      'Test-User-1'
+    );
+
+    assert.ok(currencyId);
+    const currency = await module.findCurrency(currencyId);
+
+    assert.ok(currency);
+    assert.equal(currency._id, currencyId);
+    assert.equal(currency.isoCode, 'CHF');
+    assert.equal(currency.userId, 'Test-User-1');
+    assert.isDefined(currency.created);
+    assert.isUndefined(currency.updated);
+    assert.isUndefined(currency.updatedBy);
+    assert.equal(currency.createdBy, 'Test-User-1');
+
+    const deletedCount = await module.delete(currencyId);
+    assert.equal(deletedCount, 1);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["esnext"],
+    "module": "esnext",
+    "moduleResolution": "node",
+    "noImplicitReturns": true,
+    "noUnusedLocals": false,
+    "outDir": "lib",
+    "preserveWatchOutput": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "target": "esnext",
+    "types": ["node"],
+    "baseUrl": ".", // This must be specified if "paths" is.
+    "paths": {
+      "meteor/unchained:*": ["node_modules/@unchainedshop/types/index.d.ts"]
+    }
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["node", "mocha"]
+  },
+  "include": ["src", "tests", "plugins"]
+}