@flink-app/flink 0.3.8 → 0.3.12

package/dist/src/FlinkApp.d.ts

@@ -1,3 +1,4 @@
+import { OptionsJson } from "body-parser";
 import { Express } from "express";
 import { JSONSchema7 } from "json-schema";
 import { Db } from "mongodb";
@@ -88,6 +89,10 @@ export interface FlinkOptions {
      * Optional root folder of app. Defaults to `./`
      */
     appRoot?: string;
+    /**
+     * Options for json body parser
+     */
+    jsonOptions?: OptionsJson;
 }
 export interface HandlerConfig {
     schema?: {
@@ -124,6 +129,7 @@ export declare class FlinkApp<C extends FlinkContext> {
     private auth?;
     private corsOpts;
     private routingConfigured;
+    private jsonOptions?;
     private repos;
     /**
      * Internal cache used to track registered handlers and potentially any overlapping routes

package/dist/src/FlinkApp.js

@@ -99,6 +99,7 @@ var FlinkApp = /** @class */ (function () {
         this.plugins = opts.plugins || [];
         this.corsOpts = __assign(__assign({}, defaultCorsOptions), opts.cors);
         this.auth = opts.auth;
+        this.jsonOptions = opts.jsonOptions || { limit: "1mb" };
     }
     Object.defineProperty(FlinkApp.prototype, "ctx", {
         get: function () {
@@ -140,7 +141,7 @@ var FlinkApp = /** @class */ (function () {
                         }
                         this.expressApp = express_1.default();
                         this.expressApp.use(cors_1.default(this.corsOpts));
-                        this.expressApp.use(body_parser_1.default.json());
+                        this.expressApp.use(body_parser_1.default.json(this.jsonOptions));
                         this.expressApp.use(function (req, res, next) {
                             req.reqId = uuid_1.v4();
                             next();
@@ -212,10 +213,7 @@ var FlinkApp = /** @class */ (function () {
             node_color_log_1.default.error("Failed to register handler '" + handler.__file + "': Missing 'path' in route props");
             return;
         }
-        var dup = this.handlers.find(function (h) {
-            return h.routeProps.path === routeProps.path &&
-                h.routeProps.method === routeProps.method;
-        });
+        var dup = this.handlers.find(function (h) { return h.routeProps.path === routeProps.path && h.routeProps.method === routeProps.method; });
         var methodAndPath = routeProps.method.toUpperCase() + " " + routeProps.path;
         if (dup) {
             // TODO: Not sure if there is a case where you'd want to overwrite a route?
@@ -302,6 +300,7 @@ var FlinkApp = /** @class */ (function () {
                         case 5:
                             err_1 = _a.sent();
                             node_color_log_1.default.warn("Handler '" + methodAndRoute_1 + "' threw unhandled exception " + err_1);
+                            console.error(err_1);
                             return [2 /*return*/, res.status(500).json(FlinkErrors_1.internalServerError(err_1))];
                         case 6:
                             if (schema.resSchema && !utils_1.isError(handlerRes)) {
@@ -374,6 +373,8 @@ var FlinkApp = /** @class */ (function () {
     };
     FlinkApp.prototype.addRepo = function (instanceName, repoInstance) {
         this.repos[instanceName] = repoInstance;
+        // TODO: Find out if we need to set ctx here or wanted not to if plugin has its own context
+        // repoInstance.ctx = this.ctx;
     };
     /**
      * Constructs the app context. Will inject context in all components
@@ -381,8 +382,8 @@ var FlinkApp = /** @class */ (function () {
      */
     FlinkApp.prototype.buildContext = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, autoRegisteredRepos_1, _a, collectionName, repoInstanceName, Repo, repoInstance, pluginCtx;
-            return __generator(this, function (_b) {
+            var _i, autoRegisteredRepos_1, _a, collectionName, repoInstanceName, Repo, repoInstance, pluginCtx, _b, _c, repo;
+            return __generator(this, function (_d) {
                 if (this.dbOpts) {
                     for (_i = 0, autoRegisteredRepos_1 = exports.autoRegisteredRepos; _i < autoRegisteredRepos_1.length; _i++) {
                         _a = autoRegisteredRepos_1[_i], collectionName = _a.collectionName, repoInstanceName = _a.repoInstanceName, Repo = _a.Repo;
@@ -406,6 +407,10 @@ var FlinkApp = /** @class */ (function () {
                     plugins: pluginCtx,
                     auth: this.auth,
                 };
+                for (_b = 0, _c = Object.values(this.repos); _b < _c.length; _b++) {
+                    repo = _c[_b];
+                    repo.ctx = this.ctx;
+                }
                 return [2 /*return*/];
             });
         });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@flink-app/flink",
-    "version": "0.3.8",
+    "version": "0.3.12",
     "description": "Typescript only framework for creating REST-like APIs on top of Express and mongodb",
     "types": "dist/src/index.d.ts",
     "main": "dist/src/index.js",
@@ -62,5 +62,5 @@
         "rimraf": "^3.0.2",
         "ts-node": "^9.1.1"
     },
-    "gitHead": "9c45e69ffff300482f9945074c5ecc3e1d661467"
+    "gitHead": "14e613ca807ffc6f2eac3bdd0e30aebee2778932"
 }

package/readme.md

@@ -107,12 +107,12 @@ export default () => {};
 
 The following building blocks exists in Flink:
 
-- Handler - a handler is responsible for handling API requests and return a response. Normally a handler has some type of logic and invokes a _repo_ to CRUD data from database.
-- Repo - a repository is used to abstract data access to database. A repo is used to access a mongo db and a repo is used per collection.
-- App Context - the app context is the glue that ties parts of the app together. By defining and creating an app context you make sure that i.e. handlers can get access to repositories.
-- Schemas - models that defines API requests and responses. These are typescript interfaces which will during compile time be converted into JSON schemas used to validate requests and responses and also used to generate API documentation.
-- Flink app - is the entry
-- Plugins - plugability is built into core of Flink. These can be external npm modules, or plugins inside your project. Plugins can for example extend the `request` object and add additional information such as auth user which can be used in handlers. Similar to how middleware works in express although a bit more constrained.
+-   Handler - a handler is responsible for handling API requests and return a response. Normally a handler has some type of logic and invokes a _repo_ to CRUD data from database.
+-   Repo - a repository is used to abstract data access to database. A repo is used to access a mongo db and a repo is used per collection.
+-   App Context - the app context is the glue that ties parts of the app together. By defining and creating an app context you make sure that i.e. handlers can get access to repositories.
+-   Schemas - models that defines API requests and responses. These are typescript interfaces which will during compile time be converted into JSON schemas used to validate requests and responses and also used to generate API documentation.
+-   Flink app - is the entry
+-   Plugins - plugability is built into core of Flink. These can be external npm modules, or plugins inside your project. Plugins can for example extend the `request` object and add additional information such as auth user which can be used in handlers. Similar to how middleware works in express although a bit more constrained.
 
 ### Handlers
 
@@ -164,10 +164,10 @@ Then handler method must be of type `Handler` or `GetHandler`.
 
 The handler function has generic type arguments which defines:
 
-- Application context
-- Request schema (optional)
-- Response schema (optional)
-- Params (optional)
+-   Application context
+-   Request schema (optional)
+-   Response schema (optional)
+-   Params (optional)
 
 > Note: `GetHandler<Ctx, ResSchema>` is just syntactic sugar since get handlers does not have request schemas so that type argument does not exist. Otherwise it is the same as `Handler<Ctx, ReqSchema, ResSchema>`
 
@@ -217,3 +217,7 @@ export const Props: RouteProps {
     method: HttpMethod.get
 }
 ```
+
+## 🤕 Known issues
+
+-   Current TypeScript compiler is slow when project gets larger

package/src/FlinkApp.ts

@@ -1,6 +1,6 @@
 import Ajv from "ajv";
 import addFormats from "ajv-formats";
-import bodyParser from "body-parser";
+import bodyParser, { OptionsJson } from "body-parser";
 import cors from "cors";
 import express, { Express, Request } from "express";
 import { JSONSchema7 } from "json-schema";
@@ -10,13 +10,7 @@ import { v4 } from "uuid";
 import { FlinkAuthPlugin } from "./auth/FlinkAuthPlugin";
 import { FlinkContext } from "./FlinkContext";
 import { internalServerError, notFound, unauthorized } from "./FlinkErrors";
-import {
-  Handler,
-  HandlerFile,
-  HttpMethod,
-  QueryParamMetadata,
-  RouteProps,
-} from "./FlinkHttpHandler";
+import { Handler, HandlerFile, HttpMethod, QueryParamMetadata, RouteProps } from "./FlinkHttpHandler";
 import { FlinkPlugin } from "./FlinkPlugin";
 import { FlinkRepo } from "./FlinkRepo";
 import { FlinkResponse } from "./FlinkResponse";
@@ -27,9 +21,9 @@ const ajv = new Ajv();
 addFormats(ajv);
 
 const defaultCorsOptions: FlinkOptions["cors"] = {
-  allowedHeaders: "",
-  credentials: true,
-  origin: [/.*/],
+    allowedHeaders: "",
+    credentials: true,
+    origin: [/.*/],
 };
 
 export type JSONSchema = JSONSchema7;
@@ -39,8 +33,8 @@ export type JSONSchema = JSONSchema7;
  * are picked up by typescript compiler
  */
 export const autoRegisteredHandlers: {
-  handler: HandlerFile;
-  assumedHttpMethod: HttpMethod;
+    handler: HandlerFile;
+    assumedHttpMethod: HttpMethod;
 }[] = [];
 
 /**
@@ -48,586 +42,538 @@ export const autoRegisteredHandlers: {
  * are picked up by typescript compiler
  */
 export const autoRegisteredRepos: {
-  collectionName: string;
-  repoInstanceName: string;
-  Repo: any;
+    collectionName: string;
+    repoInstanceName: string;
+    Repo: any;
 }[] = [];
 
 export interface FlinkOptions {
-  /**
-   * Name of application, will only show in logs and in HTTP header.
-   */
-  name: string;
-
-  /**
-   * HTTP port
-   * @default 3333
-   */
-  port?: number;
-
-  /**
-   * Configuration related to database.
-   * Leave empty if no database is needed.
-   */
-  db?: {
     /**
-     * Uri to mongodb including any username and password.
-     * @example mongodb://localhost:27017/my-db
+     * Name of application, will only show in logs and in HTTP header.
      */
-    uri: string;
-  };
-
-  /**
-   * Optional debug options, used to log and debug Flink internals.
-   */
-  debug?: boolean;
-
-  /**
-   * Callback invoked after database was connected
-   * end before application starts.
-   *
-   * A good place to for example ensure database indexes.
-   */
-  onDbConnection?: (db: Db) => Promise<void>;
-
-  /**
-   * Callback invoked so Flink can load files from host project.
-   * @deprecated not needed anymore since new `flink run`
-   */
-  loader?: (file: string) => Promise<any>;
-
-  /**
-   * Optional list of plugins that should be configured and used.
-   */
-  plugins?: FlinkPlugin[];
-
-  /**
-   * Plugin used for authentication.
-   */
-  auth?: FlinkAuthPlugin;
-
-  /**
-   * Optional cors options.
-   */
-  cors?: {
+    name: string;
+
+    /**
+     * HTTP port
+     * @default 3333
+     */
+    port?: number;
+
+    /**
+     * Configuration related to database.
+     * Leave empty if no database is needed.
+     */
+    db?: {
+        /**
+         * Uri to mongodb including any username and password.
+         * @example mongodb://localhost:27017/my-db
+         */
+        uri: string;
+    };
+
+    /**
+     * Optional debug options, used to log and debug Flink internals.
+     */
+    debug?: boolean;
+
     /**
-     * Origin(s) to allow
+     * Callback invoked after database was connected
+     * end before application starts.
+     *
+     * A good place to for example ensure database indexes.
      */
-    origin?: RegExp[];
+    onDbConnection?: (db: Db) => Promise<void>;
 
-    credentials?: boolean;
+    /**
+     * Callback invoked so Flink can load files from host project.
+     * @deprecated not needed anymore since new `flink run`
+     */
+    loader?: (file: string) => Promise<any>;
+
+    /**
+     * Optional list of plugins that should be configured and used.
+     */
+    plugins?: FlinkPlugin[];
+
+    /**
+     * Plugin used for authentication.
+     */
+    auth?: FlinkAuthPlugin;
+
+    /**
+     * Optional cors options.
+     */
+    cors?: {
+        /**
+         * Origin(s) to allow
+         */
+        origin?: RegExp[];
+
+        credentials?: boolean;
+
+        /**
+         * Specify allowed headers for CORS, can be a comma separated string if multiple
+         * Defaults to none.
+         */
+        allowedHeaders?: string;
+    };
 
     /**
-     * Specify allowed headers for CORS, can be a comma separated string if multiple
-     * Defaults to none.
+     * Optional root folder of app. Defaults to `./`
      */
-    allowedHeaders?: string;
-  };
+    appRoot?: string;
 
-  /**
-   * Optional root folder of app. Defaults to `./`
-   */
-  appRoot?: string;
+
+    /**
+     * Options for json body parser
+     */
+    jsonOptions?: OptionsJson;
+    
+    
 }
 
 export interface HandlerConfig {
-  schema?: {
-    reqSchema?: JSONSchema;
-    resSchema?: JSONSchema;
-  };
-  routeProps: RouteProps;
-  queryMetadata: QueryParamMetadata[];
-  paramsMetadata: QueryParamMetadata[];
+    schema?: {
+        reqSchema?: JSONSchema;
+        resSchema?: JSONSchema;
+    };
+    routeProps: RouteProps;
+    queryMetadata: QueryParamMetadata[];
+    paramsMetadata: QueryParamMetadata[];
 }
 
 export interface HandlerConfigWithMethod extends HandlerConfig {
-  routeProps: RouteProps & { method: HttpMethod };
+    routeProps: RouteProps & { method: HttpMethod };
 }
-export interface HandlerConfigWithSchemaRefs
-  extends Omit<HandlerConfig, "schema" | "origin"> {
-  schema?: {
-    reqSchema?: string;
-    resSchema?: string;
-  };
+export interface HandlerConfigWithSchemaRefs extends Omit<HandlerConfig, "schema" | "origin"> {
+    schema?: {
+        reqSchema?: string;
+        resSchema?: string;
+    };
 }
 
 export class FlinkApp<C extends FlinkContext> {
-  public name: string;
-  public expressApp?: Express;
-  public db?: Db;
-  public handlers: HandlerConfig[] = [];
-  public port?: number;
-  public started = false;
-
-  private _ctx?: C;
-  private dbOpts?: FlinkOptions["db"];
-  private debug = false;
-  private onDbConnection?: FlinkOptions["onDbConnection"];
-
-  private plugins: FlinkPlugin[] = [];
-  private auth?: FlinkAuthPlugin;
-  private corsOpts: FlinkOptions["cors"];
-  private routingConfigured = false;
-
-  private repos: { [x: string]: FlinkRepo<C> } = {};
-
-  /**
-   * Internal cache used to track registered handlers and potentially any overlapping routes
-   */
-  private handlerRouteCache = new Map<string, string>();
-
-  constructor(opts: FlinkOptions) {
-    this.name = opts.name;
-    this.port = opts.port || 3333;
-    this.dbOpts = opts.db;
-    this.debug = !!opts.debug;
-    this.onDbConnection = opts.onDbConnection;
-    this.plugins = opts.plugins || [];
-    this.corsOpts = { ...defaultCorsOptions, ...opts.cors };
-    this.auth = opts.auth;
-  }
-
-  get ctx() {
-    if (!this._ctx) {
-      throw new Error("Context is not yet initialized");
-    }
-    return this._ctx;
-  }
+    public name: string;
+    public expressApp?: Express;
+    public db?: Db;
+    public handlers: HandlerConfig[] = [];
+    public port?: number;
+    public started = false;
+
+    private _ctx?: C;
+    private dbOpts?: FlinkOptions["db"];
+    private debug = false;
+    private onDbConnection?: FlinkOptions["onDbConnection"];
+
+    private plugins: FlinkPlugin[] = [];
+    private auth?: FlinkAuthPlugin;
+    private corsOpts: FlinkOptions["cors"];
+    private routingConfigured = false;
+    private jsonOptions? : OptionsJson;
+
+    private repos: { [x: string]: FlinkRepo<C> } = {};
 
-  async start() {
-    const startTime = Date.now();
-    let offsetTime = 0;
-
-    await this.initDb();
-
-    if (this.debug) {
-      offsetTime = Date.now();
-      log.bgColorLog("cyan", `Init db took ${offsetTime - startTime} ms`);
+    /**
+     * Internal cache used to track registered handlers and potentially any overlapping routes
+     */
+    private handlerRouteCache = new Map<string, string>();
+
+    constructor(opts: FlinkOptions) {
+        this.name = opts.name;
+        this.port = opts.port || 3333;
+        this.dbOpts = opts.db;
+        this.debug = !!opts.debug;
+        this.onDbConnection = opts.onDbConnection;
+        this.plugins = opts.plugins || [];
+        this.corsOpts = { ...defaultCorsOptions, ...opts.cors };
+        this.auth = opts.auth;
+        this.jsonOptions = opts.jsonOptions || { limit : "1mb"}
     }
 
-    await this.buildContext();
-
-    if (this.debug) {
-      log.bgColorLog(
-        "cyan",
-        `Build context took ${Date.now() - offsetTime} ms`
-      );
-      offsetTime = Date.now();
+    get ctx() {
+        if (!this._ctx) {
+            throw new Error("Context is not yet initialized");
+        }
+        return this._ctx;
     }
 
-    if (this.debug) {
-      log.bgColorLog(
-        "cyan",
-        `Registered JSON schemas took ${Date.now() - offsetTime} ms`
-      );
-      offsetTime = Date.now();
-    }
+    async start() {
+        const startTime = Date.now();
+        let offsetTime = 0;
 
-    this.expressApp = express();
+        await this.initDb();
 
-    this.expressApp.use(cors(this.corsOpts));
+        if (this.debug) {
+            offsetTime = Date.now();
+            log.bgColorLog("cyan", `Init db took ${offsetTime - startTime} ms`);
+        }
 
-    this.expressApp.use(bodyParser.json());
+        await this.buildContext();
 
-    this.expressApp.use((req, res, next) => {
-      req.reqId = v4();
-      next();
-    });
+        if (this.debug) {
+            log.bgColorLog("cyan", `Build context took ${Date.now() - offsetTime} ms`);
+            offsetTime = Date.now();
+        }
 
-    // TODO: Add better more fine grained control when plugins are initialized, i.e. in what order
+        if (this.debug) {
+            log.bgColorLog("cyan", `Registered JSON schemas took ${Date.now() - offsetTime} ms`);
+            offsetTime = Date.now();
+        }
 
-    for (const plugin of this.plugins) {
-      let db;
+        this.expressApp = express();
 
-      if (plugin.db) {
-        db = await this.initPluginDb(plugin);
-      }
+        this.expressApp.use(cors(this.corsOpts));
 
-      if (plugin.init) {
-        await plugin.init(this, db);
-      }
+        this.expressApp.use(bodyParser.json(this.jsonOptions));
 
-      log.info(`Initialized plugin '${plugin.id}'`);
-    }
+        this.expressApp.use((req, res, next) => {
+            req.reqId = v4();
+            next();
+        });
 
-    await this.registerAutoRegisterableHandlers();
+        // TODO: Add better more fine grained control when plugins are initialized, i.e. in what order
 
-    if (this.debug) {
-      log.bgColorLog(
-        "cyan",
-        `Register handlers took ${Date.now() - offsetTime} ms`
-      );
-      offsetTime = Date.now();
-    }
+        for (const plugin of this.plugins) {
+            let db;
 
-    // Register 404 with slight delay to allow all manually added routes to be added
-    // TODO: Is there a better solution to force this handler to always run last?
-    setTimeout(() => {
-      this.expressApp!.use((req, res, next) => {
-        res.status(404).json(notFound());
-      });
-
-      this.routingConfigured = true;
-    });
-
-    this.expressApp?.listen(this.port, () => {
-      log.fontColorLog(
-        "magenta",
-        `⚡️ HTTP server '${this.name}' is running and waiting for connections on ${this.port}`
-      );
-
-      this.started = true;
-    });
-
-    return this;
-  }
-
-  /**
-   * Manually registers a handler.
-   *
-   * Typescript compiler will scan handler function and set schemas
-   * which are derived from handler function type arguments.
-   */
-  public addHandler(
-    handler: HandlerFile,
-    routePropsOverride?: Partial<HandlerConfig["routeProps"]>
-  ) {
-    if (this.routingConfigured) {
-      throw new Error(
-        "Cannot add handler after routes has been registered, make sure to invoke earlier"
-      );
-    }
+            if (plugin.db) {
+                db = await this.initPluginDb(plugin);
+            }
 
-    const routeProps = { ...(handler.Route || {}), ...routePropsOverride };
+            if (plugin.init) {
+                await plugin.init(this, db);
+            }
 
-    if (!routeProps.method) {
-      log.error(
-        `Failed to register handler '${handler.__file}': Missing 'method' in route props, either set it or name handler file with HTTP method as prefix`
-      );
-      return;
-    }
+            log.info(`Initialized plugin '${plugin.id}'`);
+        }
 
-    if (!routeProps.path) {
-      log.error(
-        `Failed to register handler '${handler.__file}': Missing 'path' in route props`
-      );
-      return;
-    }
+        await this.registerAutoRegisterableHandlers();
 
-    const dup = this.handlers.find(
-      (h) =>
-        h.routeProps.path === routeProps.path &&
-        h.routeProps.method === routeProps.method
-    );
+        if (this.debug) {
+            log.bgColorLog("cyan", `Register handlers took ${Date.now() - offsetTime} ms`);
+            offsetTime = Date.now();
+        }
 
-    const methodAndPath = `${routeProps.method.toUpperCase()} ${
-      routeProps.path
-    }`;
+        // Register 404 with slight delay to allow all manually added routes to be added
+        // TODO: Is there a better solution to force this handler to always run last?
+        setTimeout(() => {
+            this.expressApp!.use((req, res, next) => {
+                res.status(404).json(notFound());
+            });
 
-    if (dup) {
-      // TODO: Not sure if there is a case where you'd want to overwrite a route?
-      log.warn(`${methodAndPath} overlaps existing route`);
-    }
+            this.routingConfigured = true;
+        });
 
-    const handlerConfig: HandlerConfigWithMethod = {
-      routeProps: {
-        ...routeProps,
-        method: routeProps.method!,
-        path: routeProps.path!,
-      },
-      schema: {
-        reqSchema: handler.__schemas?.reqSchema,
-        resSchema: handler.__schemas?.resSchema,
-      },
-      queryMetadata: handler.__query || [],
-      paramsMetadata: handler.__params || [],
-    };
+        this.expressApp?.listen(this.port, () => {
+            log.fontColorLog("magenta", `⚡️ HTTP server '${this.name}' is running and waiting for connections on ${this.port}`);
 
-    if (handler.__schemas?.reqSchema && !handlerConfig.schema?.reqSchema) {
-      log.warn(
-        `Expected request schema ${handler.__schemas.reqSchema} for handler ${methodAndPath} but no such schema was found`
-      );
-    }
+            this.started = true;
+        });
 
-    if (handler.__schemas?.resSchema && !handlerConfig.schema?.resSchema) {
-      log.warn(
-        `Expected response schema ${handler.__schemas.resSchema} for handler ${methodAndPath} but no such schema was found`
-      );
+        return this;
     }
 
-    this.registerHandler(handlerConfig, handler.default);
-  }
+    /**
+     * Manually registers a handler.
+     *
+     * Typescript compiler will scan handler function and set schemas
+     * which are derived from handler function type arguments.
+     */
+    public addHandler(handler: HandlerFile, routePropsOverride?: Partial<HandlerConfig["routeProps"]>) {
+        if (this.routingConfigured) {
+            throw new Error("Cannot add handler after routes has been registered, make sure to invoke earlier");
+        }
 
-  private registerHandler(handlerConfig: HandlerConfig, handler: Handler<any>) {
-    this.handlers.push(handlerConfig);
+        const routeProps = { ...(handler.Route || {}), ...routePropsOverride };
 
-    const { routeProps, schema = {} } = handlerConfig;
-    const { method } = routeProps;
-    const app = this.expressApp!;
+        if (!routeProps.method) {
+            log.error(
+                `Failed to register handler '${handler.__file}': Missing 'method' in route props, either set it or name handler file with HTTP method as prefix`
+            );
+            return;
+        }
 
-    if (!method) {
-      log.error(`Route ${routeProps.path} is missing http method`);
-    }
+        if (!routeProps.path) {
+            log.error(`Failed to register handler '${handler.__file}': Missing 'path' in route props`);
+            return;
+        }
+
+        const dup = this.handlers.find((h) => h.routeProps.path === routeProps.path && h.routeProps.method === routeProps.method);
 
-    if (method) {
-      const methodAndRoute = `${method.toUpperCase()} ${routeProps.path}`;
+        const methodAndPath = `${routeProps.method.toUpperCase()} ${routeProps.path}`;
 
-      app[method](routeProps.path, async (req, res) => {
-        if (routeProps.permissions) {
-          if (!(await this.authenticate(req, routeProps.permissions))) {
-            return res.status(401).json(unauthorized());
-          }
+        if (dup) {
+            // TODO: Not sure if there is a case where you'd want to overwrite a route?
+            log.warn(`${methodAndPath} overlaps existing route`);
         }
 
-        if (schema.reqSchema) {
-          const validate = ajv.compile(schema.reqSchema);
-          const valid = validate(req.body);
-
-          if (!valid) {
-            log.warn(
-              `${methodAndRoute}: Bad request ${JSON.stringify(
-                validate.errors,
-                null,
-                2
-              )}`
-            );
+        const handlerConfig: HandlerConfigWithMethod = {
+            routeProps: {
+                ...routeProps,
+                method: routeProps.method!,
+                path: routeProps.path!,
+            },
+            schema: {
+                reqSchema: handler.__schemas?.reqSchema,
+                resSchema: handler.__schemas?.resSchema,
+            },
+            queryMetadata: handler.__query || [],
+            paramsMetadata: handler.__params || [],
+        };
+
+        if (handler.__schemas?.reqSchema && !handlerConfig.schema?.reqSchema) {
+            log.warn(`Expected request schema ${handler.__schemas.reqSchema} for handler ${methodAndPath} but no such schema was found`);
+        }
 
-            log.debug(`Invalid json: ${JSON.stringify(req.body)}`);
-
-            return res.status(400).json({
-              status: 400,
-              error: {
-                id: v4(),
-                title: "Bad request",
-                detail: `Schema did not validate ${JSON.stringify(
-                  validate.errors
-                )}`,
-              },
-            });
-          }
+        if (handler.__schemas?.resSchema && !handlerConfig.schema?.resSchema) {
+            log.warn(`Expected response schema ${handler.__schemas.resSchema} for handler ${methodAndPath} but no such schema was found`);
         }
 
-        if (routeProps.mockApi && schema.resSchema) {
-          log.warn(`Mock response for ${req.method.toUpperCase()} ${req.path}`);
+        this.registerHandler(handlerConfig, handler.default);
+    }
+
+    private registerHandler(handlerConfig: HandlerConfig, handler: Handler<any>) {
+        this.handlers.push(handlerConfig);
 
-          const data = generateMockData(schema.resSchema);
+        const { routeProps, schema = {} } = handlerConfig;
+        const { method } = routeProps;
+        const app = this.expressApp!;
 
-          res.status(200).json({
-            status: 200,
-            data,
-          });
-          return;
+        if (!method) {
+            log.error(`Route ${routeProps.path} is missing http method`);
         }
 
-        let handlerRes: FlinkResponse<any>;
-
-        try {
-          // 👇 This is where the actual handler gets invoked
-          handlerRes = await handler({
-            req,
-            ctx: this.ctx,
-            origin: routeProps.origin,
-          });
-        } catch (err) {
-          log.warn(
-            `Handler '${methodAndRoute}' threw unhandled exception ${err}`
-          );
-          return res.status(500).json(internalServerError(err as any));
+        if (method) {
+            const methodAndRoute = `${method.toUpperCase()} ${routeProps.path}`;
+
+            app[method](routeProps.path, async (req, res) => {
+                if (routeProps.permissions) {
+                    if (!(await this.authenticate(req, routeProps.permissions))) {
+                        return res.status(401).json(unauthorized());
+                    }
+                }
+
+                if (schema.reqSchema) {
+                    const validate = ajv.compile(schema.reqSchema);
+                    const valid = validate(req.body);
+
+                    if (!valid) {
+                        log.warn(`${methodAndRoute}: Bad request ${JSON.stringify(validate.errors, null, 2)}`);
+
+                        log.debug(`Invalid json: ${JSON.stringify(req.body)}`);
+
+                        return res.status(400).json({
+                            status: 400,
+                            error: {
+                                id: v4(),
+                                title: "Bad request",
+                                detail: `Schema did not validate ${JSON.stringify(validate.errors)}`,
+                            },
+                        });
+                    }
+                }
+
+                if (routeProps.mockApi && schema.resSchema) {
+                    log.warn(`Mock response for ${req.method.toUpperCase()} ${req.path}`);
+
+                    const data = generateMockData(schema.resSchema);
+
+                    res.status(200).json({
+                        status: 200,
+                        data,
+                    });
+                    return;
+                }
+
+                let handlerRes: FlinkResponse<any>;
+
+                try {
+                    // 👇 This is where the actual handler gets invoked
+                    handlerRes = await handler({
+                        req,
+                        ctx: this.ctx,
+                        origin: routeProps.origin,
+                    });
+                } catch (err) {
+                    log.warn(`Handler '${methodAndRoute}' threw unhandled exception ${err}`);
+                    console.error(err);
+                    return res.status(500).json(internalServerError(err as any));
+                }
+
+                if (schema.resSchema && !isError(handlerRes)) {
+                    const validate = ajv.compile(schema.resSchema);
+                    const valid = validate(JSON.parse(JSON.stringify(handlerRes.data)));
+
+                    if (!valid) {
+                        log.warn(`[${req.reqId}] ${methodAndRoute}: Bad response ${JSON.stringify(validate.errors, null, 2)}`);
+                        log.debug(`Invalid json: ${JSON.stringify(handlerRes.data)}`);
+                        // log.debug(JSON.stringify(schema, null, 2));
+
+                        return res.status(500).json({
+                            status: 500,
+                            error: {
+                                id: v4(),
+                                title: "Bad response",
+                                detail: `Schema did not validate ${JSON.stringify(validate.errors)}`,
+                            },
+                        });
+                    }
+                }
+
+                res.set(handlerRes.headers);
+
+                res.status(handlerRes.status || 200).json(handlerRes);
+            });
+
+            if (this.handlerRouteCache.has(methodAndRoute)) {
+                log.error(`Cannot register handler ${methodAndRoute} - route already registered`);
+                return process.exit(1); // TODO: Do we need to exit?
+            } else {
+                this.handlerRouteCache.set(methodAndRoute, JSON.stringify(routeProps));
+                log.info(`Registered route ${methodAndRoute}`);
+            }
         }
+    }
 
-        if (schema.resSchema && !isError(handlerRes)) {
-          const validate = ajv.compile(schema.resSchema);
-          const valid = validate(JSON.parse(JSON.stringify(handlerRes.data)));
-
-          if (!valid) {
-            log.warn(
-              `[${req.reqId}] ${methodAndRoute}: Bad response ${JSON.stringify(
-                validate.errors,
-                null,
-                2
-              )}`
+    /**
+     * Register handlers found within the `/src/handlers`
+     * directory in Flink App.
+     *
+     * Will not register any handlers added programmatically.
+     */
+    private async registerAutoRegisterableHandlers() {
+        for (const { handler, assumedHttpMethod } of autoRegisteredHandlers) {
+            if (!handler.Route) {
+                log.error(`Missing Props in handler ${handler.__file}`);
+                continue;
+            }
+
+            if (!handler.default) {
+                log.error(`Missing exported handler function in handler ${handler.__file}`);
+                continue;
+            }
+
+            this.registerHandler(
+                {
+                    routeProps: {
+                        ...handler.Route,
+                        method: handler.Route.method || assumedHttpMethod,
+                        origin: this.name,
+                    },
+                    schema: {
+                        reqSchema: handler.__schemas?.reqSchema,
+                        resSchema: handler.__schemas?.resSchema,
+                    },
+                    queryMetadata: handler.__query || [],
+                    paramsMetadata: handler.__params || [],
+                },
+                handler.default
             );
-            log.debug(`Invalid json: ${JSON.stringify(handlerRes.data)}`);
-            // log.debug(JSON.stringify(schema, null, 2));
-
-            return res.status(500).json({
-              status: 500,
-              error: {
-                id: v4(),
-                title: "Bad response",
-                detail: `Schema did not validate ${JSON.stringify(
-                  validate.errors
-                )}`,
-              },
-            });
-          }
         }
+    }
 
-        res.set(handlerRes.headers);
+    public addRepo(instanceName: string, repoInstance: FlinkRepo<C>) {
+        this.repos[instanceName] = repoInstance;
+        // TODO: Find out if we need to set ctx here or wanted not to if plugin has its own context
+        // repoInstance.ctx = this.ctx;
+    }
 
-        res.status(handlerRes.status || 200).json(handlerRes);
-      });
+    /**
+     * Constructs the app context. Will inject context in all components
+     * except for handlers which are handled in later stage.
+     */
+    private async buildContext() {
+        if (this.dbOpts) {
+            for (const { collectionName, repoInstanceName, Repo } of autoRegisteredRepos) {
+                const repoInstance: FlinkRepo<C> = new Repo(collectionName, this.db);
 
-      if (this.handlerRouteCache.has(methodAndRoute)) {
-        log.error(
-          `Cannot register handler ${methodAndRoute} - route already registered`
-        );
-        return process.exit(1); // TODO: Do we need to exit?
-      } else {
-        this.handlerRouteCache.set(methodAndRoute, JSON.stringify(routeProps));
-        log.info(`Registered route ${methodAndRoute}`);
-      }
-    }
-  }
-
-  /**
-   * Register handlers found within the `/src/handlers`
-   * directory in Flink App.
-   *
-   * Will not register any handlers added programmatically.
-   */
-  private async registerAutoRegisterableHandlers() {
-    for (const { handler, assumedHttpMethod } of autoRegisteredHandlers) {
-      if (!handler.Route) {
-        log.error(`Missing Props in handler ${handler.__file}`);
-        continue;
-      }
-
-      if (!handler.default) {
-        log.error(
-          `Missing exported handler function in handler ${handler.__file}`
-        );
-        continue;
-      }
-
-      this.registerHandler(
-        {
-          routeProps: {
-            ...handler.Route,
-            method: handler.Route.method || assumedHttpMethod,
-            origin: this.name,
-          },
-          schema: {
-            reqSchema: handler.__schemas?.reqSchema,
-            resSchema: handler.__schemas?.resSchema,
-          },
-          queryMetadata: handler.__query || [],
-          paramsMetadata: handler.__params || [],
-        },
-        handler.default
-      );
-    }
-  }
-
-  public addRepo(instanceName: string, repoInstance: FlinkRepo<C>) {
-    this.repos[instanceName] = repoInstance;
-  }
-
-  /**
-   * Constructs the app context. Will inject context in all components
-   * except for handlers which are handled in later stage.
-   */
-  private async buildContext() {
-    if (this.dbOpts) {
-      for (const {
-        collectionName,
-        repoInstanceName,
-        Repo,
-      } of autoRegisteredRepos) {
-        const repoInstance: FlinkRepo<C> = new Repo(collectionName, this.db);
-
-        this.repos[repoInstanceName] = repoInstance;
-
-        log.info(`Registered repo ${repoInstanceName}`);
-      }
-    } else if (autoRegisteredRepos.length > 0) {
-      log.warn(`No db configured but found repo(s)`);
-    }
+                this.repos[repoInstanceName] = repoInstance;
 
-    const pluginCtx = this.plugins.reduce<{ [x: string]: any }>(
-      (out, plugin) => {
-        if (out[plugin.id]) {
-          throw new Error(`Plugin ${plugin.id} is already registered`);
+                log.info(`Registered repo ${repoInstanceName}`);
+            }
+        } else if (autoRegisteredRepos.length > 0) {
+            log.warn(`No db configured but found repo(s)`);
+        }
+
+        const pluginCtx = this.plugins.reduce<{ [x: string]: any }>((out, plugin) => {
+            if (out[plugin.id]) {
+                throw new Error(`Plugin ${plugin.id} is already registered`);
+            }
+            out[plugin.id] = plugin.ctx;
+            return out;
+        }, {});
+
+        this._ctx = {
+            repos: this.repos,
+            plugins: pluginCtx,
+            auth: this.auth,
+        } as C;
+
+        for (const repo of Object.values(this.repos)) {
+            repo.ctx = this.ctx;
         }
-        out[plugin.id] = plugin.ctx;
-        return out;
-      },
-      {}
-    );
-
-    this._ctx = {
-      repos: this.repos,
-      plugins: pluginCtx,
-      auth: this.auth,
-    } as C;
-  }
-
-  /**
-   * Connects to database.
-   */
-  private async initDb() {
-    if (this.dbOpts) {
-      try {
-        log.debug("Connecting to db");
-        const client = await mongodb.connect(this.dbOpts.uri, {
-          useUnifiedTopology: true,
-          connectTimeoutMS: 4000,
-        });
-        this.db = client.db();
-      } catch (err) {
-        log.error("Failed to connect to db: " + err);
-        process.exit(1);
-      }
-
-      if (this.onDbConnection) {
-        await this.onDbConnection(this.db);
-      }
     }
-  }
-
-  /**
-   * Connects plugin to database.
-   */
-  private async initPluginDb(plugin: FlinkPlugin) {
-    if (!plugin.db) {
-      return;
+
+    /**
+     * Connects to database.
+     */
+    private async initDb() {
+        if (this.dbOpts) {
+            try {
+                log.debug("Connecting to db");
+                const client = await mongodb.connect(this.dbOpts.uri, {
+                    useUnifiedTopology: true,
+                    connectTimeoutMS: 4000,
+                });
+                this.db = client.db();
+            } catch (err) {
+                log.error("Failed to connect to db: " + err);
+                process.exit(1);
+            }
+
+            if (this.onDbConnection) {
+                await this.onDbConnection(this.db);
+            }
+        }
     }
 
-    if (plugin.db) {
-      if (plugin.db.useHostDb) {
-        if (!this.db) {
-          log.error(
-            `Plugin '${this.name} configured to use host app db, but no db exists in FlinkApp'`
-          );
-        } else {
-          return this.db;
+    /**
+     * Connects plugin to database.
+     */
+    private async initPluginDb(plugin: FlinkPlugin) {
+        if (!plugin.db) {
+            return;
         }
-      } else if (plugin.db.uri) {
-        try {
-          log.debug(`Connecting to '${plugin.id}' db`);
-          const client = await mongodb.connect(plugin.db.uri, {
-            useUnifiedTopology: true,
-          });
-          return client.db();
-        } catch (err) {
-          log.error(
-            `Failed to connect to db defined in plugin '${plugin.id}': ` + err
-          );
+
+        if (plugin.db) {
+            if (plugin.db.useHostDb) {
+                if (!this.db) {
+                    log.error(`Plugin '${this.name} configured to use host app db, but no db exists in FlinkApp'`);
+                } else {
+                    return this.db;
+                }
+            } else if (plugin.db.uri) {
+                try {
+                    log.debug(`Connecting to '${plugin.id}' db`);
+                    const client = await mongodb.connect(plugin.db.uri, {
+                        useUnifiedTopology: true,
+                    });
+                    return client.db();
+                } catch (err) {
+                    log.error(`Failed to connect to db defined in plugin '${plugin.id}': ` + err);
+                }
+            }
         }
-      }
     }
-  }
 
-  private async authenticate(req: Request, permissions: string | string[]) {
-    if (!this.auth) {
-      throw new Error(
-        `Attempting to authenticate request (${req.method} ${req.path}) but no authPlugin is set`
-      );
+    private async authenticate(req: Request, permissions: string | string[]) {
+        if (!this.auth) {
+            throw new Error(`Attempting to authenticate request (${req.method} ${req.path}) but no authPlugin is set`);
+        }
+        return await this.auth.authenticateRequest(req, permissions);
     }
-    return await this.auth.authenticateRequest(req, permissions);
-  }
 
-  public getRegisteredRoutes() {
-    return Array.from(this.handlerRouteCache.values());
-  }
+    public getRegisteredRoutes() {
+        return Array.from(this.handlerRouteCache.values());
+    }
 }