@unchainedshop/plugins 4.3.4 → 4.4.0

package/src/payment/datatrans-v2/parseRegistrationData.ts

@@ -1,34 +0,0 @@
-import splitProperties from './splitProperties.js';
-import { StatusResponseSuccess } from './api/types.js';
-import { sha256 } from '@unchainedshop/utils';
-
-export default async function parseRegistrationData(transaction: StatusResponseSuccess) {
-  const parsed = Object.entries(transaction).reduce((acc, [objectKey, payload]) => {
-    const { token, info } = splitProperties({ objectKey, payload });
-    if (token) {
-      return {
-        token,
-        info,
-        objectKey,
-      };
-    }
-    return acc;
-  }, {}) as {
-    token?: Record<string, unknown>;
-    info?: Record<string, unknown>;
-    objectKey?: string;
-  };
-  if (parsed.objectKey) {
-    const _id = await sha256(parsed.token);
-
-    return {
-      ...parsed,
-      _id,
-      paymentMethod: transaction.paymentMethod,
-      currency: transaction.currency,
-      language: transaction.language,
-      type: transaction.type,
-    };
-  }
-  return null;
-}

package/src/payment/datatrans-v2/roundedAmountFromOrder.ts

@@ -1,16 +0,0 @@
-import { OrderPricingSheet } from '@unchainedshop/core';
-import { Order } from '@unchainedshop/core-orders';
-
-const roundedAmountFromOrder = (order: Order): { currencyCode: string; amount: number } => {
-  const pricing = OrderPricingSheet({
-    calculation: order.calculation,
-    currencyCode: order.currencyCode,
-  });
-  const { currencyCode, amount } = pricing.total({ useNetPrice: false });
-  return {
-    currencyCode,
-    amount: Math.round(amount),
-  };
-};
-
-export default roundedAmountFromOrder;

package/src/payment/datatrans-v2/splitProperties.ts

@@ -1,58 +0,0 @@
-// This method splits the return data of alias registration to the important properties needed for validation and the additional data
-
-export default function splitProperties({ objectKey, payload }: { objectKey?: string; payload: any }): {
-  token?: string;
-  info: any;
-} {
-  if (!payload || !objectKey) return { info: {} };
-
-  if (objectKey === 'card') {
-    const { expiryMonth, alias, expiryYear, ...info } = payload;
-    if (!alias) return { info };
-    const is3DActive = !!payload['3D']?.xid;
-    if (is3DActive) {
-      delete info['3D'];
-    }
-    const token = JSON.stringify({
-      alias,
-      expiryMonth,
-      expiryYear,
-      '3D': is3DActive ? payload['3D'] : undefined,
-    });
-    return {
-      token,
-      info,
-    };
-  }
-
-  if (objectKey === 'PAY') {
-    const { signature, protocolVersion, signedMessage, ...info } = payload;
-    if (!signedMessage) return { info };
-    return {
-      token: JSON.stringify({
-        signature,
-        protocolVersion,
-        signedMessage,
-      }),
-      info,
-    };
-  }
-
-  if (objectKey === 'APL') {
-    const { data, header, signature, version, ...info } = payload;
-    if (!data) return { info };
-    delete info['3D'];
-    return {
-      token: JSON.stringify({
-        data,
-        header,
-        signature,
-        version,
-      }),
-      info,
-    };
-  }
-
-  const { alias, ...info } = payload;
-  return { token: alias ? JSON.stringify({ alias }) : undefined, info };
-}

package/src/payment/invoice-prepaid.ts

@@ -1,40 +0,0 @@
-import { IPaymentAdapter, PaymentAdapter, PaymentDirector } from '@unchainedshop/core';
-import { PaymentProviderType } from '@unchainedshop/core-payment';
-
-const InvoicePrepaid: IPaymentAdapter = {
-  ...PaymentAdapter,
-
-  key: 'shop.unchained.invoice-prepaid',
-  label: 'Invoice pre-paid',
-  version: '1.0.0',
-
-  initialConfiguration: [],
-
-  typeSupported: (type) => {
-    return type === PaymentProviderType.INVOICE;
-  },
-
-  actions: (config, context) => {
-    return {
-      ...PaymentAdapter.actions(config, context),
-
-      configurationError: () => {
-        return null;
-      },
-
-      isActive: () => {
-        return true;
-      },
-
-      isPayLaterAllowed: () => {
-        return false;
-      },
-
-      charge: async () => {
-        return false;
-      },
-    };
-  },
-};
-
-PaymentDirector.registerAdapter(InvoicePrepaid);

package/src/payment/invoice.ts

@@ -1,36 +0,0 @@
-import { IPaymentAdapter, PaymentAdapter, PaymentDirector } from '@unchainedshop/core';
-import { PaymentProviderType } from '@unchainedshop/core-payment';
-
-const Invoice: IPaymentAdapter = {
-  ...PaymentAdapter,
-
-  key: 'shop.unchained.invoice',
-  label: 'Invoice',
-  version: '1.0.0',
-
-  initialConfiguration: [],
-
-  typeSupported: (type) => {
-    return type === PaymentProviderType.INVOICE;
-  },
-
-  actions: (config, context) => {
-    return {
-      ...PaymentAdapter.actions(config, context),
-
-      configurationError: () => {
-        return null;
-      },
-
-      isActive: () => {
-        return true;
-      },
-
-      isPayLaterAllowed: () => {
-        return true;
-      },
-    };
-  },
-};
-
-PaymentDirector.registerAdapter(Invoice);

package/src/payment/paypal-checkout.ts

@@ -1,127 +0,0 @@
-import {
-  OrderPricingSheet,
-  IPaymentAdapter,
-  PaymentAdapter,
-  PaymentDirector,
-  PaymentError,
-} from '@unchainedshop/core';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:paypal-checkout');
-
-let checkoutNodeJssdk;
-try {
-  // eslint-disable-next-line
-  // @ts-ignore
-  checkoutNodeJssdk = await import('@paypal/checkout-server-sdk');
-  // TODO: npm warn deprecated @paypal/checkout-server-sdk@1.0.3: Package no longer supported. The author suggests using the @paypal/paypal-server-sdk package instead: https://www.npmjs.com/package/@paypal/paypal-server-sdk.
-} catch {
-  /* */
-  logger.warn(
-    "npm dependency '@paypal/checkout-server-sdk' is not installed, paypal adapter will not work",
-  );
-}
-
-const { PAYPAL_CLIENT_ID, PAYPAL_SECRET, PAYPAL_ENVIRONMENT = 'sandbox' } = process.env;
-
-/**
- *
- * Set up and return PayPal JavaScript SDK environment with PayPal access credentials.
- * This sample uses SandboxEnvironment. In production, use ProductionEnvironment.
- *
- */
-const environment = () => {
-  const clientId = PAYPAL_CLIENT_ID;
-  const clientSecret = PAYPAL_SECRET;
-
-  return PAYPAL_ENVIRONMENT !== 'live'
-    ? new checkoutNodeJssdk.core.SandboxEnvironment(clientId, clientSecret)
-    : new checkoutNodeJssdk.core.LiveEnvironment(clientId, clientSecret);
-};
-
-const roundToDecimals = (number, decimals) => {
-  const num = Math.pow(10, decimals);
-  return Math.round(number * num) / num;
-};
-
-const PaypalCheckout: IPaymentAdapter = {
-  ...PaymentAdapter,
-
-  key: 'shop.unchained.payment.paypal',
-  label: 'Paypal',
-  version: '1.0.1',
-
-  initialConfiguration: [],
-
-  typeSupported: (type) => {
-    return type === 'GENERIC';
-  },
-
-  actions: (config, context) => {
-    const adapter = {
-      ...PaymentAdapter.actions(config, context),
-
-      configurationError: () => {
-        const publicCredentialsValid = PAYPAL_CLIENT_ID && PAYPAL_SECRET;
-
-        if (!publicCredentialsValid) {
-          return PaymentError.WRONG_CREDENTIALS;
-        }
-        return null;
-      },
-
-      isActive: () => {
-        if (adapter.configurationError() === null) return true;
-        return false;
-      },
-
-      isPayLaterAllowed: () => {
-        return false;
-      },
-
-      sign: async () => {
-        return PAYPAL_CLIENT_ID || null;
-      },
-
-      charge: async ({ orderID }) => {
-        const { order } = context;
-
-        if (!order) throw new Error('Order missing in payment context');
-
-        if (!orderID) {
-          throw new Error('You have to provide orderID in paymentContext');
-        }
-
-        try {
-          const request = new checkoutNodeJssdk.orders.OrdersGetRequest(orderID);
-          const client = new checkoutNodeJssdk.core.PayPalHttpClient(environment());
-          const paypalOrder = await client.execute(request);
-
-          const pricing = OrderPricingSheet({
-            calculation: order.calculation,
-            currencyCode: order.currencyCode,
-          });
-          const ourTotal = roundToDecimals(pricing.total({ useNetPrice: false }).amount / 100, 2);
-          const paypalTotal = roundToDecimals(paypalOrder.result.purchase_units[0].amount.value, 2);
-
-          if (ourTotal === paypalTotal) {
-            return order;
-          }
-
-          logger.warn('Missmatch PAYPAL ORDER', JSON.stringify(paypalOrder.result, null, 2));
-
-          logger.debug('OUR ORDER', order);
-          logger.debug('OUR PRICE', pricing);
-
-          throw new Error(`Payment mismatch`);
-        } catch (e) {
-          logger.warn(e);
-          throw new Error(e);
-        }
-      },
-    };
-    return adapter;
-  },
-};
-
-PaymentDirector.registerAdapter(PaypalCheckout);

package/src/payment/payrexx/api/index.ts

@@ -1,84 +0,0 @@
-import makeFetcher from './makeFetcher.js';
-
-const baseUrl = 'https://api.payrexx.com/v1.0/';
-
-export enum GatewayObjectStatus {
-  waiting = 'waiting',
-  confirmed = 'confirmed',
-  cancelled = 'cancelled',
-  declined = 'declined',
-  authorized = 'authorized',
-  reserved = 'reserved',
-  refunded = 'refunded',
-  refundpending = 'refundpending',
-  'partially-refunded' = 'partially-refunded',
-  chargeback = 'chargeback',
-  error = 'error',
-  uncaptured = '_',
-}
-
-export interface GatewayObject {
-  status: GatewayObjectStatus;
-  currency: string;
-  amount: number;
-  referenceId: string;
-  invoices: {
-    transactions: {
-      id: string;
-    }[];
-  }[];
-}
-
-export type TransactionObject = any;
-
-const createPayrexxAPI = (instance: string, secret: string) => {
-  const fetchPayrexx = makeFetcher(baseUrl, instance, secret);
-
-  return {
-    async chargePreAuthorized(id, params) {
-      const result = await fetchPayrexx(`Transaction/${id}`, 'POST', params);
-      if (result.ok) {
-        return result.json();
-      }
-      throw new Error(await result.text());
-    },
-
-    async deleteReservation(id) {
-      const result = await fetchPayrexx(`Transaction/${id}`, 'DELETE');
-      if (result.ok) {
-        return result.json();
-      }
-      throw new Error(await result.text());
-    },
-
-    async getGateway(id): Promise<GatewayObject | null> {
-      const result = await fetchPayrexx(`Gateway/${id}`, 'GET');
-      if (!result.ok) throw new Error(await result.text());
-      const { status, data } = await result.json();
-      if (status !== 'success') return null;
-      return data?.[0];
-    },
-
-    async createGateway(params): Promise<GatewayObject> {
-      const result = await fetchPayrexx('Gateway', 'POST', params);
-      if (result.ok) {
-        return result.json();
-      }
-      throw new Error(await result.text());
-    },
-  };
-};
-
-export default createPayrexxAPI;
-
-// where you want to consume the payrexx module:
-// const payrexx = payrexx.init(instance, api_secret);
-// const response = await payrexx.createGateway({
-//   amount: 100,
-//   // add more fields here
-// });
-
-// if (response.status === 200) {
-//   const gateway = response.data.data[0];
-//   // here you will get the gateway
-// }

package/src/payment/payrexx/api/makeFetcher.ts

@@ -1,83 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-
-const { MOCK_APIS } = process.env;
-
-const logger = createLogger('unchained:payrexx');
-
-export default (
-  baseUrl = 'https://api.payrexx.com/v1.0/',
-  instance: string,
-  secret: string,
-): ((path: string, method: 'GET' | 'DELETE' | 'PUT' | 'POST', data?: any) => Promise<Response>) => {
-  if (MOCK_APIS) {
-    return async (path): Promise<Response> => {
-      try {
-        const { default: jsonData } = await import(
-          `${import.meta.dirname}/../../../../tests/mock/payrexx/${path}.json`,
-          {
-            with: { type: 'json' },
-          }
-        );
-        return {
-          json: async () => jsonData,
-          text: async () => JSON.stringify(jsonData?.error),
-          ok: true,
-          status: jsonData?.error ? 500 : 204,
-        } as any;
-      } catch (error) {
-        logger.error('Mock: Error while trying reading and parsing file', {
-          ...error,
-        });
-        return {
-          json: async () => ({ error: { code: 'MOCK', message: 'MOCK' } }),
-          text: async () => 'MOCK',
-          ok: false,
-          status: 500,
-        } as any;
-      }
-    };
-  }
-
-  const buildSignature = async (query = '') => {
-    const key = await crypto.subtle.importKey(
-      'raw',
-      new TextEncoder().encode(secret),
-      { name: 'HMAC', hash: 'SHA-256' },
-      false,
-      ['sign'],
-    );
-    const signature = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(query));
-    return btoa(String.fromCharCode(...new Uint8Array(signature)));
-  };
-
-  const buildUrl = (path, params = {}) => {
-    const url = new URL(`${path}/`, baseUrl);
-    url.search = new URLSearchParams({ instance, ...params }).toString();
-    return url.href;
-  };
-
-  return async (path: string, method: 'GET' | 'DELETE' | 'POST', data?: any): Promise<Response> => {
-    logger.info(`${method} ${path}`);
-    if (method === 'POST') {
-      const queryParams = { ...data };
-      const signature = await buildSignature(new URLSearchParams(queryParams).toString());
-      queryParams.ApiSignature = signature;
-      const url = buildUrl(path);
-      return fetch(url, {
-        method,
-        body: new URLSearchParams(queryParams).toString(),
-        headers: {
-          accept: 'application/json',
-          'content-type': 'application/x-www-form-urlencoded',
-        },
-      });
-    }
-    if (method === 'DELETE' || method === 'GET') {
-      const url = buildUrl(path, { ApiSignature: await buildSignature() });
-      return fetch(url, {
-        method,
-      });
-    }
-    throw new Error('Method not supported');
-  };
-};

package/src/payment/payrexx/handler-express.ts

@@ -1,93 +0,0 @@
-import { Context } from '@unchainedshop/api';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:payrexx:handler');
-
-export const payrexxHandler = async (request, response) => {
-  const resolvedContext = request.unchainedContext as Context;
-  const { modules, services } = resolvedContext;
-
-  const { transaction } = request.body;
-
-  if (!transaction) {
-    logger.info(`unhandled event type`, {
-      type: Object.keys(request.body).join(','),
-    });
-    response.status(200).send({
-      ignored: true,
-      message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
-    });
-    return;
-  }
-  if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
-    // Ignore confirmed transactions, because those hooks are generated through calling the confirm()
-    // method in the payment adapter and could lead to double bookings.
-    logger.info(`unhandled transaction state: ${transaction.status}`);
-    response.status(200).send({
-      ignored: true,
-      message: `Unhandled transaction state: ${transaction.status}`,
-    });
-    return;
-  }
-
-  logger.info(`Processing event`, {
-    transactionId: transaction.id,
-  });
-  try {
-    if (transaction.preAuthorizationId) {
-      // Pre-Authorization Flow, referenceId is a userId
-      const { referenceId: paymentProviderId, invoice } = transaction;
-      const userId = '';
-      logger.info(`register credentials for: ${userId}`);
-      await services.orders.registerPaymentCredentials(paymentProviderId, {
-        userId,
-        transactionContext: { gatewayId: invoice.paymentRequestId },
-      });
-      logger.info(`registration successful`, {
-        paymentProviderId,
-        userId,
-      });
-      response.status(200).send({
-        message: 'registration successful',
-        paymentProviderId,
-        userId,
-      });
-    } else {
-      const { referenceId: orderPaymentId, invoice } = transaction;
-      logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
-      await modules.orders.payments.logEvent(orderPaymentId, {
-        transactionId: transaction.id,
-      });
-      const orderPayment = await modules.orders.payments.findOrderPayment({
-        orderPaymentId,
-      });
-      if (!orderPayment) {
-        throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
-      }
-
-      const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-        paymentContext: {
-          gatewayId: invoice.paymentRequestId,
-        },
-      });
-      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
-
-      logger.info(`checkout successful`, {
-        orderPaymentId,
-        orderId: order._id,
-      });
-      response.status(200).send({
-        message: 'checkout successful',
-        orderId: order._id,
-      });
-    }
-  } catch (error) {
-    logger.error(error, {
-      transactionId: transaction.id,
-    });
-    response.status(500).send({
-      message: error.message,
-      name: error.name,
-    });
-  }
-};

package/src/payment/payrexx/handler-fastify.ts

@@ -1,105 +0,0 @@
-import { Context } from '@unchainedshop/api';
-import { createLogger } from '@unchainedshop/logger';
-import { FastifyRequest, RouteHandlerMethod } from 'fastify';
-
-const logger = createLogger('unchained:payrexx:handler');
-
-export const payrexxHandler: RouteHandlerMethod = async (
-  request: FastifyRequest & {
-    unchainedContext: Context;
-  } & { body: Record<string, any> },
-  reply,
-) => {
-  const resolvedContext = request.unchainedContext as Context;
-  const { modules, services } = resolvedContext;
-
-  const { transaction } = request.body;
-  if (!transaction) {
-    logger.info(`unhandled event type`, {
-      type: Object.keys(request.body).join(','),
-    });
-    reply.status(200);
-    return reply.send({
-      success: false,
-      ignored: true,
-      message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
-    });
-  }
-  if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
-    // Ignore confirmed transactions, because those hooks are generated through calling the confirm()
-    // method in the payment adapter and could lead to double bookings.
-    logger.info(`unhandled transaction state: ${transaction.status}`);
-    reply.status(200);
-    return reply.send({
-      success: false,
-      ignored: true,
-      message: `Unhandled transaction state: ${transaction.status}`,
-    });
-  }
-
-  logger.info(`Processing event`, {
-    transactionId: transaction.id,
-  });
-  try {
-    if (transaction.preAuthorizationId) {
-      // Pre-Authorization Flow, referenceId is a userId
-      const { referenceId: paymentProviderId, invoice } = transaction;
-      const userId = '';
-      logger.info(`register credentials for: ${userId}`);
-      await services.orders.registerPaymentCredentials(paymentProviderId, {
-        userId,
-        transactionContext: { gatewayId: invoice.paymentRequestId },
-      });
-      logger.info(`registration successful`, {
-        paymentProviderId,
-        userId,
-      });
-      reply.status(200);
-      return reply.send({
-        success: true,
-        paymentProviderId,
-        userId,
-      });
-    } else {
-      const { referenceId: orderPaymentId, invoice } = transaction;
-      logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
-      const orderPayment = await modules.orders.payments.findOrderPayment({
-        orderPaymentId,
-      });
-      if (!orderPayment) {
-        throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
-      }
-
-      await modules.orders.payments.logEvent(orderPaymentId, {
-        transactionId: transaction.id,
-      });
-
-      const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-        paymentContext: {
-          gatewayId: invoice.paymentRequestId,
-        },
-      });
-      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
-
-      logger.info(`checkout successful`, {
-        orderPaymentId,
-        orderId: order._id,
-      });
-      reply.status(200);
-      return reply.send({
-        success: true,
-        orderId: order._id,
-      });
-    }
-  } catch (error) {
-    logger.error(error, {
-      transactionId: transaction.id,
-    });
-    reply.status(500);
-    return reply.send({
-      success: false,
-      message: error.message,
-      name: error.name,
-    });
-  }
-};