@unchainedshop/core-payment 1.1.3

package/package.js

@@ -0,0 +1,33 @@
+Package.describe({
+  name: 'unchained:core-payment',
+  version: '1.1.3',
+  summary: 'Unchained Engine Core: Payment',
+  git: 'https://github.com/unchainedshop/unchained',
+  documentation: 'README.md',
+});
+
+Npm.depends({
+  'simpl-schema': '1.12.0',
+  '@unchainedshop/logger': '1.1.3',
+  '@unchainedshop/utils': '1.1.3',
+  // '@unchainedshop/events': '1.1.4', // PEER
+});
+
+Package.onUse((api) => {
+  api.versionsFrom('2.7.3');
+  api.use('ecmascript');
+  api.use('typescript');
+
+  api.mainModule('src/payment-index.ts', 'server');
+});
+
+Package.onTest((api) => {
+  api.use('meteortesting:mocha');
+  api.use('ecmascript');
+  api.use('typescript');
+
+  api.use('unchained:mongodb');
+  api.use('unchained:core-payment');
+
+  api.mainModule('tests/payment-index.test.ts');
+});

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@unchainedshop/core-payment",
+  "version": "1.1.3",
+  "main": "lib/payments-index.js",
+  "types": "lib/payments-index.d.ts",
+  "type": "module",
+  "scripts": {
+    "clean": "rm -rf lib",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "watch": "tsc --watch",
+    "link:core": "npm link  @unchainedshop/types",
+    "test": "cross-env METEOR_PACKAGE_DIRS=../ TEST_CLIENT=0 TEST_WATCH=1 meteor test-packages ./ --driver-package meteortesting:mocha --port 4200"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unchainedshop/unchained.git"
+  },
+  "keywords": [
+    "unchained",
+    "ecommerce",
+    "core"
+  ],
+  "author": "Joël Meiller",
+  "license": "EUPL-1.2",
+  "bugs": {
+    "url": "https://github.com/unchainedshop/unchained/issues"
+  },
+  "homepage": "https://github.com/unchainedshop/unchained#readme",
+  "dependencies": {
+    "@unchainedshop/events": "latest",
+    "@unchainedshop/logger": "latest",
+    "@unchainedshop/utils": "latest",
+    "simpl-schema": "^1.12.2"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.1",
+    "@types/mocha": "^9.1.1",
+    "@unchainedshop/types": "latest",
+    "chai": "^4.3.6",
+    "cross-env": "^7.0.3",
+    "typescript": "^4.7.4"
+  }
+}

package/src/db/PaymentCredentialsCollection.ts

@@ -0,0 +1,14 @@
+import { Db } from '@unchainedshop/types/common';
+import { PaymentCredentials as PaymentCredentialsType } from '@unchainedshop/types/payments';
+import { buildDbIndexes } from '@unchainedshop/utils';
+
+export const PaymentCredentialsCollection = async (db: Db) => {
+  const PaymentCredentials = db.collection<PaymentCredentialsType>('payment_credentials');
+
+  await buildDbIndexes<PaymentCredentialsType>(PaymentCredentials, [
+    { index: { paymentProviderId: 1 } },
+    { index: { userId: 1 } },
+  ]);
+
+  return PaymentCredentials;
+};

package/src/db/PaymentCredentialsSchema.js

@@ -0,0 +1,14 @@
+import { Schemas } from '@unchainedshop/utils';
+import SimpleSchema from 'simpl-schema';
+
+export const PaymentCredentialsSchema = new SimpleSchema(
+  {
+    paymentProviderId: { type: String, required: true },
+    userId: { type: String, required: true },
+    token: String,
+    isPreferred: Boolean,
+    meta: { type: Object, blackbox: true },
+    ...Schemas.timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/db/PaymentProvidersCollection.ts

@@ -0,0 +1,11 @@
+import { Db } from '@unchainedshop/types/common';
+import { PaymentProvider } from '@unchainedshop/types/payments';
+import { buildDbIndexes } from '@unchainedshop/utils';
+
+export const PaymentProvidersCollection = async (db: Db) => {
+  const PaymentProviders = db.collection<PaymentProvider>('payment-providers');
+
+  await buildDbIndexes<PaymentProvider>(PaymentProviders, [{ index: { type: 1 } }]);
+
+  return PaymentProviders;
+};

package/src/db/PaymentProvidersSchema.js

@@ -0,0 +1,16 @@
+import { Schemas } from '@unchainedshop/utils';
+import SimpleSchema from 'simpl-schema';
+
+export const PaymentProvidersSchema = new SimpleSchema(
+  {
+    type: { type: String, required: true },
+    adapterKey: { type: String, required: true },
+    authorId: { type: String, required: true },
+    configuration: { type: Array },
+    'configuration.$': { type: Object },
+    'configuration.$.key': { type: String },
+    'configuration.$.value': { type: String },
+    ...Schemas.timestampFields,
+  },
+  { requiredByDefault: false },
+);

package/src/director/PaymentAdapter.ts

@@ -0,0 +1,63 @@
+import { IPaymentAdapter } from '@unchainedshop/types/payments';
+import { log, LogLevel } from '@unchainedshop/logger';
+import { PaymentError } from './PaymentError';
+
+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

@@ -0,0 +1,99 @@
+import { IPaymentAdapter, IPaymentDirector, PaymentContext } from '@unchainedshop/types/payments';
+import { BaseDirector } from '@unchainedshop/utils';
+import { createLogger } from '@unchainedshop/logger';
+import { PaymentError } from './PaymentError';
+
+const logger = createLogger('unchained:core-payment');
+const baseDirector = BaseDirector<IPaymentAdapter>('PaymentDirector');
+
+export const PaymentDirector: IPaymentDirector = {
+  ...baseDirector,
+
+  actions: async (paymentProvider, paymentContext, requestContext) => {
+    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 } = requestContext;
+      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: requestContext,
+    });
+
+    return {
+      configurationError: () => {
+        try {
+          const error = adapter.configurationError();
+          return error;
+        } catch (error) {
+          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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,41 @@
+import {
+  IPaymentPricingSheet,
+  PaymentPricingAdapterContext,
+  PaymentPricingCalculation,
+} from '@unchainedshop/types/payments.pricing';
+import { IPricingAdapter } from '@unchainedshop/types/pricing';
+import { BasePricingAdapter } from '@unchainedshop/utils';
+import { PaymentPricingSheet } from './PaymentPricingSheet';
+
+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/director/PaymentPricingDirector.ts

@@ -0,0 +1,66 @@
+import {
+  IPaymentPricingAdapter,
+  IPaymentPricingDirector,
+  PaymentPricingAdapterContext,
+  PaymentPricingCalculation,
+  PaymentPricingContext,
+} from '@unchainedshop/types/payments.pricing';
+import { BasePricingDirector } from '@unchainedshop/utils';
+import { PaymentPricingSheet } from './PaymentPricingSheet';
+
+const baseDirector = BasePricingDirector<
+  PaymentPricingContext,
+  PaymentPricingAdapterContext,
+  PaymentPricingCalculation,
+  IPaymentPricingAdapter
+>('PaymentPricingDirector');
+
+export const PaymentPricingDirector: IPaymentPricingDirector = {
+  ...baseDirector,
+
+  async buildPricingContext({ item, ...context }, requestContext) {
+    if (!item)
+      return {
+        discounts: [],
+        ...context,
+        ...requestContext,
+      };
+
+    const order = await requestContext.modules.orders.findOrder({
+      orderId: item.orderId,
+    });
+    const provider = await requestContext.modules.payment.paymentProviders.findProvider({
+      paymentProviderId: item.paymentProviderId,
+    });
+    const user = await requestContext.modules.users.findUserById(order.userId);
+    const discounts = await requestContext.modules.orders.discounts.findOrderDiscounts({
+      orderId: item.orderId,
+    });
+
+    return {
+      country: order.countryCode,
+      currency: order.currency,
+      ...context,
+      ...requestContext,
+      order,
+      orderPayment: item,
+      provider,
+      user,
+      discounts,
+    };
+  },
+
+  async actions(pricingContext, requestContext) {
+    const actions = await baseDirector.actions(pricingContext, requestContext, this.buildPricingContext);
+    return {
+      ...actions,
+      calculationSheet() {
+        const context = actions.getContext();
+        return PaymentPricingSheet({
+          calculation: actions.getCalculation(),
+          currency: context.currency,
+        });
+      },
+    };
+  },
+};

package/src/director/PaymentPricingSheet.ts

@@ -0,0 +1,112 @@
+import { BasePricingSheet } from '@unchainedshop/utils';
+import {
+  PaymentPricingCalculation,
+  PaymentPricingRowCategory,
+  IPaymentPricingSheet,
+} from '@unchainedshop/types/payments.pricing';
+import { IBasePricingSheet, PricingSheetParams } from '@unchainedshop/types/pricing';
+
+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() {
+      return basePricingSheet.sum({
+        category: PaymentPricingRowCategory.Tax,
+      });
+    },
+
+    feeSum() {
+      return basePricingSheet.sum({
+        category: PaymentPricingRowCategory.Payment,
+      });
+    },
+
+    discountSum(discountId) {
+      return basePricingSheet.sum({
+        category: PaymentPricingRowCategory.Discount,
+        discountId,
+      });
+    },
+
+    discountPrices(explicitDiscountId) {
+      const discountIds = pricingSheet
+        .getDiscountRows(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);
+    },
+
+    getFeeRows() {
+      return basePricingSheet.filterBy({
+        category: PaymentPricingRowCategory.Item,
+      });
+    },
+
+    getDiscountRows(discountId) {
+      return basePricingSheet.filterBy({
+        category: PaymentPricingRowCategory.Discount,
+        discountId,
+      });
+    },
+
+    getTaxRows() {
+      return basePricingSheet.filterBy({
+        category: PaymentPricingRowCategory.Tax,
+      });
+    },
+  };
+
+  return pricingSheet;
+};

package/src/director/PaymentProviderType.ts

@@ -0,0 +1,5 @@
+export enum PaymentProviderType {
+  CARD = 'CARD',
+  INVOICE = 'INVOICE',
+  GENERIC = 'GENERIC',
+}

package/src/module/configurePaymentCredentialsModule.ts

@@ -0,0 +1,110 @@
+import {
+  PaymentCredentials as PaymentCredentialsType,
+  PaymentModule,
+} from '@unchainedshop/types/payments';
+import { Collection } from '@unchainedshop/types/common';
+import { generateDbFilterById, generateDbObjectId } from '@unchainedshop/utils';
+
+export const configurePaymentCredentialsModule = (
+  PaymentCredentials: Collection<PaymentCredentialsType>,
+): PaymentModule['paymentCredentials'] => {
+  const markPreferred = async ({ userId, paymentCredentialsId }) => {
+    await PaymentCredentials.updateOne(
+      {
+        _id: paymentCredentialsId,
+      },
+      {
+        $set: {
+          isPreferred: true,
+        },
+      },
+    );
+    await PaymentCredentials.updateMany(
+      {
+        _id: { $ne: paymentCredentialsId },
+        userId,
+      },
+      {
+        $set: {
+          isPreferred: false,
+        },
+      },
+    );
+  };
+
+  return {
+    markPreferred,
+
+    credentialsExists: async ({ paymentCredentialsId }) => {
+      const credentialsCount = await PaymentCredentials.countDocuments(
+        generateDbFilterById(paymentCredentialsId),
+        { limit: 1 },
+      );
+      return !!credentialsCount;
+    },
+
+    findPaymentCredential: async ({ paymentCredentialsId, userId, paymentProviderId }, options) => {
+      return PaymentCredentials.findOne(
+        paymentCredentialsId
+          ? generateDbFilterById(paymentCredentialsId)
+          : { userId, paymentProviderId },
+        options,
+      );
+    },
+
+    findPaymentCredentials: async (query, options) => {
+      const credentials = await PaymentCredentials.find(query, options).toArray();
+      return credentials;
+    },
+
+    upsertCredentials: async ({ userId, paymentProviderId, _id, token, ...meta }) => {
+      const insertedId = _id || generateDbObjectId();
+      const result = await PaymentCredentials.updateOne(
+        _id
+          ? generateDbFilterById(_id, {
+            userId,
+            paymentProviderId,
+          })
+          : {
+            userId,
+            paymentProviderId,
+          },
+        {
+          $setOnInsert: {
+            _id: insertedId,
+            userId,
+            paymentProviderId,
+            isPreferred: false,
+            created: new Date(),
+            createdBy: userId,
+          },
+          $set: {
+            updated: new Date(),
+            updatedBy: userId,
+            token,
+            meta,
+          },
+        },
+        {
+          upsert: true,
+        },
+      );
+
+      if (result.upsertedCount > 0) {
+        await markPreferred({
+          userId,
+          paymentCredentialsId: insertedId,
+        });
+        return insertedId;
+      }
+      return null;
+    },
+
+    removeCredentials: async (paymentCredentialsId) => {
+      const selector = generateDbFilterById(paymentCredentialsId);
+      const paymentCredentials = await PaymentCredentials.findOne(selector, {});
+      await PaymentCredentials.deleteOne(selector);
+      return paymentCredentials;
+    },
+  };
+};

package/src/module/configurePaymentModule.ts

@@ -0,0 +1,22 @@
+import { ModuleInput } from '@unchainedshop/types/common';
+import { PaymentModule, PaymentSettingsOptions } from '@unchainedshop/types/payments';
+import { PaymentCredentialsCollection } from '../db/PaymentCredentialsCollection';
+import { PaymentProvidersCollection } from '../db/PaymentProvidersCollection';
+import { configurePaymentCredentialsModule } from './configurePaymentCredentialsModule';
+import { configurePaymentProvidersModule } from './configurePaymentProvidersModule';
+import { paymentSettings } from '../payment-settings';
+
+export const configurePaymentModule = async ({
+  db,
+  options: paymentOptions = {},
+}: ModuleInput<PaymentSettingsOptions>): Promise<PaymentModule> => {
+  const PaymentProviders = await PaymentProvidersCollection(db);
+  const PaymentCredentials = await PaymentCredentialsCollection(db);
+
+  paymentSettings.configureSettings(paymentOptions);
+
+  return {
+    paymentProviders: configurePaymentProvidersModule(PaymentProviders),
+    paymentCredentials: configurePaymentCredentialsModule(PaymentCredentials),
+  };
+};