@webiny/handler 0.0.0-unstable.7f63ea0744 → 0.0.0-unstable.81ae05e56b

package/abstractions/Request.d.ts

@@ -0,0 +1,5 @@
+import type { Request as IRequest } from "../types.js";
+export declare const Request: import("@webiny/di").Abstraction<IRequest>;
+export declare namespace Request {
+    type Interface = IRequest;
+}

package/abstractions/Request.js

@@ -0,0 +1,4 @@
+import { createAbstraction } from "@webiny/feature/api";
+export const Request = createAbstraction("Request");
+
+//# sourceMappingURL=Request.js.map

package/abstractions/Request.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","Request"],"sources":["Request.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Request as IRequest } from \"~/types.js\";\n\nexport const Request = createAbstraction<IRequest>(\"Request\");\n\nexport namespace Request {\n    export type Interface = IRequest;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAGvD,OAAO,MAAMC,OAAO,GAAGD,iBAAiB,CAAW,SAAS,CAAC","ignoreList":[]}

package/fastify.d.ts

@@ -1,8 +1,11 @@
-/// <reference types="node" />
-import { PluginCollection } from "@webiny/plugins/types";
-import { FastifyServerOptions as ServerOptions } from "fastify";
+import type { PluginCollection } from "@webiny/plugins/types.js";
+import { PluginsContainer } from "@webiny/plugins/types.js";
+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>> & {
+    __linterBrands: "SafePromiseLike";
+};

package/fastify.js

@@ -1,76 +1,48 @@
-"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 _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");
-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 (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(type => {
-      if (!routes[type] || Array.isArray(routes[type]) === false) {
-        return false;
-      }
-      return routes[type].length > 0;
-    }).sort().join(",")
+import { PluginsContainer } from "@webiny/plugins/types.js";
+import fastify from "fastify";
+import { middleware } from "@webiny/utils";
+import { Context } from "./Context.js";
+import WebinyError from "@webiny/error";
+import { RoutePlugin } from "./plugins/RoutePlugin.js";
+import { createHandlerClient } from "@webiny/handler-client";
+import fastifyCookie from "@fastify/cookie";
+import fastifyCompress from "@fastify/compress";
+import { ContextPlugin } from "@webiny/api";
+import { BeforeHandlerPlugin } from "./plugins/BeforeHandlerPlugin.js";
+import { HandlerResultPlugin } from "./plugins/HandlerResultPlugin.js";
+import { HandlerErrorPlugin } from "./plugins/HandlerErrorPlugin.js";
+import { ModifyFastifyPlugin } from "./plugins/ModifyFastifyPlugin.js";
+import { HandlerOnRequestPlugin } from "./plugins/HandlerOnRequestPlugin.js";
+import { ResponseHeaders } from "./ResponseHeaders.js";
+import { ModifyResponseHeadersPlugin } from "./plugins/ModifyResponseHeadersPlugin.js";
+import { SetDefaultHeaders } from "./PreHandler/SetDefaultHeaders.js";
+import { PreHandler } from "./PreHandler/PreHandler.js";
+import { stringifyError } from "./stringifyError.js";
+import { ProcessHandlerOnRequestPlugins } from "./PreHandler/ProcessHandlerOnRequestPlugins.js";
+import { ProcessContextPlugins } from "./PreHandler/ProcessContextPlugins.js";
+import { IfNotOptionsRequest } from "./PreHandler/IfNotOptionsRequest.js";
+import { ProcessBeforeHandlerPlugins } from "./PreHandler/ProcessBeforeHandlerPlugins.js";
+import { IfOptionsRequest } from "./PreHandler/IfOptionsRequest.js";
+import { SendEarlyOptionsResponse } from "./PreHandler/SendEarlyOptionsResponse.js";
+import { OnRequestTimeoutPlugin } from "./plugins/OnRequestTimeoutPlugin.js";
+import { OnRequestResponseSendPlugin } from "./plugins/OnRequestResponseSendPlugin.js";
+import { Request } from "./abstractions/Request.js";
+import { Reply } from "./abstractions/Reply.js";
+const modifyResponseHeaders = (app, request, reply) => {
+  const modifyHeaders = app.webiny.plugins.byType(ModifyResponseHeadersPlugin.type);
+  const replyHeaders = reply.getHeaders();
+  const headers = ResponseHeaders.create(replyHeaders);
+  modifyHeaders.forEach(plugin => {
+    plugin.modify(request, headers);
   });
+
+  // Exclude 'set-cookie' header to avoid duplication.
+  // Cookies are managed by @fastify/cookie and calling reply.headers() with 'set-cookie' duplicates them.
+  const headersToSet = headers.getHeaders();
+  delete headersToSet["set-cookie"];
+  reply.headers(headersToSet);
 };
-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 => {
+export const createHandler = params => {
   const definedRoutes = {
     POST: [],
     GET: [],
@@ -87,35 +59,39 @@ const createHandler = params => {
     PROPPATCH: [],
     SEARCH: [],
     TRACE: [],
-    UNLOCK: []
+    UNLOCK: [],
+    REPORT: [],
+    MKCALENDAR: []
   };
   const throwOnDefinedRoute = (type, path, options) => {
     if (type === "ALL") {
-      const all = Object.keys(definedRoutes).find(key => {
+      const all = Object.keys(definedRoutes).find(k => {
+        const key = k.toUpperCase();
         const routes = definedRoutes[key];
         return routes.includes(path);
       });
       if (!all) {
         return;
       }
-      console.log(`Error while registering onAll route. One of the routes is already defined.`);
-      console.log(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", {
+      console.error(`Error while registering onAll route. One of the routes is already defined.`);
+      console.error(JSON.stringify(all));
+      throw new WebinyError(`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.log(`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", {
+    console.error(`Error while trying to override route: [${type}] ${path}`);
+    throw new WebinyError(`When you are trying to override existing route, you must send "override" parameter when adding that route.`, "OVERRIDE_ROUTE_ERROR", {
       type,
       path
     });
   };
-  const addDefinedRoute = (type, path) => {
+  const addDefinedRoute = (input, path) => {
+    const type = input.toUpperCase();
     if (!definedRoutes[type]) {
       return;
     } else if (definedRoutes[type].includes(path)) {
@@ -123,12 +99,20 @@ const createHandler = params => {
     }
     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)((0, _objectSpread2.default)({}, params.options || {}));
+  const app = fastify({
+    bodyLimit: 536870912,
+    // 512MB
+    disableRequestLogging: true,
+    allowErrorHandlerOverride: true,
+    ...(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;
@@ -149,7 +133,7 @@ const createHandler = params => {
    *
    * https://github.com/fastify/fastify-cookie
    */
-  app.register(_cookie.default, {
+  app.register(fastifyCookie, {
     parseOptions: {} // options for parsing cookies
   });
   /**
@@ -157,7 +141,7 @@ const createHandler = params => {
    *
    * https://github.com/fastify/fastify-compress
    */
-  app.register(_compress.default, {
+  app.register(fastifyCompress, {
     global: true,
     threshold: 1024,
     onUnsupportedEncoding: (encoding, _, reply) => {
@@ -205,24 +189,25 @@ const createHandler = params => {
     }
   };
   let context;
+  const plugins = new PluginsContainer([
+  /**
+   * We must have handlerClient by default.
+   * And it must be one of the first context plugins applied.
+   */
+  createHandlerClient()]);
+  plugins.merge(params.plugins || []);
   try {
-    context = new _Context.Context({
-      plugins: [
+    context = new 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.
+       * Inserted via webpack at build time.
        */
       WEBINY_VERSION: process.env.WEBINY_VERSION,
-      server: app,
       routes
     });
   } catch (ex) {
-    console.log(`Error while constructing the Context.`);
-    console.log(stringifyError(ex));
+    console.error(`Error while constructing the Context.`);
+    console.error(stringifyError(ex));
     throw ex;
   }
 
@@ -232,118 +217,68 @@ const createHandler = params => {
   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.
-   */
-  const routePlugins = app.webiny.plugins.byType(_RoutePlugin.RoutePlugin.type);
-
-  /**
-   * Add routes to the system.
-   */
-  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.log(`Error while running the "RoutePlugin" ${routePluginName ? `(${routePluginName})` : ""} plugin in the beginning of the "createHandler" callable.`);
-    console.log(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.
+   * To prevent Unsupported Media Type errors on OPTIONS requests with a body,
+   * we need to have a custom parser
    */
-  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.log(`Error while running the "HandlerOnRequestPlugin" ${name ? `(${name})` : ""} plugin in the onRequest hook.`);
-      console.log(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;
-    }
-    if (reply.sent) {
-      /**
-       * At this point throwing an exception will not do anything with the response. So just log it.
-       */
-      console.log(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."
-      }));
+  app.addContentTypeParser("application/json", {
+    parseAs: "string",
+    bodyLimit: 1024 * 1024
+  }, (req, body, done) => {
+    if (req.method === "OPTIONS") {
+      done(null, undefined);
       return;
     }
-    reply.headers((0, _objectSpread2.default)((0, _objectSpread2.default)({}, defaultHeaders), OPTIONS_HEADERS)).code(204).send("").hijack();
-  });
-  app.addHook("preParsing", async (request, reply) => {
-    app.webiny.request = request;
-    app.webiny.reply = reply;
-    const plugins = app.webiny.plugins.byType(_api.ContextPlugin.type);
-    let name;
     try {
-      for (const plugin of plugins) {
-        name = plugin.name;
-        await plugin.apply(app.webiny);
-      }
-    } catch (ex) {
-      console.log(`Error while running the "ContextPlugin" ${name ? `(${name})` : ""} plugin in the preParsing hook.`);
-      console.log(stringifyError(ex));
-      throw ex;
+      const json = typeof body === "string" ? body : body.toString("utf8");
+      done(null, JSON.parse(json));
+    } catch (err) {
+      done(err);
     }
   });
+
   /**
+   * 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("preHandler", async () => {
-    const plugins = app.webiny.plugins.byType(_BeforeHandlerPlugin.BeforeHandlerPlugin.type);
-    let name;
-    try {
-      for (const plugin of plugins) {
-        name = plugin.name;
-        await plugin.apply(app.webiny);
-      }
-    } catch (ex) {
-      console.log(`Error while running the "BeforeHandlerPlugin" ${name ? `(${name})` : ""} plugin in the preHandler hook.`);
-      console.log(stringifyError(ex));
-      throw ex;
+  app.addHook("onRequest", async request => {
+    if (request.method === "OPTIONS" && request.body === undefined) {
+      request.headers["content-type"] = undefined;
     }
   });
 
   /**
-   *
+   * 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`
    */
-  const preSerialization = async (_, __, payload) => {
-    const plugins = app.webiny.plugins.byType(_HandlerResultPlugin.HandlerResultPlugin.type);
+  app.addHook("preHandler", async (request, reply) => {
+    app.webiny.request = request;
+    app.webiny.reply = reply;
+
+    // Bind request and reply to DI container for runtime access
+    if (app.webiny.container) {
+      app.webiny.container.registerInstance(Request, request);
+      app.webiny.container.registerInstance(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.type);
+    const contextPlugins = app.webiny.plugins.byType(ContextPlugin.type);
+    const beforeHandlerPlugins = app.webiny.plugins.byType(BeforeHandlerPlugin.type);
+    const modifyHeadersPlugins = app.webiny.plugins.byType(ModifyResponseHeadersPlugin.type);
+    const preHandler = new PreHandler([new SetDefaultHeaders(definedRoutes), new ProcessHandlerOnRequestPlugins(handlerOnRequestPlugins), new IfNotOptionsRequest([new ProcessContextPlugins(app.webiny, contextPlugins), new ProcessBeforeHandlerPlugins(app.webiny, beforeHandlerPlugins)]), new IfOptionsRequest([new SendEarlyOptionsResponse(modifyHeadersPlugins)])]);
+    await preHandler.execute(request, reply, app.webiny);
+  });
+  app.addHook("preSerialization", async (_, __, payload) => {
+    const plugins = app.webiny.plugins.byType(HandlerResultPlugin.type);
     let name;
     try {
       for (const plugin of plugins) {
@@ -351,14 +286,36 @@ const createHandler = params => {
         await plugin.handle(app.webiny, payload);
       }
     } catch (ex) {
-      console.log(`Error while running the "HandlerResultPlugin" ${name ? `(${name})` : ""} plugin in the preSerialization hook.`);
-      console.log(stringifyError(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) => {
+  });
+  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;
+    }
+    if (error.code?.startsWith("Authentication/")) {
+      return reply.status(401).headers({
+        "Cache-Control": "no-store"
+      }).send(JSON.stringify({
+        message: error.message,
+        code: error.code
+      }));
+    }
+    if (error.code === "Tenancy/TenantDisabled") {
+      return reply.status(503).headers({
+        "Cache-Control": "no-store"
+      }).send(JSON.stringify({
+        message: error.message,
+        code: error.code
+      }));
+    }
     return reply.status(500).headers({
       "Cache-Control": "no-store"
     }).send(
@@ -372,24 +329,37 @@ const createHandler = params => {
     }));
   });
   app.addHook("onError", async (_, reply, error) => {
-    const plugins = app.webiny.plugins.byType(_HandlerErrorPlugin.HandlerErrorPlugin.type);
+    const plugins = app.webiny.plugins.byType(HandlerErrorPlugin.type);
     /**
      * Log error to cloud, as these can be extremely annoying to debug!
      */
-    console.log("@webiny/handler");
-    console.log(stringifyError(error));
-    reply.status(500).headers({
-      "Cache-Control": "no-store"
-    }).send(
+    console.error("Logging error in @webiny/handler");
+    try {
+      console.error(stringifyError(error));
+    } catch (ex) {
+      console.warn("Could not stringify error:");
+      console.log(error);
+      console.error("Stringify error:", ex);
+    }
     /**
-     * When we are sending the error in the response, we cannot send the whole error object, as it might contain some sensitive data.
+     * IMPORTANT! Do not send anything if reply was already sent.
      */
-    JSON.stringify({
-      message: error.message,
-      code: error.code,
-      data: error.data
-    }));
-    const handler = (0, _middleware.middleware)(plugins.map(pl => {
+    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 = middleware(plugins.map(pl => {
       return (context, error, next) => {
         return pl.handle(context, error, next);
       };
@@ -398,10 +368,37 @@ const createHandler = params => {
     return reply;
   });
 
+  /**
+   * Apply response headers modifier plugins.
+   */
+  app.addHook("onSend", async (request, reply, input) => {
+    modifyResponseHeaders(app, request, reply);
+    const plugins = app.webiny.plugins.byType(OnRequestResponseSendPlugin.type);
+    let payload = input;
+    for (const plugin of plugins) {
+      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
+   */
+  app.addHook("onResponse", async () => {
+    await context.benchmark.output();
+  });
+  app.addHook("onTimeout", async (request, reply) => {
+    const plugins = app.webiny.plugins.byType(OnRequestTimeoutPlugin.type);
+    for (const plugin of plugins) {
+      await plugin.exec(request, reply);
+    }
+    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);
+  const modifyPlugins = app.webiny.plugins.byType(ModifyFastifyPlugin.type);
   let modifyFastifyPluginName;
   try {
     for (const plugin of modifyPlugins) {
@@ -409,10 +406,38 @@ const createHandler = params => {
       plugin.modify(app);
     }
   } catch (ex) {
-    console.log(`Error while running the "ModifyFastifyPlugin" ${modifyFastifyPluginName ? `(${modifyFastifyPluginName})` : ""} plugin in the end of the "createHandler" callable.`);
-    console.log(stringifyError(ex));
+    console.error(`Error while running the "ModifyFastifyPlugin" ${modifyFastifyPluginName ? `(${modifyFastifyPluginName})` : ""} plugin in the end of the "createHandler" callable.`);
+    console.error(stringifyError(ex));
+    throw ex;
+  }
+
+  /**
+   * 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.type);
+
+  /**
+   * 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(stringifyError(ex));
     throw ex;
   }
   return app;
 };
-exports.createHandler = createHandler;
+
+//# sourceMappingURL=fastify.js.map