@webiny/handler 0.0.0-unstable.fcdad0bc61 → 0.0.0-unstable.fdd9228b5d

package/ResponseHeaders.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResponseHeaders = void 0;
+// Extract known standard headers, and remove all non-string keys.
+
+function isFunction(setter) {
+  return typeof setter === "function";
+}
+class ResponseHeaders {
+  headers = new Map();
+  constructor(initialHeaders) {
+    if (initialHeaders) {
+      Object.keys(initialHeaders).forEach(key => {
+        this.headers.set(key, initialHeaders[key]);
+      });
+    }
+  }
+  set(header, setter) {
+    if (isFunction(setter)) {
+      const previousValue = this.headers.get(header);
+      const newValue = setter(previousValue);
+      this.headers.set(header, newValue);
+      return this;
+    }
+    this.headers.set(header, setter);
+    return this;
+  }
+  merge(headers) {
+    return ResponseHeaders.create({
+      ...this.getHeaders(),
+      ...headers.getHeaders()
+    });
+  }
+  getHeaders() {
+    return Object.fromEntries(this.headers);
+  }
+  static create(initialHeaders) {
+    return new ResponseHeaders(initialHeaders);
+  }
+}
+exports.ResponseHeaders = ResponseHeaders;
+
+//# sourceMappingURL=ResponseHeaders.js.map

package/ResponseHeaders.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isFunction","setter","ResponseHeaders","headers","Map","constructor","initialHeaders","Object","keys","forEach","key","set","header","previousValue","get","newValue","merge","create","getHeaders","fromEntries","exports"],"sources":["ResponseHeaders.ts"],"sourcesContent":["import type * as http from \"http\";\n\ntype ExtraHeaders = {\n    \"content-type\"?: string | undefined;\n    \"x-webiny-version\"?: http.OutgoingHttpHeader | undefined;\n};\n\ntype AllHeaders = http.OutgoingHttpHeaders & ExtraHeaders;\n\nexport type StandardHeaderValue = http.OutgoingHttpHeader | undefined;\n\n// Extract known standard headers, and remove all non-string keys.\nexport type StandardHeaders = {\n    [K in keyof AllHeaders as string extends K\n        ? never\n        : number extends K\n        ? never\n        : K]: http.OutgoingHttpHeaders[K];\n} & {\n    [name: string]: StandardHeaderValue;\n};\n\nfunction isFunction<T>(setter: unknown): setter is (value: T) => T {\n    return typeof setter === \"function\";\n}\n\ntype Setter<T> = ((value: T) => T) | T;\n\nexport class ResponseHeaders {\n    private readonly headers = new Map<keyof StandardHeaders, StandardHeaderValue>();\n\n    private constructor(initialHeaders?: StandardHeaders) {\n        if (initialHeaders) {\n            (Object.keys(initialHeaders) as Array<keyof StandardHeaders>).forEach(key => {\n                this.headers.set(key, initialHeaders[key]);\n            });\n        }\n    }\n\n    set<T extends keyof StandardHeaders>(header: T, setter: Setter<StandardHeaders[T]>) {\n        if (isFunction<StandardHeaders[T]>(setter)) {\n            const previousValue = this.headers.get(header) as StandardHeaders[T];\n            const newValue = setter(previousValue);\n            this.headers.set(header, newValue);\n            return this;\n        }\n\n        this.headers.set(header, setter);\n\n        return this;\n    }\n\n    merge(headers: ResponseHeaders) {\n        return ResponseHeaders.create({ ...this.getHeaders(), ...headers.getHeaders() });\n    }\n\n    getHeaders() {\n        return Object.fromEntries(this.headers);\n    }\n\n    static create(initialHeaders?: StandardHeaders) {\n        return new ResponseHeaders(initialHeaders);\n    }\n}\n"],"mappings":";;;;;;AAWA;;AAWA,SAASA,UAAUA,CAAIC,MAAe,EAA6B;EAC/D,OAAO,OAAOA,MAAM,KAAK,UAAU;AACvC;AAIO,MAAMC,eAAe,CAAC;EACRC,OAAO,GAAG,IAAIC,GAAG,CAA6C,CAAC;EAExEC,WAAWA,CAACC,cAAgC,EAAE;IAClD,IAAIA,cAAc,EAAE;MACfC,MAAM,CAACC,IAAI,CAACF,cAAc,CAAC,CAAkCG,OAAO,CAACC,GAAG,IAAI;QACzE,IAAI,CAACP,OAAO,CAACQ,GAAG,CAACD,GAAG,EAAEJ,cAAc,CAACI,GAAG,CAAC,CAAC;MAC9C,CAAC,CAAC;IACN;EACJ;EAEAC,GAAGA,CAAkCC,MAAS,EAAEX,MAAkC,EAAE;IAChF,IAAID,UAAU,CAAqBC,MAAM,CAAC,EAAE;MACxC,MAAMY,aAAa,GAAG,IAAI,CAACV,OAAO,CAACW,GAAG,CAACF,MAAM,CAAuB;MACpE,MAAMG,QAAQ,GAAGd,MAAM,CAACY,aAAa,CAAC;MACtC,IAAI,CAACV,OAAO,CAACQ,GAAG,CAACC,MAAM,EAAEG,QAAQ,CAAC;MAClC,OAAO,IAAI;IACf;IAEA,IAAI,CAACZ,OAAO,CAACQ,GAAG,CAACC,MAAM,EAAEX,MAAM,CAAC;IAEhC,OAAO,IAAI;EACf;EAEAe,KAAKA,CAACb,OAAwB,EAAE;IAC5B,OAAOD,eAAe,CAACe,MAAM,CAAC;MAAE,GAAG,IAAI,CAACC,UAAU,CAAC,CAAC;MAAE,GAAGf,OAAO,CAACe,UAAU,CAAC;IAAE,CAAC,CAAC;EACpF;EAEAA,UAAUA,CAAA,EAAG;IACT,OAAOX,MAAM,CAACY,WAAW,CAAC,IAAI,CAAChB,OAAO,CAAC;EAC3C;EAEA,OAAOc,MAAMA,CAACX,cAAgC,EAAE;IAC5C,OAAO,IAAIJ,eAAe,CAACI,cAAc,CAAC;EAC9C;AACJ;AAACc,OAAA,CAAAlB,eAAA,GAAAA,eAAA","ignoreList":[]}

package/fastify.d.ts

@@ -1,8 +1,10 @@
 /// <reference types="node" />
-import { PluginCollection } from "@webiny/plugins/types";
-import { FastifyServerOptions as ServerOptions } from "fastify";
+import type { PluginCollection } from "@webiny/plugins/types";
+import { PluginsContainer } from "@webiny/plugins/types";
+import type { FastifyInstance, FastifyServerOptions as ServerOptions } from "fastify";
 export interface CreateHandlerParams {
-    plugins: PluginCollection;
+    plugins: PluginCollection | PluginsContainer;
     options?: ServerOptions;
+    debug?: boolean;
 }
-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>>;
+export declare const createHandler: (params: CreateHandlerParams) => FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault> & PromiseLike<FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>>;

package/fastify.js

@@ -1,77 +1,47 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createHandler = void 0;
-
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-
+var _types = require("@webiny/plugins/types");
 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 _middleware = require("./middleware");
-
+var _compress = _interopRequireDefault(require("@fastify/compress"));
 var _api = require("@webiny/api");
-
 var _BeforeHandlerPlugin = require("./plugins/BeforeHandlerPlugin");
-
 var _HandlerResultPlugin = require("./plugins/HandlerResultPlugin");
-
 var _HandlerErrorPlugin = require("./plugins/HandlerErrorPlugin");
-
-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 (0, _objectSpread2.default)((0, _objectSpread2.default)({}, DEFAULT_HEADERS), {}, {
-      "Access-Control-Allow-Methods": "*"
-    });
-  }
-
-  return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, DEFAULT_HEADERS), {}, {
-    "Access-Control-Allow-Methods": keys.filter(key => {
-      const type = key;
-
-      if (!routes[type] || Array.isArray(routes[type]) === false) {
-        return false;
-      }
-
-      return routes[type].length > 0;
-    }).sort().join(",")
+var _ModifyFastifyPlugin = require("./plugins/ModifyFastifyPlugin");
+var _HandlerOnRequestPlugin = require("./plugins/HandlerOnRequestPlugin");
+var _ResponseHeaders = require("./ResponseHeaders");
+var _ModifyResponseHeadersPlugin = require("./plugins/ModifyResponseHeadersPlugin");
+var _SetDefaultHeaders = require("./PreHandler/SetDefaultHeaders");
+var _PreHandler = require("./PreHandler/PreHandler");
+var _stringifyError = require("./stringifyError");
+var _ProcessHandlerOnRequestPlugins = require("./PreHandler/ProcessHandlerOnRequestPlugins");
+var _ProcessContextPlugins = require("./PreHandler/ProcessContextPlugins");
+var _IfNotOptionsRequest = require("./PreHandler/IfNotOptionsRequest");
+var _ProcessBeforeHandlerPlugins = require("./PreHandler/ProcessBeforeHandlerPlugins");
+var _IfOptionsRequest = require("./PreHandler/IfOptionsRequest");
+var _SendEarlyOptionsResponse = require("./PreHandler/SendEarlyOptionsResponse");
+var _OnRequestTimeoutPlugin = require("./plugins/OnRequestTimeoutPlugin.js");
+var _OnRequestResponseSendPlugin = require("./plugins/OnRequestResponseSendPlugin.js");
+const modifyResponseHeaders = (app, request, reply) => {
+  const modifyHeaders = app.webiny.plugins.byType(_ModifyResponseHeadersPlugin.ModifyResponseHeadersPlugin.type);
+  const replyHeaders = reply.getHeaders();
+  const headers = _ResponseHeaders.ResponseHeaders.create(replyHeaders);
+  modifyHeaders.forEach(plugin => {
+    plugin.modify(request, headers);
   });
+  reply.headers(headers.getHeaders());
 };
-
-const OPTIONS_HEADERS = {
-  "Access-Control-Max-Age": "86400",
-  "Cache-Control": "public, max-age=86400"
-};
-
 const createHandler = params => {
   const definedRoutes = {
     POST: [],
@@ -89,82 +59,99 @@ const createHandler = params => {
     PROPPATCH: [],
     SEARCH: [],
     TRACE: [],
-    UNLOCK: []
+    UNLOCK: [],
+    REPORT: [],
+    MKCALENDAR: []
   };
-
   const throwOnDefinedRoute = (type, path, options) => {
     if (type === "ALL") {
-      const all = Object.keys(definedRoutes).some(key => {
+      const all = Object.keys(definedRoutes).find(k => {
+        const key = k.toUpperCase();
         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
       });
     } else if (definedRoutes[type].includes(path) === false) {
       return;
-    } else if ((options === null || options === void 0 ? void 0 : options.override) === true) {
+    } else if (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 = (input, path) => {
+    const type = input.toUpperCase();
     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)({
+    bodyLimit: 536870912,
+    // 512MB
+    disableRequestLogging: true,
+    ...(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.
+   * We need to register routes in our system to output headers later on, and disallow route overriding.
    */
-
   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) => {
@@ -200,120 +187,215 @@ 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 || [])],
-
-    /**
-     * Inserted via webpack on build time.
-     */
-    WEBINY_VERSION: process.env.WEBINY_VERSION,
-    server: app,
-    routes
-  });
+  let context;
+  const plugins = new _types.PluginsContainer([
   /**
-   * We are attaching our custom context to webiny variable on the fastify app so it is accessible everywhere
+   * We must have handlerClient by default.
+   * And it must be one of the first context plugins applied.
    */
+  (0, _handlerClient.createHandlerClient)()]);
+  plugins.merge(params.plugins || []);
+  try {
+    context = new _Context.Context({
+      plugins,
+      /**
+       * Inserted via webpack at build time.
+       */
+      WEBINY_VERSION: process.env.WEBINY_VERSION,
+      routes
+    });
+  } catch (ex) {
+    console.error(`Error while constructing the Context.`);
+    console.error((0, _stringifyError.stringifyError)(ex));
+    throw ex;
+  }
 
-  app.decorate("webiny", context);
   /**
-   * We have few types of triggers:
-   *  * Events - EventPlugin
-   *  * Routes - RoutePlugin
-   *
-   * Routes are registered in fastify but events must be handled in package which implements cloud specific methods.
+   * We are attaching our custom context to webiny variable on the fastify app, so it is accessible everywhere.
    */
+  app.decorate("webiny", context);
 
-  const routePlugins = app.webiny.plugins.byType(_RoutePlugin.RoutePlugin.type);
   /**
-   * Add routes to the system.
+   * With this we ensure that an undefined request body is not parsed on OPTIONS requests,
+   * in case there's a `content-type` header set for whatever reason.
+   *
+   * @see https://fastify.dev/docs/latest/Reference/ContentTypeParser/#content-type-parser
    */
+  app.addHook("onRequest", async request => {
+    if (request.method === "OPTIONS" && request.body === undefined) {
+      request.headers["content-type"] = undefined;
+    }
+  });
 
-  for (const plugin of routePlugins) {
-    plugin.cb((0, _objectSpread2.default)((0, _objectSpread2.default)({}, app.webiny.routes), {}, {
-      context: app.webiny
-    }));
-  }
   /**
-   * 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.
+   * At this point, request body is properly parsed, and we can execute Webiny business logic.
+   * - set default headers
+   * - process `HandlerOnRequestPlugin`
+   * - if OPTIONS request, exit early
+   * - process `ContextPlugin`
+   * - process `BeforeHandlerPlugin`
    */
-
-
-  app.addHook("onRequest", async (request, reply) => {
-    const defaultHeaders = getDefaultHeaders(definedRoutes);
-    reply.headers(defaultHeaders);
-
-    if (request.method !== "OPTIONS") {
-      return;
+  app.addHook("preHandler", async (request, reply) => {
+    app.webiny.request = request;
+    app.webiny.reply = reply;
+    /**
+     * Default code to 200 - so we do not need to set it again.
+     * Usually we set errors manually when we use reply.send.
+     */
+    reply.code(200);
+    const handlerOnRequestPlugins = app.webiny.plugins.byType(_HandlerOnRequestPlugin.HandlerOnRequestPlugin.type);
+    const contextPlugins = app.webiny.plugins.byType(_api.ContextPlugin.type);
+    const beforeHandlerPlugins = app.webiny.plugins.byType(_BeforeHandlerPlugin.BeforeHandlerPlugin.type);
+    const modifyHeadersPlugins = app.webiny.plugins.byType(_ModifyResponseHeadersPlugin.ModifyResponseHeadersPlugin.type);
+    const preHandler = new _PreHandler.PreHandler([new _SetDefaultHeaders.SetDefaultHeaders(definedRoutes), new _ProcessHandlerOnRequestPlugins.ProcessHandlerOnRequestPlugins(handlerOnRequestPlugins), new _IfNotOptionsRequest.IfNotOptionsRequest([new _ProcessContextPlugins.ProcessContextPlugins(app.webiny, contextPlugins), new _ProcessBeforeHandlerPlugins.ProcessBeforeHandlerPlugins(app.webiny, beforeHandlerPlugins)]), new _IfOptionsRequest.IfOptionsRequest([new _SendEarlyOptionsResponse.SendEarlyOptionsResponse(modifyHeadersPlugins)])]);
+    await preHandler.execute(request, reply, app.webiny);
+  });
+  app.addHook("preSerialization", async (_, __, payload) => {
+    const plugins = app.webiny.plugins.byType(_HandlerResultPlugin.HandlerResultPlugin.type);
+    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((0, _stringifyError.stringifyError)(ex));
+      throw ex;
     }
-
-    const raw = reply.code(204).hijack().raw;
-    const headers = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, defaultHeaders), OPTIONS_HEADERS);
-
-    for (const key in headers) {
-      raw.setHeader(key, headers[key]);
+    return payload;
+  });
+  app.setErrorHandler(async (error, _, reply) => {
+    /**
+     * IMPORTANT! Do not send anything if reply was already sent.
+     */
+    if (reply.sent) {
+      console.warn("Reply already sent, cannot send the result (handler:setErrorHandler).");
+      return reply;
     }
-
-    raw.end("");
+    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("preParsing", async request => {
-    app.webiny.request = request;
-    const plugins = app.webiny.plugins.byType(_api.ContextPlugin.type);
-
-    for (const plugin of plugins) {
-      await plugin.apply(app.webiny);
+  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.error("Logging error in @webiny/handler");
+    try {
+      console.error((0, _stringifyError.stringifyError)(error));
+    } catch (ex) {
+      console.warn("Could not stringify error:");
+      console.log(error);
+      console.error("Stringify error:", ex);
+    }
+    /**
+     * IMPORTANT! Do not send anything if reply was already sent.
+     */
+    if (!reply.sent) {
+      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
+      }));
+    } else {
+      console.warn("Reply already sent, cannot send the result (handler:addHook:onError).");
     }
+    const handler = (0, _utils.middleware)(plugins.map(pl => {
+      return (context, error, next) => {
+        return pl.handle(context, error, next);
+      };
+    }));
+    await handler(app.webiny, error);
+    return reply;
   });
+
   /**
-   *
+   * Apply response headers modifier plugins.
    */
-
-  app.addHook("preHandler", async () => {
-    const plugins = app.webiny.plugins.byType(_BeforeHandlerPlugin.BeforeHandlerPlugin.type);
-
+  app.addHook("onSend", async (request, reply, input) => {
+    modifyResponseHeaders(app, request, reply);
+    const plugins = app.webiny.plugins.byType(_OnRequestResponseSendPlugin.OnRequestResponseSendPlugin.type);
+    let payload = input;
     for (const plugin of plugins) {
-      await plugin.apply(app.webiny);
+      payload = await plugin.exec(request, reply, payload);
     }
+    return payload;
   });
+
   /**
-   *
+   * We need to output the benchmark results at the end of the request in both response and timeout cases
    */
-
-  const preSerialization = async (_, __, payload) => {
-    const plugins = app.webiny.plugins.byType(_HandlerResultPlugin.HandlerResultPlugin.type);
-
+  app.addHook("onResponse", async () => {
+    await context.benchmark.output();
+  });
+  app.addHook("onTimeout", async (request, reply) => {
+    const plugins = app.webiny.plugins.byType(_OnRequestTimeoutPlugin.OnRequestTimeoutPlugin.type);
     for (const plugin of plugins) {
-      await plugin.handle(app.webiny, payload);
+      await plugin.exec(request, reply);
     }
+    await context.benchmark.output();
+  });
 
-    return payload;
-  };
+  /**
+   * 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((0, _stringifyError.stringifyError)(ex));
+    throw ex;
+  }
 
-  app.addHook("preSerialization", preSerialization);
-  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!
+  /**
+   * We have few types of triggers:
+   *  * Events - EventPlugin
+   *  * Routes - RoutePlugin
+   *
+   * 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);
 
-    console.log("@webiny/handler");
-    console.log(JSON.stringify((0, _objectSpread2.default)((0, _objectSpread2.default)({}, error || {}), {}, {
-      message: error === null || error === void 0 ? void 0 : error.message,
-      code: error === null || error === void 0 ? void 0 : error.code
-    })));
-    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);
-  });
+  /**
+   * Add routes to the system.
+   */
+  let routePluginName;
+  try {
+    for (const plugin of routePlugins) {
+      routePluginName = plugin.name;
+      plugin.cb({
+        ...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((0, _stringifyError.stringifyError)(ex));
+    throw ex;
+  }
   return app;
 };
+exports.createHandler = createHandler;
 
-exports.createHandler = createHandler;
+//# sourceMappingURL=fastify.js.map