@unchainedshop/plugins 3.0.0-rc9 → 3.0.1

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

@@ -0,0 +1,89 @@
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+import { createLogger } from '@unchainedshop/logger';
+import { Context } from '@unchainedshop/api';
+import { OrderStatus } from '@unchainedshop/core-orders';
+import { CryptopayModule } from './module.js';
+import { ProductPriceRate } from '@unchainedshop/core-products';
+
+const { CRYPTOPAY_SECRET, CRYPTOPAY_MAX_RATE_AGE = '360' } = process.env;
+
+const logger = createLogger('unchained:core-payment:cryptopay');
+
+const cryptopayHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & {
+    unchainedContext: Context & {
+      modules: CryptopayModule;
+    };
+  },
+  reply,
+) => {
+  const { modules, services } = req.unchainedContext;
+
+  try {
+    const { secret, price, wallet, ping } = req.body as Record<string, any>;
+    if (secret !== CRYPTOPAY_SECRET) {
+      logger.warn(`Cryptopay Plugin: Invalid Cryptopay Secret provided`);
+      throw new Error('Secret invalid');
+    }
+
+    if (wallet) {
+      const { address, blockHeight, amount, contract, decimals, currency } = wallet;
+      const { orderPaymentId } = await modules.cryptopay.updateWalletAddress({
+        addressId: address,
+        blockHeight,
+        amount,
+        contract,
+        decimals,
+        currency,
+      });
+      const orderPayment =
+        orderPaymentId &&
+        (await modules.orders.payments.findOrderPayment({
+          orderPaymentId,
+        }));
+
+      if (orderPayment) {
+        // Try to process order to next status
+        // TODO: Not sure if it's correct to use processOrder here if status is PENDING!
+        const order = await modules.orders.findOrder({ orderId: orderPayment.orderId });
+        if (order.status === null) {
+          await services.orders.checkoutOrder(order._id, {});
+        } else if (order.status === OrderStatus.PENDING) {
+          await services.orders.processOrder(order, {});
+        } else {
+          throw new Error('Already processed');
+        }
+      }
+    }
+
+    if (price) {
+      const { baseCurrency, token, rate, timestamp } = price;
+
+      const timestampDate = new Date(timestamp);
+      const expiresAt = new Date(new Date().getTime() + parseInt(CRYPTOPAY_MAX_RATE_AGE, 10) * 1000);
+
+      const rateData: ProductPriceRate = {
+        baseCurrency,
+        quoteCurrency: token,
+        rate,
+        expiresAt,
+        timestamp: timestampDate,
+      };
+      logger.info(`update rate ${JSON.stringify(price)}, ${JSON.stringify(rateData)}`);
+      await modules.products.prices.rates.updateRates([rateData]);
+    }
+
+    if (ping) {
+      const { blockHeight, currency } = ping;
+      await modules.cryptopay.updateMostRecentBlock(currency, blockHeight);
+    }
+
+    reply.status(200);
+    return reply.send({ success: true });
+  } catch (e) {
+    reply.status(500);
+    return reply.send({ success: false, error: e.message });
+  }
+};
+
+export default cryptopayHandler;

package/src/payment/cryptopay/index.ts

@@ -1,6 +1,7 @@
-import CryptopayPlugin from './plugin.js';
+import './plugin.js';
 
-export * from './middleware.js';
-export * from './module/configureCryptopayModule.js';
+import cryptopayModules, { type CryptopayModule } from './module.js';
 
-export default CryptopayPlugin;
+export type { CryptopayModule };
+
+export default cryptopayModules;

package/src/payment/cryptopay/{module/configureCryptopayModule.ts → module.ts}

@@ -1,38 +1,14 @@
 import { mongodb } from '@unchainedshop/mongodb';
-import { CryptopayTransaction, CryptopayTransactionsCollection } from '../db/CryptopayTransactions.js';
+import { CryptopayTransaction, CryptopayTransactionsCollection } from './db/CryptopayTransactions.js';
 
-export interface CryptopayModule {
-  getWalletAddress: (addressId: string) => Promise<CryptopayTransaction>;
-  getWalletAddressesByOrderPaymentId: (orderPaymentId: string) => Promise<CryptopayTransaction[]>;
-  updateMostRecentBlock: (currency: string, blockHeight: number) => Promise<void>;
-  updateWalletAddress: (walletData: {
-    addressId: string;
-    blockHeight: number;
-    amount: string;
-    contract: string;
-    currency: string;
-    decimals: number;
-  }) => Promise<CryptopayTransaction>;
-  mapOrderPaymentToWalletAddress: (walletData: {
-    addressId: string;
-    contract: string;
-    currency: string;
-    orderPaymentId: string;
-  }) => Promise<CryptopayTransaction>;
-  getNextDerivationNumber: (currency: string) => Promise<number>;
-}
-
-export const configureCryptopayModule = ({ db }): CryptopayModule => {
+const configureCryptopayModule = ({ db }) => {
   const CryptoTransactions = CryptopayTransactionsCollection(db);
 
-  const getWalletAddress: CryptopayModule['getWalletAddress'] = async (addressId) => {
+  const getWalletAddress = async (addressId: string): Promise<CryptopayTransaction> => {
     return CryptoTransactions.findOne({ _id: addressId.toLowerCase() });
   };
 
-  const updateMostRecentBlock: CryptopayModule['updateMostRecentBlock'] = async (
-    currency,
-    blockHeight,
-  ) => {
+  const updateMostRecentBlock = async (currency: string, blockHeight: number): Promise<void> => {
     await CryptoTransactions.updateMany(
       {
         currency,
@@ -45,12 +21,17 @@ export const configureCryptopayModule = ({ db }): CryptopayModule => {
     );
   };
 
-  const mapOrderPaymentToWalletAddress: CryptopayModule['mapOrderPaymentToWalletAddress'] = async ({
+  const mapOrderPaymentToWalletAddress = async ({
     addressId,
     contract,
     currency,
     orderPaymentId,
-  }) => {
+  }: {
+    addressId: string;
+    contract: string;
+    currency: string;
+    orderPaymentId: string;
+  }): Promise<CryptopayTransaction> => {
     await CryptoTransactions.updateOne(
       {
         _id: addressId.toLowerCase(),
@@ -77,25 +58,33 @@ export const configureCryptopayModule = ({ db }): CryptopayModule => {
     return CryptoTransactions.findOne({ _id: addressId.toLowerCase() });
   };
 
-  const getNextDerivationNumber: CryptopayModule['getNextDerivationNumber'] = async (currency) => {
+  const getNextDerivationNumber = async (currency: string): Promise<number> => {
     return (await CryptoTransactions.countDocuments({ currency })) + 1;
   };
 
-  const getWalletAddressesByOrderPaymentId: CryptopayModule['getWalletAddressesByOrderPaymentId'] =
-    async (orderPaymentId) => {
-      return CryptoTransactions.find({
-        orderPaymentId,
-      }).toArray();
-    };
+  const getWalletAddressesByOrderPaymentId = async (
+    orderPaymentId: string,
+  ): Promise<CryptopayTransaction[]> => {
+    return CryptoTransactions.find({
+      orderPaymentId,
+    }).toArray();
+  };
 
-  const updateWalletAddress: CryptopayModule['updateWalletAddress'] = async ({
+  const updateWalletAddress = async ({
     addressId,
     blockHeight,
     amount,
     contract,
     currency,
     decimals,
-  }) => {
+  }: {
+    addressId: string;
+    blockHeight: number;
+    amount: string;
+    contract: string;
+    currency: string;
+    decimals: number;
+  }): Promise<CryptopayTransaction> => {
     await CryptoTransactions.updateOne(
       {
         _id: addressId.toLowerCase(),
@@ -130,3 +119,13 @@ export const configureCryptopayModule = ({ db }): CryptopayModule => {
     getWalletAddressesByOrderPaymentId,
   };
 };
+
+export default {
+  cryptopay: {
+    configure: configureCryptopayModule,
+  },
+};
+
+export type CryptopayModule = {
+  cryptopay: ReturnType<typeof configureCryptopayModule>;
+};

package/src/payment/cryptopay/plugin.ts

@@ -10,7 +10,7 @@ import {
   PaymentError,
   OrderPricingSheet,
 } from '@unchainedshop/core';
-import { CryptopayModule } from './module/configureCryptopayModule.js';
+import { CryptopayModule } from './module.js';
 
 const logger = createLogger('unchained:core-payment:cryptopay');
 
@@ -59,7 +59,7 @@ const Cryptopay: IPaymentAdapter = {
   },
 
   actions: (config, context) => {
-    const { modules } = context as typeof context & { modules: { cryptopay: CryptopayModule } };
+    const { modules } = context as typeof context & { modules: CryptopayModule };
 
     const setConversionRates = async (currencyCode: string, existingAddresses: any[]) => {
       const originCurrencyObj = await modules.currencies.findCurrency({ isoCode: currencyCode });
@@ -267,7 +267,7 @@ const Cryptopay: IPaymentAdapter = {
 
         1. Check that generated crypto addresses are unique and no order payments share the same crypto address, only repeat when derivations completely exhausted.
         2. When derivation path get's close to "exhaustedness" (95%), send a special e-mail alert to tell the user should generate a new xpub.
-        3. Extend the middleware to report the highest seen block number so we can calculate confirmations, 
+        3. Extend the handler to report the highest seen block number so we can calculate confirmations, 
         4. Order rejection should trigger an e-mail advising the vendor to actively send back funds
 
         To allow paying in ETH or BTC or Tokens for CHF orders, it should work like this:

package/src/payment/datatrans-v2/{middleware.ts → handler-express.ts}

@@ -9,7 +9,7 @@ const {
   DATATRANS_SECURITY = Security.DYNAMIC_SIGN,
 } = process.env;
 
-const logger = createLogger('unchained:core-payment:datatrans:webhook');
+const logger = createLogger('unchained:core-payment:datatrans:handler');
 
 export const datatransHandler = async (req, res) => {
   const resolvedContext = req.unchainedContext as Context;

package/src/payment/datatrans-v2/handler-fastify.ts

@@ -0,0 +1,88 @@
+import { createLogger } from '@unchainedshop/logger';
+import { Context } from '@unchainedshop/api';
+import generateSignature, { Security } from './generateSignature.js';
+import { StatusResponseSuccess } from './api/types.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const {
+  DATATRANS_SIGN_KEY,
+  DATATRANS_SIGN2_KEY,
+  DATATRANS_SECURITY = Security.DYNAMIC_SIGN,
+} = process.env;
+
+const logger = createLogger('unchained:core-payment:datatrans:handler');
+
+export const datatransHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & {
+    unchainedContext: Context;
+  },
+  reply,
+) => {
+  const resolvedContext = req.unchainedContext as Context;
+  const { modules, services } = resolvedContext;
+  const signature = req.headers['datatrans-signature'] as string;
+  if (signature) {
+    const [rawTimestamp, rawHash] = signature.split(',');
+    const [, hash] = rawHash.split('=');
+    const [, timestamp] = rawTimestamp.split('=');
+
+    const comparableSignature = await generateSignature({
+      security: DATATRANS_SECURITY as any,
+      signKey: DATATRANS_SIGN2_KEY || DATATRANS_SIGN_KEY,
+    })(timestamp, req.body as string);
+
+    if (hash !== comparableSignature) {
+      logger.error(`hash mismatch: ${signature} / ${comparableSignature}`, req.body as string);
+      reply.status(403);
+      return reply.send('Hash mismatch');
+    }
+
+    const transaction: StatusResponseSuccess = JSON.parse(req.body as string) as StatusResponseSuccess;
+
+    logger.info(`received request`, {
+      type: transaction.type,
+    });
+
+    if (transaction.status === 'authorized') {
+      const userId = transaction.refno2;
+      const referenceId = Buffer.from(transaction.refno, 'base64').toString('hex');
+
+      try {
+        if (transaction.type === 'card_check') {
+          const paymentProviderId = referenceId;
+          const paymentCredentials = await services.orders.registerPaymentCredentials(
+            paymentProviderId,
+            { userId, transactionContext: { transactionId: transaction.transactionId } },
+          );
+          logger.info(`registered payment credentials for ${userId}`, {
+            userId,
+          });
+          reply.status(200);
+          return reply.send(paymentCredentials);
+        }
+        if (transaction.type === 'payment') {
+          const orderPaymentId = referenceId;
+          const orderPayment = await modules.orders.payments.findOrderPayment({
+            orderPaymentId,
+          });
+          if (!orderPayment) throw new Error(`Order Payment with id ${orderPaymentId} not found`);
+
+          const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+            paymentContext: { userId, transactionId: transaction.transactionId },
+          });
+          reply.status(200);
+          logger.info(`confirmed checkout for order ${order.orderNumber}`, {
+            orderId: order._id,
+          });
+          return reply.send(order);
+        }
+      } catch (e) {
+        logger.error(`rejected to checkout with message`, e);
+        reply.status(500);
+        return reply.send({ name: e.name, code: e.code, message: e.message });
+      }
+    }
+  }
+  reply.status(404);
+  return reply.send();
+};

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

@@ -20,8 +20,6 @@ import {
   OrderPricingSheet,
 } from '@unchainedshop/core';
 
-export * from './middleware.js';
-
 const logger = createLogger('unchained:core-payment:datatrans');
 
 // v2

package/src/payment/paypal-checkout.ts

@@ -38,9 +38,9 @@ const environment = () => {
 const PaypalCheckout: IPaymentAdapter = {
   ...PaymentAdapter,
 
-  key: 'com.paypal.checkout',
+  key: 'shop.unchained.payment.paypal',
   label: 'Paypal',
-  version: '1.0.0',
+  version: '1.0.1',
 
   initialConfiguration: [],
 

package/src/payment/payrexx/{middleware.ts → handler-express.ts}

@@ -1,7 +1,7 @@
 import { Context } from '@unchainedshop/api';
 import { createLogger } from '@unchainedshop/logger';
 
-const logger = createLogger('unchained:core-payment:payrexx:webhook');
+const logger = createLogger('unchained:core-payment:payrexx:handler');
 
 export const payrexxHandler = async (request, response) => {
   const resolvedContext = request.unchainedContext as Context;

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

@@ -0,0 +1,105 @@
+import { Context } from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:core-payment:payrexx:handler');
+
+export const payrexxHandler: RouteHandlerMethod = async (
+  request: FastifyRequest & {
+    unchainedContext: Context;
+  },
+  reply,
+) => {
+  const resolvedContext = request.unchainedContext as Context;
+  const { modules, services } = resolvedContext;
+
+  const { transaction } = request.body as Record<string, any>;
+
+  if (!transaction) {
+    logger.info(`unhandled event type`, {
+      type: Object.keys(request.body).join(','),
+    });
+    reply.status(200);
+    return reply.send(
+      JSON.stringify({
+        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(
+      JSON.stringify({
+        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(
+        JSON.stringify({
+          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,
+        },
+      });
+      logger.info(`checkout successful`, {
+        orderPaymentId,
+        orderId: order._id,
+      });
+      reply.status(200);
+      return reply.send(
+        JSON.stringify({
+          message: 'checkout successful',
+          orderId: order._id,
+        }),
+      );
+    }
+  } catch (error) {
+    logger.error(error, {
+      transactionId: transaction.id,
+    });
+    reply.status(500);
+    return reply.send(error.message);
+  }
+};

package/src/payment/payrexx/index.ts

@@ -9,8 +9,6 @@ import {
   PaymentError,
 } from '@unchainedshop/core';
 
-export * from './middleware.js';
-
 const logger = createLogger('unchained:core-payment:payrexx');
 
 const Payrexx: IPaymentAdapter = {

package/src/payment/postfinance-checkout/handler-fastify.ts

@@ -0,0 +1,52 @@
+import { Context } from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import { WebhookData } from './types.js';
+import { getTransaction, getTransactionCompletion } from './api.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:core-payment:postfinance-checkout');
+
+export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & {
+    unchainedContext: Context;
+  },
+  reply,
+) => {
+  const context = req.unchainedContext as Context;
+  const { services, modules } = context;
+  const data = req.body as WebhookData;
+  if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
+    try {
+      const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
+      const transaction = await getTransaction(
+        transactionCompletion.linkedTransaction as unknown as string,
+      );
+      const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
+      const orderPayment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId,
+      });
+      if (!orderPayment) throw new Error('Order Payment not found');
+
+      const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+        paymentContext: {
+          transactionId: transactionCompletion.linkedTransaction,
+        },
+      });
+      logger.info(
+        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+      );
+      reply.status(200);
+      return reply.send(`Order marked as paid: ${order.orderNumber}`);
+    } catch (e) {
+      logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
+      reply.status(500);
+      return reply.send({ name: e.name, code: e.code, message: e.message });
+    }
+  } else {
+    logger.error(
+      `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
+    );
+    reply.status(404);
+    return reply.send();
+  }
+};

package/src/payment/postfinance-checkout/index.ts

@@ -24,8 +24,6 @@ import {
 import { orderIsPaid } from './utils.js';
 import { CompletionModes, IntegrationModes, SignResponse } from './types.js';
 
-export * from './middleware.js';
-
 const { PostFinanceCheckout } = pf;
 
 const {

package/src/payment/saferpay/adapter.ts

@@ -1,7 +1,7 @@
 import { mongodb } from '@unchainedshop/mongodb';
 import { PaymentPageInitializeInput, SaferpayClient } from './api/index.js';
 import { buildSignature } from './buildSignature.js';
-import { SaferpayTransactionsModule } from './module/configureSaferpayTransactionsModule.js';
+import { SaferpayTransactionsModule } from './module.js';
 import {
   OrderPricingSheet,
   IPaymentAdapter,
@@ -10,8 +10,6 @@ import {
   PaymentError,
 } from '@unchainedshop/core';
 
-export * from './middleware.js';
-
 const {
   SAFERPAY_BASE_URL = 'https://test.saferpay.com/api',
   SAFERPAY_CUSTOMER_ID,
@@ -48,7 +46,7 @@ export const WordlineSaferpay: IPaymentAdapter = {
 
   actions: (config, context) => {
     const { modules } = context as typeof context & {
-      modules: { saferpayTransactions: SaferpayTransactionsModule };
+      modules: SaferpayTransactionsModule;
     };
 
     const createSaferPayClient = () => {

package/src/payment/saferpay/{middleware.ts → handler-express.ts}

@@ -1,13 +1,13 @@
 import { Context } from '@unchainedshop/api';
 import { createLogger } from '@unchainedshop/logger';
 import { buildSignature } from './buildSignature.js';
-import { SaferpayTransactionsModule } from './module/configureSaferpayTransactionsModule.js';
+import { SaferpayTransactionsModule } from './module.js';
 
-const logger = createLogger('unchained:core-payment:saferpay:webhook');
+const logger = createLogger('unchained:core-payment:saferpay:handler');
 
 export const saferpayHandler = async (request, response) => {
   const resolvedContext = request.unchainedContext as Context & {
-    modules: { saferpayTransactions: SaferpayTransactionsModule };
+    modules: SaferpayTransactionsModule;
   };
   const { modules, services } = resolvedContext;
 

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

@@ -0,0 +1,75 @@
+import { Context } from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import { buildSignature } from './buildSignature.js';
+import { SaferpayTransactionsModule } from './module.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:core-payment:saferpay:handler');
+
+export const saferpayHandler: RouteHandlerMethod = async (
+  request: FastifyRequest & {
+    unchainedContext: Context;
+  },
+  reply,
+) => {
+  const resolvedContext = request.unchainedContext as Context & {
+    modules: SaferpayTransactionsModule;
+  };
+  const { modules, services } = resolvedContext;
+
+  const { orderPaymentId, signature, transactionId } = request.query as Record<string, string>;
+  const isValidRequest =
+    typeof orderPaymentId === 'string' &&
+    typeof signature === 'string' &&
+    typeof transactionId === 'string' &&
+    orderPaymentId &&
+    transactionId &&
+    signature;
+
+  if (!isValidRequest) {
+    logger.warn(`orderPaymentId missing in query`);
+    reply.status(404);
+    return reply.send();
+  }
+
+  try {
+    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}`);
+    }
+
+    const correctSignature = await buildSignature(transactionId, orderPaymentId);
+
+    if (correctSignature !== signature) {
+      throw new Error('Invalid signature');
+    }
+
+    const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+      paymentContext: {
+        transactionId,
+      },
+    });
+    logger.info(`checkout successful`, {
+      orderPaymentId,
+      orderId: order._id,
+    });
+    reply.status(200);
+    return reply.send(
+      JSON.stringify({
+        message: 'checkout successful',
+        orderPaymentId,
+        orderId: order._id,
+      }),
+    );
+  } catch (error) {
+    logger.error(error, {
+      orderPaymentId,
+      transactionId,
+    });
+    reply.status(500);
+    return reply.send(error.message);
+  }
+};