@webiny/handler 0.0.0-unstable.5e7233243f → 0.0.0-unstable.606fc9c866

package/Context.d.ts

@@ -1,13 +1,23 @@
-import { Context as BaseContext, ContextParams as BaseContextParams } from "@webiny/api";
-import { Context as BaseContextType } from "./types";
+import { Context as BaseContext, ContextParams as BaseContextParams, ContextPlugin as BaseContextPlugin, ContextPluginCallable as BaseContextPluginCallable } from "@webiny/api";
+import { Context as ContextInterface } from "./types";
 export interface ContextParams extends BaseContextParams {
-    server: BaseContextType["server"];
-    routes: BaseContextType["routes"];
+    server: ContextInterface["server"];
+    routes: ContextInterface["routes"];
 }
-export declare class Context extends BaseContext implements BaseContextType {
-    readonly server: BaseContextType["server"];
-    readonly routes: BaseContextType["routes"];
-    handlerClient: BaseContextType["handlerClient"];
-    request: BaseContextType["request"];
+export declare class Context extends BaseContext implements ContextInterface {
+    readonly server: ContextInterface["server"];
+    readonly routes: ContextInterface["routes"];
+    handlerClient: ContextInterface["handlerClient"];
+    request: ContextInterface["request"];
+    reply: ContextInterface["reply"];
     constructor(params: ContextParams);
 }
+/**
+ * We need to extend and reexport the ContextPlugin, ContextPluginCallable and createContextPlugin to support extended context.
+ *
+ * This can be removed when we introduce the type augmentation.
+ */
+export declare type ContextPluginCallable<T extends ContextInterface = ContextInterface> = BaseContextPluginCallable<T>;
+export declare class ContextPlugin<T extends ContextInterface = ContextInterface> extends BaseContextPlugin<T> {
+}
+export declare const createContextPlugin: <T extends ContextInterface = ContextInterface>(callable: ContextPluginCallable<T>) => BaseContextPlugin<T>;

package/Context.js

@@ -1,29 +1,40 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Context = void 0;
-
+exports.createContextPlugin = exports.ContextPlugin = exports.Context = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _api = require("@webiny/api");
-
 class Context extends _api.Context {
   // @ts-ignore
+
   // @ts-ignore
+
+  // @ts-ignore
+
   constructor(params) {
     super(params);
     (0, _defineProperty2.default)(this, "server", void 0);
     (0, _defineProperty2.default)(this, "routes", void 0);
     (0, _defineProperty2.default)(this, "handlerClient", void 0);
     (0, _defineProperty2.default)(this, "request", void 0);
+    (0, _defineProperty2.default)(this, "reply", void 0);
     this.server = params.server;
     this.routes = params.routes;
   }
-
 }
 
-exports.Context = Context;
+/**
+ * We need to extend and reexport the ContextPlugin, ContextPluginCallable and createContextPlugin to support extended context.
+ *
+ * This can be removed when we introduce the type augmentation.
+ */
+exports.Context = Context;
+class ContextPlugin extends _api.ContextPlugin {}
+exports.ContextPlugin = ContextPlugin;
+const createContextPlugin = callable => {
+  return (0, _api.createContextPlugin)(callable);
+};
+exports.createContextPlugin = createContextPlugin;

package/Context.js.map

@@ -1 +1 @@
-{"version":3,"names":["Context","BaseContext","constructor","params","server","routes"],"sources":["Context.ts"],"sourcesContent":["import { Context as BaseContext, ContextParams as BaseContextParams } from \"@webiny/api\";\nimport { Context as BaseContextType } from \"~/types\";\n\nexport interface ContextParams extends BaseContextParams {\n    server: BaseContextType[\"server\"];\n    routes: BaseContextType[\"routes\"];\n}\n\nexport class Context extends BaseContext implements BaseContextType {\n    public readonly server: BaseContextType[\"server\"];\n    public readonly routes: BaseContextType[\"routes\"];\n    // @ts-ignore\n    public handlerClient: BaseContextType[\"handlerClient\"];\n    // @ts-ignore\n    public request: BaseContextType[\"request\"];\n\n    public constructor(params: ContextParams) {\n        super(params);\n        this.server = params.server;\n        this.routes = params.routes;\n    }\n}\n"],"mappings":";;;;;;;;;;;AAAA;;AAQO,MAAMA,OAAN,SAAsBC,YAAtB,CAA6D;EAGhE;EAEA;EAGOC,WAAW,CAACC,MAAD,EAAwB;IACtC,MAAMA,MAAN;IADsC;IAAA;IAAA;IAAA;IAEtC,KAAKC,MAAL,GAAcD,MAAM,CAACC,MAArB;IACA,KAAKC,MAAL,GAAcF,MAAM,CAACE,MAArB;EACH;;AAZ+D"}
+{"version":3,"names":["Context","BaseContext","constructor","params","server","routes","ContextPlugin","BaseContextPlugin","createContextPlugin","callable","baseCreateContextPlugin"],"sources":["Context.ts"],"sourcesContent":["import {\n    Context as BaseContext,\n    ContextParams as BaseContextParams,\n    ContextPlugin as BaseContextPlugin,\n    ContextPluginCallable as BaseContextPluginCallable,\n    createContextPlugin as baseCreateContextPlugin\n} from \"@webiny/api\";\nimport { Context as ContextInterface } from \"~/types\";\n\nexport interface ContextParams extends BaseContextParams {\n    server: ContextInterface[\"server\"];\n    routes: ContextInterface[\"routes\"];\n}\n\nexport class Context extends BaseContext implements ContextInterface {\n    public readonly server: ContextInterface[\"server\"];\n    public readonly routes: ContextInterface[\"routes\"];\n    // @ts-ignore\n    public handlerClient: ContextInterface[\"handlerClient\"];\n    // @ts-ignore\n    public request: ContextInterface[\"request\"];\n    // @ts-ignore\n    public reply: ContextInterface[\"reply\"];\n\n    public constructor(params: ContextParams) {\n        super(params);\n        this.server = params.server;\n        this.routes = params.routes;\n    }\n}\n\n/**\n * We need to extend and reexport the ContextPlugin, ContextPluginCallable and createContextPlugin to support extended context.\n *\n * This can be removed when we introduce the type augmentation.\n */\nexport type ContextPluginCallable<T extends ContextInterface = ContextInterface> =\n    BaseContextPluginCallable<T>;\n\nexport class ContextPlugin<\n    T extends ContextInterface = ContextInterface\n> extends BaseContextPlugin<T> {}\n\nexport const createContextPlugin = <T extends ContextInterface = ContextInterface>(\n    callable: ContextPluginCallable<T>\n) => {\n    return baseCreateContextPlugin<T>(callable);\n};\n"],"mappings":";;;;;;;;AAAA;AAcO,MAAMA,OAAO,SAASC,YAAW,CAA6B;EAGjE;;EAEA;;EAEA;;EAGOC,WAAW,CAACC,MAAqB,EAAE;IACtC,KAAK,CAACA,MAAM,CAAC;IAAC;IAAA;IAAA;IAAA;IAAA;IACd,IAAI,CAACC,MAAM,GAAGD,MAAM,CAACC,MAAM;IAC3B,IAAI,CAACC,MAAM,GAAGF,MAAM,CAACE,MAAM;EAC/B;AACJ;;AAEA;AACA;AACA;AACA;AACA;AAJA;AAQO,MAAMC,aAAa,SAEhBC,kBAAiB,CAAI;AAAE;AAE1B,MAAMC,mBAAmB,GAC5BC,QAAkC,IACjC;EACD,OAAO,IAAAC,wBAAuB,EAAID,QAAQ,CAAC;AAC/C,CAAC;AAAC"}

package/fastify.d.ts

@@ -5,4 +5,4 @@ export interface CreateHandlerParams {
     plugins: PluginCollection;
     options?: ServerOptions;
 }
-export declare const createHandler: (params: CreateHandlerParams) => import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance, import("fastify").FastifyTypeProviderDefault> & PromiseLike<import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance, import("fastify").FastifyTypeProviderDefault>>;
+export declare const createHandler: (params: CreateHandlerParams) => import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<import("fastify").FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>>;

package/fastify.js

@@ -1,81 +1,75 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createHandler = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 var _fastify = _interopRequireDefault(require("fastify"));
-
 var _utils = require("@webiny/utils");
-
 var _Context = require("./Context");
-
 var _error = _interopRequireDefault(require("@webiny/error"));
-
 var _RoutePlugin = require("./plugins/RoutePlugin");
-
 var _handlerClient = require("@webiny/handler-client");
-
 var _cookie = _interopRequireDefault(require("@fastify/cookie"));
-
+var _compress = _interopRequireDefault(require("@fastify/compress"));
 var _middleware = require("./middleware");
-
 var _api = require("@webiny/api");
-
 var _BeforeHandlerPlugin = require("./plugins/BeforeHandlerPlugin");
-
 var _HandlerResultPlugin = require("./plugins/HandlerResultPlugin");
-
 var _HandlerErrorPlugin = require("./plugins/HandlerErrorPlugin");
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
-const DEFAULT_HEADERS = _objectSpread({
+var _ModifyFastifyPlugin = require("./plugins/ModifyFastifyPlugin");
+var _HandlerOnRequestPlugin = require("./plugins/HandlerOnRequestPlugin");
+const DEFAULT_HEADERS = (0, _objectSpread2.default)({
   "Cache-Control": "no-store",
   "Content-Type": "application/json; charset=utf-8",
   "Access-Control-Allow-Origin": "*",
   "Access-Control-Allow-Headers": "*",
   "Access-Control-Allow-Methods": "OPTIONS,POST,GET,DELETE,PUT,PATCH"
 }, (0, _utils.getWebinyVersionHeaders)());
-
 const getDefaultHeaders = routes => {
   /**
    * If we are accepting all headers, just output that one.
    */
   const keys = Object.keys(routes);
   const all = keys.every(key => routes[key].length > 0);
-
   if (all) {
-    return _objectSpread(_objectSpread({}, DEFAULT_HEADERS), {}, {
+    return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, DEFAULT_HEADERS), {}, {
       "Access-Control-Allow-Methods": "*"
     });
   }
-
-  return _objectSpread(_objectSpread({}, DEFAULT_HEADERS), {}, {
-    "Access-Control-Allow-Methods": keys.filter(key => {
-      const type = key;
-
+  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, DEFAULT_HEADERS), {}, {
+    "Access-Control-Allow-Methods": keys.filter(type => {
       if (!routes[type] || Array.isArray(routes[type]) === false) {
         return false;
       }
-
       return routes[type].length > 0;
     }).sort().join(",")
   });
 };
-
+const stringifyError = error => {
+  var _error$constructor;
+  const {
+    name,
+    message,
+    code,
+    stack,
+    data
+  } = error;
+  return JSON.stringify((0, _objectSpread2.default)((0, _objectSpread2.default)({}, error), {}, {
+    constructorName: ((_error$constructor = error.constructor) === null || _error$constructor === void 0 ? void 0 : _error$constructor.name) || "UnknownError",
+    name: name || "No error name",
+    message: message || "No error message",
+    code: code || "NO_CODE",
+    data,
+    stack: process.env.DEBUG === "true" ? stack : "Turn on the debug flag to see the stack."
+  }));
+};
 const OPTIONS_HEADERS = {
   "Access-Control-Max-Age": "86400",
   "Cache-Control": "public, max-age=86400"
 };
-
 const createHandler = params => {
   const definedRoutes = {
     POST: [],
@@ -84,20 +78,28 @@ const createHandler = params => {
     DELETE: [],
     PATCH: [],
     PUT: [],
-    HEAD: []
+    HEAD: [],
+    COPY: [],
+    LOCK: [],
+    MKCOL: [],
+    MOVE: [],
+    PROPFIND: [],
+    PROPPATCH: [],
+    SEARCH: [],
+    TRACE: [],
+    UNLOCK: []
   };
-
   const throwOnDefinedRoute = (type, path, options) => {
     if (type === "ALL") {
-      const all = Object.keys(definedRoutes).some(key => {
+      const all = Object.keys(definedRoutes).find(key => {
         const routes = definedRoutes[key];
         return routes.includes(path);
       });
-
       if (!all) {
         return;
       }
-
+      console.error(`Error while registering onAll route. One of the routes is already defined.`);
+      console.error(JSON.stringify(all));
       throw new _error.default(`You cannot override a route with onAll() method, please remove unnecessary route from the system.`, "OVERRIDE_ROUTE_ERROR", {
         type,
         path
@@ -107,59 +109,66 @@ const createHandler = params => {
     } else if ((options === null || options === void 0 ? void 0 : options.override) === true) {
       return;
     }
-
+    console.error(`Error while trying to override route: [${type}] ${path}`);
     throw new _error.default(`When you are trying to override existing route, you must send "override" parameter when adding that route.`, "OVERRIDE_ROUTE_ERROR", {
       type,
       path
     });
   };
-
-  const addDefinedRoute = (inputType, path) => {
-    const type = inputType.toUpperCase();
-
+  const addDefinedRoute = (type, path) => {
     if (!definedRoutes[type]) {
       return;
     } else if (definedRoutes[type].includes(path)) {
       return;
     }
-
     definedRoutes[type].push(path);
   };
   /**
    * We must attach the server to our internal context if we want to have it accessible.
    */
-
-
-  const app = (0, _fastify.default)(_objectSpread({}, params.options || {}));
+  const app = (0, _fastify.default)((0, _objectSpread2.default)({}, params.options || {}));
   /**
    * We need to register routes in our system so we can output headers later on and dissallow overriding routes.
    */
-
   app.addHook("onRoute", route => {
     const method = route.method;
-
     if (Array.isArray(method)) {
       for (const m of method) {
         addDefinedRoute(m, route.path);
       }
-
       return;
     }
-
     addDefinedRoute(method, route.path);
   });
   /**
+   * ############################
+   * Register the Fastify plugins.
+   */
+  /**
+   * Package @fastify/cookie
    *
+   * https://github.com/fastify/fastify-cookie
    */
-
   app.register(_cookie.default, {
     parseOptions: {} // options for parsing cookies
-
+  });
+  /**
+   * Package @fastify/compress
+   *
+   * https://github.com/fastify/fastify-compress
+   */
+  app.register(_compress.default, {
+    global: true,
+    threshold: 1024,
+    onUnsupportedEncoding: (encoding, _, reply) => {
+      reply.code(406);
+      return `We do not support the ${encoding} encoding.`;
+    },
+    inflateIfDeflated: true
   });
   /**
    * Route helpers - mostly for users.
    */
-
   const routes = {
     defined: definedRoutes,
     onPost: (path, handler, options) => {
@@ -195,26 +204,33 @@ const createHandler = params => {
       app.head(path, handler);
     }
   };
-  const context = new _Context.Context({
-    plugins: [
-    /**
-     * We must have handlerClient by default.
-     * And it must be one of the first context plugins applied.
-     */
-    (0, _handlerClient.createHandlerClient)(), ...(params.plugins || [])],
+  let context;
+  try {
+    context = new _Context.Context({
+      plugins: [
+      /**
+       * We must have handlerClient by default.
+       * And it must be one of the first context plugins applied.
+       */
+      (0, _handlerClient.createHandlerClient)(), ...(params.plugins || [])],
+      /**
+       * Inserted via webpack on build time.
+       */
+      WEBINY_VERSION: process.env.WEBINY_VERSION,
+      server: app,
+      routes
+    });
+  } catch (ex) {
+    console.error(`Error while constructing the Context.`);
+    console.error(stringifyError(ex));
+    throw ex;
+  }
 
-    /**
-     * Inserted via webpack on build time.
-     */
-    WEBINY_VERSION: process.env.WEBINY_VERSION,
-    server: app,
-    routes
-  });
   /**
-   * We are attaching our custom context to webiny variable on the fastify app so it is accessible everywhere
+   * We are attaching our custom context to webiny variable on the fastify app, so it is accessible everywhere.
    */
-
   app.decorate("webiny", context);
+
   /**
    * We have few types of triggers:
    *  * Events - EventPlugin
@@ -222,94 +238,190 @@ const createHandler = params => {
    *
    * Routes are registered in fastify but events must be handled in package which implements cloud specific methods.
    */
-
   const routePlugins = app.webiny.plugins.byType(_RoutePlugin.RoutePlugin.type);
+
   /**
    * Add routes to the system.
    */
-
-  for (const plugin of routePlugins) {
-    plugin.cb(_objectSpread(_objectSpread({}, app.webiny.routes), {}, {
-      context: app.webiny
-    }));
+  let routePluginName;
+  try {
+    for (const plugin of routePlugins) {
+      routePluginName = plugin.name;
+      plugin.cb((0, _objectSpread2.default)((0, _objectSpread2.default)({}, app.webiny.routes), {}, {
+        context: app.webiny
+      }));
+    }
+  } catch (ex) {
+    console.error(`Error while running the "RoutePlugin" ${routePluginName ? `(${routePluginName})` : ""} plugin in the beginning of the "createHandler" callable.`);
+    console.error(stringifyError(ex));
+    throw ex;
   }
+
   /**
    * On every request we add default headers, which can be changed later.
    * Also, if it is an options request, we skip everything after this hook and output options headers.
    */
-
-
   app.addHook("onRequest", async (request, reply) => {
+    /**
+     * Our default headers are always set. Users can override them.
+     */
     const defaultHeaders = getDefaultHeaders(definedRoutes);
     reply.headers(defaultHeaders);
-
+    /**
+     * Users can define their own custom handlers for the onRequest event - so let's run them first.
+     */
+    const plugins = app.webiny.plugins.byType(_HandlerOnRequestPlugin.HandlerOnRequestPlugin.type);
+    let name;
+    try {
+      for (const plugin of plugins) {
+        name = plugin.name;
+        const result = await plugin.exec(request, reply);
+        if (result === false) {
+          return;
+        }
+      }
+    } catch (ex) {
+      console.error(`Error while running the "HandlerOnRequestPlugin" ${name ? `(${name})` : ""} plugin in the onRequest hook.`);
+      console.error(stringifyError(ex));
+      throw ex;
+    }
+    /**
+     * When we receive the OPTIONS request, we end it before it goes any further as there is no need for anything to run after this - at least for our use cases.
+     *
+     * Users can prevent this by creating their own HandlerOnRequestPlugin and returning false as the result of the callable.
+     */
     if (request.method !== "OPTIONS") {
       return;
     }
-
-    const raw = reply.code(204).hijack().raw;
-
-    const headers = _objectSpread(_objectSpread({}, defaultHeaders), OPTIONS_HEADERS);
-
-    for (const key in headers) {
-      raw.setHeader(key, headers[key]);
+    if (reply.sent) {
+      /**
+       * At this point throwing an exception will not do anything with the response. So just log it.
+       */
+      console.error(JSON.stringify({
+        message: `Output was already sent. Please check custom plugins of type "HandlerOnRequestPlugin".`,
+        explanation: "This error can happen if the user plugin ended the reply, but did not return false as response."
+      }));
+      return;
     }
-
-    raw.end("");
+    reply.headers((0, _objectSpread2.default)((0, _objectSpread2.default)({}, defaultHeaders), OPTIONS_HEADERS)).code(204).send("").hijack();
   });
-  app.addHook("preParsing", async request => {
+  app.addHook("preParsing", async (request, reply) => {
     app.webiny.request = request;
+    app.webiny.reply = reply;
     const plugins = app.webiny.plugins.byType(_api.ContextPlugin.type);
-
-    for (const plugin of plugins) {
-      await plugin.apply(app.webiny);
+    let name;
+    try {
+      for (const plugin of plugins) {
+        name = plugin.name;
+        await plugin.apply(app.webiny);
+      }
+    } catch (ex) {
+      console.error(`Error while running the "ContextPlugin" ${name ? `(${name})` : ""} plugin in the preParsing hook.`);
+      console.error(stringifyError(ex));
+      throw ex;
     }
   });
   /**
    *
    */
-
   app.addHook("preHandler", async () => {
     const plugins = app.webiny.plugins.byType(_BeforeHandlerPlugin.BeforeHandlerPlugin.type);
-
-    for (const plugin of plugins) {
-      await plugin.apply(app.webiny);
+    let name;
+    try {
+      for (const plugin of plugins) {
+        name = plugin.name;
+        await plugin.apply(app.webiny);
+      }
+    } catch (ex) {
+      console.error(`Error while running the "BeforeHandlerPlugin" ${name ? `(${name})` : ""} plugin in the preHandler hook.`);
+      console.error(stringifyError(ex));
+      throw ex;
     }
   });
+
   /**
    *
    */
-
   const preSerialization = async (_, __, payload) => {
     const plugins = app.webiny.plugins.byType(_HandlerResultPlugin.HandlerResultPlugin.type);
-
-    for (const plugin of plugins) {
-      await plugin.handle(app.webiny, payload);
+    let name;
+    try {
+      for (const plugin of plugins) {
+        name = plugin.name;
+        await plugin.handle(app.webiny, payload);
+      }
+    } catch (ex) {
+      console.error(`Error while running the "HandlerResultPlugin" ${name ? `(${name})` : ""} plugin in the preSerialization hook.`);
+      console.error(stringifyError(ex));
+      throw ex;
     }
-
     return payload;
   };
-
   app.addHook("preSerialization", preSerialization);
+  app.setErrorHandler(async (error, request, reply) => {
+    return reply.status(500).headers({
+      "Cache-Control": "no-store"
+    }).send(
+    /**
+     * When we are sending the error in the response, we cannot send the whole error object, as it might contain some sensitive data.
+     */
+    JSON.stringify({
+      message: error.message,
+      code: error.code,
+      data: error.data
+    }));
+  });
   app.addHook("onError", async (_, reply, error) => {
-    const plugins = app.webiny.plugins.byType(_HandlerErrorPlugin.HandlerErrorPlugin.type); // Log error to cloud, as these can be extremely annoying to debug!
-
-    console.log("@webiny/handler");
-    console.log(JSON.stringify(_objectSpread(_objectSpread({}, error || {}), {}, {
-      message: error === null || error === void 0 ? void 0 : error.message,
-      code: error === null || error === void 0 ? void 0 : error.code
-    })));
+    const plugins = app.webiny.plugins.byType(_HandlerErrorPlugin.HandlerErrorPlugin.type);
+    /**
+     * Log error to cloud, as these can be extremely annoying to debug!
+     */
+    console.error("@webiny/handler");
+    console.error(stringifyError(error));
+    reply.status(500).headers({
+      "Cache-Control": "no-store"
+    }).send(
+    /**
+     * When we are sending the error in the response, we cannot send the whole error object, as it might contain some sensitive data.
+     */
+    JSON.stringify({
+      message: error.message,
+      code: error.code,
+      data: error.data
+    }));
     const handler = (0, _middleware.middleware)(plugins.map(pl => {
       return (context, error, next) => {
         return pl.handle(context, error, next);
       };
     }));
     await handler(app.webiny, error);
-    return reply.headers({
-      "Cache-Control": "no-store"
-    }).status(500);
+    return reply;
+  });
+  /**
+   * We need to output the benchmark results at the end of the request in both response and timeout cases
+   */
+  app.addHook("onResponse", async () => {
+    await context.benchmark.output();
   });
+  app.addHook("onTimeout", async () => {
+    await context.benchmark.output();
+  });
+
+  /**
+   * With these plugins we give users possibility to do anything they want on our fastify instance.
+   */
+  const modifyPlugins = app.webiny.plugins.byType(_ModifyFastifyPlugin.ModifyFastifyPlugin.type);
+  let modifyFastifyPluginName;
+  try {
+    for (const plugin of modifyPlugins) {
+      modifyFastifyPluginName = plugin.name;
+      plugin.modify(app);
+    }
+  } catch (ex) {
+    console.error(`Error while running the "ModifyFastifyPlugin" ${modifyFastifyPluginName ? `(${modifyFastifyPluginName})` : ""} plugin in the end of the "createHandler" callable.`);
+    console.error(stringifyError(ex));
+    throw ex;
+  }
   return app;
 };
-
 exports.createHandler = createHandler;