@webiny/handler 0.0.0-unstable.b14eaecf38 → 0.0.0-unstable.b6d7105cee

package/fastify.js

@@ -1,427 +1,321 @@
-"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": "*"
+import { PluginsContainer } from "@webiny/plugins/types.js";
+import fastify, { LogController } from "fastify";
+import { middleware } from "@webiny/utils";
+import { Context } from "./Context.js";
+import _webiny_error from "@webiny/error";
+import { RoutePlugin } from "./plugins/RoutePlugin.js";
+import cookie from "@fastify/cookie";
+import compress 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";
+import { RegisterExtensionPlugin } from "./plugins/RegisterExtensionPlugin.js";
+import { RegisterExtensions } from "./PreHandler/RegisterExtensions.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);
     });
-  }
-  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 headersToSet = headers.getHeaders();
+    delete headersToSet["set-cookie"];
+    reply.headers(headersToSet);
 };
-const createHandler = params => {
-  const definedRoutes = {
-    POST: [],
-    GET: [],
-    OPTIONS: [],
-    DELETE: [],
-    PATCH: [],
-    PUT: [],
-    HEAD: [],
-    COPY: [],
-    LOCK: [],
-    MKCOL: [],
-    MOVE: [],
-    PROPFIND: [],
-    PROPPATCH: [],
-    SEARCH: [],
-    TRACE: [],
-    UNLOCK: []
-  };
-  const throwOnDefinedRoute = (type, path, options) => {
-    if (type === "ALL") {
-      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
-      });
-    } else if (definedRoutes[type].includes(path) === false) {
-      return;
-    } 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 createHandler = (params)=>{
+    const definedRoutes = {
+        POST: [],
+        GET: [],
+        OPTIONS: [],
+        DELETE: [],
+        PATCH: [],
+        PUT: [],
+        HEAD: [],
+        COPY: [],
+        LOCK: [],
+        MKCOL: [],
+        MOVE: [],
+        PROPFIND: [],
+        PROPPATCH: [],
+        SEARCH: [],
+        TRACE: [],
+        UNLOCK: [],
+        REPORT: [],
+        MKCALENDAR: []
+    };
+    const throwOnDefinedRoute = (type, path, options)=>{
+        if ("ALL" === type) {
+            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 _webiny_error("You cannot override a route with onAll() method, please remove unnecessary route from the system.", "OVERRIDE_ROUTE_ERROR", {
+                type,
+                path
+            });
+        }
+        if (false === definedRoutes[type].includes(path)) return;
+        if (options?.override === true) return;
+        console.error(`Error while trying to override route: [${type}] ${path}`);
+        throw new _webiny_error('When you are trying to override existing route, you must send "override" parameter when adding that route.', "OVERRIDE_ROUTE_ERROR", {
+            type,
+            path
+        });
+    };
+    const addDefinedRoute = (input, path)=>{
+        const type = input.toUpperCase();
+        if (!definedRoutes[type]) return;
+        if (definedRoutes[type].includes(path)) return;
+        definedRoutes[type].push(path);
+    };
+    const app = fastify({
+        bodyLimit: 536870912,
+        logController: new LogController({
+            disableRequestLogging: true
+        }),
+        allowErrorHandlerOverride: true,
+        ...params.options || {}
     });
-  };
-  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)((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) => {
-      throwOnDefinedRoute("POST", path, options);
-      app.post(path, handler);
-    },
-    onGet: (path, handler, options) => {
-      throwOnDefinedRoute("GET", path, options);
-      app.get(path, handler);
-    },
-    onOptions: (path, handler, options) => {
-      throwOnDefinedRoute("OPTIONS", path, options);
-      app.options(path, handler);
-    },
-    onDelete: (path, handler, options) => {
-      throwOnDefinedRoute("DELETE", path, options);
-      app.delete(path, handler);
-    },
-    onPatch: (path, handler, options) => {
-      throwOnDefinedRoute("PATCH", path, options);
-      app.patch(path, handler);
-    },
-    onPut: (path, handler, options) => {
-      throwOnDefinedRoute("PUT", path, options);
-      app.put(path, handler);
-    },
-    onAll: (path, handler, options) => {
-      throwOnDefinedRoute("ALL", path, options);
-      app.all(path, handler);
-    },
-    onHead: (path, handler, options) => {
-      throwOnDefinedRoute("HEAD", path, options);
-      app.head(path, handler);
-    }
-  };
-  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
+    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);
     });
-  } catch (ex) {
-    console.error(`Error while constructing the Context.`);
-    console.error(stringifyError(ex));
-    throw ex;
-  }
-
-  /**
-   * 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
-   *  * 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.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;
+    app.register(cookie, {
+        parseOptions: {}
+    });
+    app.register(compress, {
+        global: true,
+        threshold: 1024,
+        onUnsupportedEncoding: (encoding, _, reply)=>{
+            reply.code(406);
+            return `We do not support the ${encoding} encoding.`;
+        },
+        inflateIfDeflated: true
+    });
+    const routes = {
+        defined: definedRoutes,
+        onPost: (path, handler, options)=>{
+            throwOnDefinedRoute("POST", path, options);
+            app.post(path, handler);
+        },
+        onGet: (path, handler, options)=>{
+            throwOnDefinedRoute("GET", path, options);
+            app.get(path, handler);
+        },
+        onOptions: (path, handler, options)=>{
+            throwOnDefinedRoute("OPTIONS", path, options);
+            app.options(path, handler);
+        },
+        onDelete: (path, handler, options)=>{
+            throwOnDefinedRoute("DELETE", path, options);
+            app.delete(path, handler);
+        },
+        onPatch: (path, handler, options)=>{
+            throwOnDefinedRoute("PATCH", path, options);
+            app.patch(path, handler);
+        },
+        onPut: (path, handler, options)=>{
+            throwOnDefinedRoute("PUT", path, options);
+            app.put(path, handler);
+        },
+        onAll: (path, handler, options)=>{
+            throwOnDefinedRoute("ALL", path, options);
+            app.all(path, handler);
+        },
+        onHead: (path, handler, options)=>{
+            throwOnDefinedRoute("HEAD", path, options);
+            app.head(path, handler);
         }
-      }
-    } 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;
-    }
-    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;
-    }
-    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;
+    };
+    let context;
+    const plugins = new PluginsContainer([]);
+    plugins.merge(params.plugins || []);
     try {
-      for (const plugin of plugins) {
-        name = plugin.name;
-        await plugin.apply(app.webiny);
-      }
+        context = new Context({
+            plugins,
+            WEBINY_VERSION: process.env.WEBINY_VERSION,
+            routes
+        });
     } catch (ex) {
-      console.error(`Error while running the "ContextPlugin" ${name ? `(${name})` : ""} plugin in the preParsing hook.`);
-      console.error(stringifyError(ex));
-      throw ex;
+        console.error("Error while constructing the Context.");
+        console.error(stringifyError(ex));
+        throw ex;
     }
-  });
-  /**
-   *
-   */
-  app.addHook("preHandler", async () => {
-    const plugins = app.webiny.plugins.byType(_BeforeHandlerPlugin.BeforeHandlerPlugin.type);
-    let name;
+    app.decorate("webiny", context);
+    app.addContentTypeParser("application/json", {
+        parseAs: "string",
+        bodyLimit: 1048576
+    }, (req, body, done)=>{
+        if ("OPTIONS" === req.method) return void done(null, void 0);
+        try {
+            const json = "string" == typeof body ? body : body.toString("utf8");
+            done(null, JSON.parse(json));
+        } catch (err) {
+            done(err);
+        }
+    });
+    app.addHook("onRequest", async (request)=>{
+        if ("OPTIONS" === request.method && void 0 === request.body) request.headers["content-type"] = void 0;
+    });
+    app.addHook("preHandler", async (request, reply)=>{
+        app.webiny.request = request;
+        app.webiny.reply = reply;
+        if (app.webiny.container) {
+            app.webiny.container.registerInstance(Request, request);
+            app.webiny.container.registerInstance(Reply, reply);
+        }
+        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 registerExtensionPlugins = app.webiny.plugins.byType(RegisterExtensionPlugin.type);
+        const preHandler = new PreHandler([
+            new RegisterExtensions(registerExtensionPlugins),
+            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){
+                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.setErrorHandler(async (error, _, reply)=>{
+        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 ("Tenancy/TenantDisabled" === error.code) 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(JSON.stringify({
+            message: error.message,
+            code: error.code,
+            data: error.data
+        }));
+    });
+    app.addHook("onError", async (_, reply, error)=>{
+        const plugins = app.webiny.plugins.byType(HandlerErrorPlugin.type);
+        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);
+        }
+        if (reply.sent) console.warn("Reply already sent, cannot send the result (handler:addHook:onError).");
+        else reply.status(500).headers({
+            "Cache-Control": "no-store"
+        }).send(JSON.stringify({
+            message: error.message,
+            code: error.code,
+            data: error.data
+        }));
+        const handler = middleware(plugins.map((pl)=>(context, error, next)=>pl.handle(context, error, next)));
+        await handler(app.webiny, error);
+        return reply;
+    });
+    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;
+    });
+    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();
+    });
+    const modifyPlugins = app.webiny.plugins.byType(ModifyFastifyPlugin.type);
+    let modifyFastifyPluginName;
     try {
-      for (const plugin of plugins) {
-        name = plugin.name;
-        await plugin.apply(app.webiny);
-      }
+        for (const plugin of modifyPlugins){
+            modifyFastifyPluginName = plugin.name;
+            plugin.modify(app);
+        }
     } catch (ex) {
-      console.error(`Error while running the "BeforeHandlerPlugin" ${name ? `(${name})` : ""} plugin in the preHandler hook.`);
-      console.error(stringifyError(ex));
-      throw ex;
+        console.error(`Error while running the "ModifyFastifyPlugin" ${modifyFastifyPluginName ? `(${modifyFastifyPluginName})` : ""} plugin in the end of the "createHandler" callable.`);
+        console.error(stringifyError(ex));
+        throw ex;
     }
-  });
-
-  /**
-   *
-   */
-  const preSerialization = async (_, __, payload) => {
-    const plugins = app.webiny.plugins.byType(_HandlerResultPlugin.HandlerResultPlugin.type);
-    let name;
+    const routePlugins = app.webiny.plugins.byType(RoutePlugin.type);
+    let routePluginName;
     try {
-      for (const plugin of plugins) {
-        name = plugin.name;
-        await plugin.handle(app.webiny, payload);
-      }
+        for (const plugin of routePlugins){
+            routePluginName = plugin.name;
+            plugin.cb({
+                ...app.webiny.routes,
+                context: app.webiny
+            });
+        }
     } catch (ex) {
-      console.error(`Error while running the "HandlerResultPlugin" ${name ? `(${name})` : ""} plugin in the preSerialization hook.`);
-      console.error(stringifyError(ex));
-      throw 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 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.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;
-  });
-  /**
-   * 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;
+    return app;
 };
-exports.createHandler = createHandler;
+export { createHandler };
+
+//# sourceMappingURL=fastify.js.map