@webtypen/webframez-core 0.0.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,31 @@
+name: Node.js Package
+
+on:
+    release:
+        types: [created]
+
+jobs:
+    publish-gpr:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 18
+                  registry-url: https://npm.pkg.github.com/
+            - run: npm install
+            - run: npm publish
+              env:
+                  NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
+    publish-npm:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 18
+                  registry-url: https://registry.npmjs.org/
+            - run: npm install
+            - run: npm publish --access public
+              env:
+                  NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/README.md

@@ -0,0 +1,148 @@
+# webtypen webframez Docs
+
+## Controller
+
+### Register a controller
+
+A new controller is registered via the `controller` attribute in `app/Kernel.ts`. Just add a new entry for the controller to the object. The key of the object is the unique name of the controller, this is used again when connecting routes.
+
+The controllers are initialized once when the web service is started. When calling a route, a single controller instance is created per request and thrown away after the request finishes.
+
+## Routing
+
+### Register a route
+
+Routes are managed via the app/routes.ts. Routes can be registered and configured with the Route Facade. Routes can be associated strictly with a request method (GET, POST, PUT, DELETE) or all request methods (ANY):
+
+```ts
+Route.get("/", "TestController@test");
+Route.post("/test2", "TestController@test");
+Route.put("/test2", "TestController@test");
+Route.delete("/test2", "TestController@test");
+Route.any("/test2", "TestController@test");
+```
+
+The URL path is specified in the first parameter. The second parameter connects the route to a controller method. A previously registered controller can be connected using the syntax `[CONTROLLER]@[METHODE]`.
+
+Alternatively, a function can be specified directly or a previously imported one can be used:
+
+```ts
+// Directly
+Route.get("/", (req: Request, res: Response) =>
+  res.send({ status: "success" })
+);
+
+// Imported
+import { myFunction } from "./myfunction";
+Route.get("/", myFunction);
+```
+
+### Register a middleware
+
+Middleware functions are also registered in `app/Kernel.ts.` A middleware function can be associated with one or more routes. When calling these routes, the middleware function is called before executing the route logic. In this function, the request can be continued or aborted, for example, authorization rules can be implemented and easily reused for multiple routes.
+
+Middleware functions are usually created under `app/Middleware`. A middleware function is called with the parameters (next, abort, req and res):
+
+- `next`: Function that signals when called that the request may be continued
+- `abort`: Function that aborts the request when called. An HTTP status code can be specified in the first parameter and a request body (usually text or JSON) in the second.
+- `req`: The Request-Object
+- `res`: The Response-Object
+
+Alternatively, middleware functions can also be defined directly in Kernel.ts:
+
+```ts
+static middleware: { [key: string]: any } = {
+  auth: async (next: any, abort: any, req: Request, res: Response) => {
+    console.log("auth-middleware");
+    next();
+  },
+};
+```
+
+A route can be connected to several middleware functions, which are called one after the other but before executing the route logic.
+
+### Connect a route with a middleware
+
+When registering a route, a configuration object can be passed in the third parameter. This can contain an array with middleware keys in the `middleware` parameter. The middlewares specified here are executed prior to executing the route logic when invoking this route. If a specified middleware aborts the request, it will not be executed:
+
+```ts
+Route.get("/auth-data", "AuthController@authData", { middleware: ["auth"] });
+```
+
+### Group routes
+
+With the grouping of routes, the code of the application can be significantly reduced and kept clear. Here's how the following configurations can be used with a multiple route definition:
+
+- `prefix`: A route path prefix used for all routes in this group:
+
+```ts
+Route.group({ prefix: "/admin", () => {
+    Route.get("/dashboard", "AdminDashboardController@data");
+    // Path for this route would be: /admin/dashboard
+}});
+```
+
+- `middleware`: An array of middleware-keys used for all routes in this group:
+
+```ts
+Route.group({ middleware: ["auth"], () => {
+    // Route with middleware auth
+    Route.get("/auth-data", "AuthController@authData");
+
+    // Route with middleware auth and admin
+    Route.get("/dashboard", "AdminDashboardController@data", { middleware: ["admin"] });
+}});
+```
+
+The configuration parameters of a route group can of course be combined with each other.
+
+Nesting of the route groups is also possible:
+
+```ts
+Route.group({ prefix: "/test" }, () => {
+  Route.get("/", "TestController@test"); // Path: /test/
+  Route.get("/test2", "TestController@test"); // Path: /test2/
+
+  Route.group({ middleware: ["auth"], prefix: "/auth" }, () => {
+    Route.get("/data", "AuthController@data"); // Path: /test/auth/data; Middleware: auth
+  });
+});
+```
+
+## Database
+
+### Connect
+
+The application can handle multiple database connections, but one is defined as the default connection and is automatically used by the system if models and database requests are not explicitly executed over another connection.
+
+The connections are configured in the `config/database.ts` file. Each connection is given a unique key in the `connections` object and uses a driver. The following drivers are currently available:
+
+- MongoDB Driver
+
+Depending on the driver, the database connection must be configured with different parameters.
+
+**MongoDB Connection example:**
+
+```ts
+export default {
+  defaultConnection: "default",
+  connections: {
+    ["default"]: {
+      driver: "mongodb",
+      url: "mongodb://...",
+    },
+  },
+};
+```
+
+### Model
+
+Models are usually placed under `app/Models`. Each model class inherits from `Model` and must store the table / collection name, in which the models data sets are stored, in the `__table` attribute.
+
+```ts
+import { Model } from "@webtypen/webframez-core";
+
+export class Test extends Model {
+  __table = "test_table";
+}
+```

package/index.ts

@@ -0,0 +1,8 @@
+export * from "./src/BaseKernel";
+export * from "./src/Controller/Controller";
+export * from "./src/WebApplication";
+export * from "./src/Router/Route";
+export * from "./src/Router/Request";
+export * from "./src/Router/Response";
+export * from "./src/Database/Model";
+export * from "./src/Database/QueryBuilder";

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@webtypen/webframez-core",
+  "version": "0.0.1",
+  "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
+  "homepage": "https://webtypen.de/",
+  "license": "MIT",
+  "main": "index.js",
+  "author": {
+    "name": "Benedict Romp",
+    "email": "b.romp@webtypen.de",
+    "url": "https://webtypen.de/"
+  },
+  "bugs": {
+    "url": "https://github.com/webtypen/webframez-core/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webtypen/webframez-core.git"
+  },
+  "dependencies": {
+    "dotenv": "^8.2.0",
+    "lodash": "^4.17.20"
+  }
+}

package/src/BaseKernel.ts

@@ -0,0 +1,7 @@
+import { Controller } from "./Controller/Controller";
+
+export class BaseKernel {
+  static commands = [];
+  static controller: { [key: string]: Controller } = {};
+  static middleware: { [key: string]: any };
+}

package/src/Controller/Controller.ts

@@ -0,0 +1 @@
+export class Controller {}

package/src/Database/BaseDBDriver.ts

@@ -0,0 +1,22 @@
+import { Model } from "./Model";
+import { QueryBuilder } from "./QueryBuilder";
+
+export class BaseDBDriver {
+  config?: object;
+
+  setConfig(config: object) {
+    this.config = config;
+  }
+
+  async connect() {}
+
+  async close(client: any) {}
+
+  async handleQueryBuilder(client: any, queryBuilder: QueryBuilder) {}
+
+  async execute(client: any, data: any) {}
+
+  async onModelSave(model: Model, saveStatus: any | null | undefined) {
+    return model;
+  }
+}

package/src/Database/DBConnection.ts

@@ -0,0 +1,103 @@
+import { DBDrivers } from "./DBDriver";
+import dbconfig from "../../../../config/database";
+import { QueryBuilder } from "./QueryBuilder";
+
+class DBConnectionFacade {
+  connections: { [key: string]: any } = {};
+
+  getConnectionConfig(connection: string) {
+    if (!connection) {
+      connection = dbconfig.defaultConnection;
+    }
+
+    if (
+      !connection ||
+      !dbconfig ||
+      !dbconfig.connections ||
+      !dbconfig.connections[connection as keyof {}]
+    ) {
+      throw new Error("No connection given ...");
+    }
+
+    return dbconfig.connections[connection as keyof {}];
+  }
+
+  getConnectionDriver(connection: string) {
+    const config = this.getConnectionConfig(connection);
+    if (!config || !config["driver"]) {
+      return null;
+    }
+
+    const driverClass = DBDrivers.get(config["driver"]);
+    const driver = new driverClass();
+    driver.setConfig(config);
+    return driver;
+  }
+
+  async getConnection(connectionName?: string) {
+    if (!connectionName) {
+      connectionName = dbconfig.defaultConnection;
+    }
+
+    if (
+      this.connections[connectionName] &&
+      this.connections[connectionName].driver
+    ) {
+      // Use cached connection
+      return this.connections[connectionName];
+    }
+
+    // Create new connection and cache it
+    const driver = this.getConnectionDriver(connectionName);
+    const client = await driver.connect();
+
+    this.connections[connectionName] = {
+      driver: driver,
+      client: client,
+    };
+
+    return this.connections[connectionName];
+  }
+
+  async runQuery(query: QueryBuilder, options?: { [name: string]: any }) {
+    const connection = await this.getConnection();
+    const data = await connection.driver.handleQueryBuilder(
+      connection.client,
+      query
+    );
+
+    if (options && options.raw) {
+      return data;
+    }
+
+    if (!data) {
+      return null;
+    }
+
+    // @ToDo: Model-Mapping
+    return data;
+  }
+
+  async execute(data: any, connectionName?: string) {
+    const connection = await this.getConnection(connectionName);
+
+    return await connection.driver.execute(connection.client, data);
+  }
+
+  async getDriver(connectionName?: string) {
+    const connection = await this.getConnection(connectionName);
+    return connection.driver;
+  }
+
+  mapDataToModel(model: any, data: any) {
+    const obj = new model();
+    if (data) {
+      for (let i in data) {
+        obj[i] = data[i];
+      }
+    }
+    return obj;
+  }
+}
+
+export const DBConnection = new DBConnectionFacade();

package/src/Database/DBDriver.ts

@@ -0,0 +1,13 @@
+export class DBDriversFacade {
+  drivers: { [key: string]: any } = {};
+
+  register(name: string, component: any) {
+    this.drivers[name] = component;
+  }
+
+  get(name: string) {
+    return this.drivers[name];
+  }
+}
+
+export const DBDrivers = new DBDriversFacade();

package/src/Database/Model.ts

@@ -0,0 +1,135 @@
+import { DBConnection } from "./DBConnection";
+import { QueryBuilder } from "./QueryBuilder";
+
+export class Model {
+  [key: string]: any | undefined; // allow-custom-properties
+  __primaryKey = "_id";
+  __table: string = "";
+  __connection: string | undefined = undefined;
+  __hidden: string[] = [];
+  __unmapped: string[] = [];
+  __unmappedSystem: string[] = [
+    "__primaryKey",
+    "__table",
+    "__connection",
+    "__unmapped",
+    "__unmappedSystem",
+    "__is_deleted",
+    "__hidden",
+  ];
+
+  /**
+   * Creates a new query-builder object and adds a where-clause
+   * @param column
+   * @param operator
+   * @param value
+   * @returns QueryBulder
+   */
+  static where(column: any, operator: any, value: any): QueryBuilder {
+    const model = new this();
+    const queryBuilder = new QueryBuilder();
+    queryBuilder.setModelMapping(this);
+    queryBuilder.table(model.__table);
+    queryBuilder.where(column, operator, value);
+
+    return queryBuilder;
+  }
+
+  /**
+   * Executes a database-aggregation (mostly used by no-sql connections)
+   * @param aggregation
+   * @returns any
+   */
+  static async aggregate(aggregation: any) {
+    const model = new this();
+    return await DBConnection.execute(
+      {
+        type: "aggregation",
+        table: model.__table,
+        aggregation: aggregation,
+      },
+      model.__connection
+    );
+  }
+
+  /**
+   * Returns the model-data without system- and unmapped-fields (new js-object)
+   * @returns object
+   */
+  getModelData(): object {
+    const out: { [key: string]: any } = {};
+    for (let i in this) {
+      if (!this.__unmapped.includes(i) && !this.__unmappedSystem.includes(i)) {
+        out[i] = this[i];
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Returns the model-data without system-, unmapped- and hidden-fields (new js-object)
+   * @returns object
+   */
+  toArray(): object {
+    const out: { [key: string]: any } = {};
+    for (let i in this) {
+      if (
+        !this.__unmapped.includes(i) &&
+        !this.__unmappedSystem.includes(i) &&
+        !this.__hidden.includes(i)
+      ) {
+        out[i] = this[i];
+      }
+    }
+    return out;
+  }
+
+  /**
+   * Saves the object in the database
+   * @returns Model
+   */
+  async save() {
+    let status = null;
+    if (this[this.__primaryKey] !== undefined && this[this.__primaryKey]) {
+      // Update
+      status = await DBConnection.execute({
+        type: "updateOne",
+        table: this.__table,
+        primaryKey: this.__primaryKey,
+        filter: { [this.__primaryKey]: this[this.__primaryKey] },
+        data: this.getModelData(),
+      });
+    } else {
+      // Insert
+      status = await DBConnection.execute({
+        type: "insertOne",
+        table: this.__table,
+        data: this.getModelData(),
+      });
+    }
+
+    // onModelSave
+    const driver = await DBConnection.getDriver(this.__connection);
+    return driver.onModelSave(this, status);
+  }
+
+  /**
+   * Deletes the object from the database
+   * @returns boolean
+   */
+  async delete() {
+    if (!this[this.__primaryKey]) {
+      return false;
+    }
+
+    const queryBuilder = new QueryBuilder();
+    queryBuilder.setModelMapping(this);
+    queryBuilder.table(this.__table);
+    queryBuilder.where(this.__primaryKey, "=", this[this.__primaryKey]);
+    await queryBuilder.delete({ mode: "deleteOne" });
+
+    this.__is_deleted = true;
+
+    return true;
+  }
+}

package/src/Database/QueryBuilder.ts

@@ -0,0 +1,65 @@
+import { DBConnection } from "./DBConnection";
+import { Model } from "./Model";
+
+export class QueryBuilder {
+  database: string | null = null;
+  query: any[] = [];
+  queryTable: string = "";
+  mode = "get";
+  modelMapping = null;
+
+  setModelMapping(model?: any | null) {
+    this.modelMapping = model;
+  }
+
+  table(table: string) {
+    this.queryTable = table;
+  }
+
+  where(column: any, operator: any, value: any) {
+    this.query.push({
+      type: "where",
+      column: column,
+      operator: operator,
+      value: value,
+    });
+  }
+
+  async get(options?: any) {
+    this.mode = "get";
+
+    const result = await DBConnection.runQuery(this);
+    if (options && options.disableModelMapping) {
+      return result && result.length > 0 ? result : null;
+    }
+
+    return result && result.length > 0 && this.modelMapping !== null
+      ? result.map((el: Model) =>
+          DBConnection.mapDataToModel(this.modelMapping, el)
+        )
+      : result && result.length > 0
+      ? result
+      : null;
+  }
+
+  async first(options?: any) {
+    this.mode = "first";
+
+    const result = await DBConnection.runQuery(this);
+    if (options && options.disableModelMapping) {
+      return result ? result : null;
+    }
+
+    return result && this.modelMapping !== null
+      ? DBConnection.mapDataToModel(this.modelMapping, result)
+      : null;
+  }
+
+  async delete(options?: { mode: string }) {
+    this.mode =
+      options && options.mode === "deleteOne" ? "deleteOne" : "delete";
+
+    await DBConnection.runQuery(this);
+    return true;
+  }
+}

package/src/Router/Request.ts

@@ -0,0 +1,12 @@
+export type Request = {
+  body?: any;
+  bodyPlain?: any;
+  params: object;
+  httpVersionMajor: any;
+  httpVersionMinor: any;
+  httpVersion: any;
+  headers: object;
+  rawHeaders: object;
+  url: string;
+  method: string;
+};

package/src/Router/Response.ts

@@ -0,0 +1,61 @@
+import { ServerResponse } from "http";
+
+export class Response {
+  res?: ServerResponse;
+
+  /**
+   * Sets the ServerResponse (res) Object (nodejs/http module)
+   * @param res
+   * @returns
+   */
+  setServerResponse(res: ServerResponse) {
+    this.res = res;
+    return this;
+  }
+
+  /**
+   * Set the http-status-code
+   *
+   * @param status
+   * @returns
+   */
+  status(status: number): Response {
+    if (!this.res) {
+      return this;
+    }
+
+    this.res.statusCode = status;
+    return this;
+  }
+
+  /**
+   * Set a header attribute: Content-Type: application/json
+   *
+   * @param type
+   * @param value
+   * @returns
+   */
+  header(type: string, value: string) {
+    if (!this.res) {
+      return this;
+    }
+
+    this.res.setHeader(type, value);
+    return this;
+  }
+
+  /**
+   * Sends data to the client
+   * Any objects will be stringified to JSON
+   *
+   * @param content
+   */
+  send(content: any) {
+    if (typeof content === "object") {
+      this.res?.setHeader("Content-Type", "application/json");
+      this.res?.write(JSON.stringify(content));
+    } else {
+      this.res?.write(content);
+    }
+  }
+}

package/src/Router/Route.ts

@@ -0,0 +1,159 @@
+import { Router } from "./Router";
+
+export class RouteFacade {
+  tempGroupPrefix: string | null = null;
+  tempGroupMiddleware: string[] | null = null;
+
+  /**
+   * Register a GET-Method
+   *
+   * @param path
+   * @param component
+   * @param options
+   */
+  get(path: string, component: any, options?: { [key: string]: any }) {
+    Router.register(
+      "GET",
+      (this.tempGroupPrefix ? this.tempGroupPrefix : "") + path,
+      component,
+      options || this.tempGroupMiddleware
+        ? {
+            ...(options ? options : {}),
+            middleware:
+              this.tempGroupMiddleware || (options && options.middleware)
+                ? [
+                    ...(this.tempGroupMiddleware
+                      ? this.tempGroupMiddleware
+                      : []),
+                    ...(options && options.middleware
+                      ? options.middleware
+                      : []),
+                  ]
+                : null,
+          }
+        : {}
+    );
+  }
+
+  /**
+   * Register a POST-Method
+   *
+   * @param path
+   * @param component
+   * @param options
+   */
+  post(path: string, component: any, options?: { [key: string]: any }) {
+    Router.register(
+      "POST",
+      (this.tempGroupPrefix ? this.tempGroupPrefix : "") + path,
+      component,
+      options || this.tempGroupMiddleware
+        ? {
+            ...(options ? options : {}),
+            middleware:
+              this.tempGroupMiddleware || (options && options.middleware)
+                ? [
+                    ...(this.tempGroupMiddleware
+                      ? this.tempGroupMiddleware
+                      : []),
+                    ...(options && options.middleware
+                      ? options.middleware
+                      : []),
+                  ]
+                : null,
+          }
+        : {}
+    );
+  }
+
+  /**
+   * Register a PUT-Method
+   *
+   * @param path
+   * @param component
+   * @param options
+   */
+  put(path: string, component: any, options?: { [key: string]: any }) {
+    Router.register(
+      "PUT",
+      (this.tempGroupPrefix ? this.tempGroupPrefix : "") + path,
+      component,
+      options || this.tempGroupMiddleware
+        ? {
+            ...(options ? options : {}),
+            middleware:
+              this.tempGroupMiddleware || (options && options.middleware)
+                ? [
+                    ...(this.tempGroupMiddleware
+                      ? this.tempGroupMiddleware
+                      : []),
+                    ...(options && options.middleware
+                      ? options.middleware
+                      : []),
+                  ]
+                : null,
+          }
+        : {}
+    );
+  }
+
+  /**
+   * Register a DELETE-Method
+   *
+   * @param path
+   * @param component
+   * @param options
+   */
+  delete(path: string, component: any, options?: { [key: string]: any }) {
+    Router.register(
+      "DELETE",
+      (this.tempGroupPrefix ? this.tempGroupPrefix : "") + path,
+      component,
+      options || this.tempGroupMiddleware
+        ? {
+            ...(options ? options : {}),
+            middleware:
+              this.tempGroupMiddleware || (options && options.middleware)
+                ? [
+                    ...(this.tempGroupMiddleware
+                      ? this.tempGroupMiddleware
+                      : []),
+                    ...(options && options.middleware
+                      ? options.middleware
+                      : []),
+                  ]
+                : null,
+          }
+        : {}
+    );
+  }
+
+  group(config: { [key: string]: any }, children: any) {
+    // Handle group prefix
+    if (config && config.prefix && config.prefix.trim() !== "") {
+      this.tempGroupPrefix =
+        (this.tempGroupPrefix ? this.tempGroupPrefix : "") + config.prefix;
+    }
+
+    // Handle group middleware
+    if (config && config.middleware && config.middleware.length > 0) {
+      if (!this.tempGroupMiddleware || this.tempGroupMiddleware.length === 0) {
+        this.tempGroupMiddleware = config.middleware;
+      } else {
+        this.tempGroupMiddleware = [
+          ...this.tempGroupMiddleware,
+          ...config.middleware,
+        ];
+      }
+    }
+
+    // Handle children / group body
+    children();
+
+    // Reset temp-group data
+    this.tempGroupPrefix = null;
+    this.tempGroupMiddleware = null;
+  }
+}
+
+export const Route = new RouteFacade();

package/src/Router/Router.ts

@@ -0,0 +1,295 @@
+import qs from "qs";
+import { IncomingMessage, ServerResponse } from "http";
+import { Response } from "./Response";
+import { Kernel } from "../../../../app/Kernel";
+
+type RouteObject = {
+  path: string;
+  component: any;
+  options: { [key: string]: any };
+  params: object;
+};
+
+class RouterFacade {
+  /**
+   * GET Route Store
+   */
+  routesGET: {
+    [key: string]: {
+      path: string;
+      component: any;
+      options: object;
+      params?: object;
+    };
+  } = {};
+
+  /**
+   * POST Route Store
+   */
+  routesPOST: {
+    [key: string]: {
+      path: string;
+      component: any;
+      options: object;
+      params?: object;
+    };
+  } = {};
+
+  /**
+   * PUT Route Store
+   */
+  routesPUT: {
+    [key: string]: {
+      path: string;
+      component: any;
+      options: object;
+      params?: object;
+    };
+  } = {};
+
+  /**
+   * DELETE Route Store
+   */
+  routesDELETE: {
+    [key: string]: {
+      path: string;
+      component: any;
+      options: object;
+      params?: object;
+    };
+  } = {};
+
+  /**
+   * Load the application-routes
+   *
+   */
+  init() {
+    // Load routes
+    require(process.cwd() + "/app/routes");
+  }
+
+  /**
+   * Register a route
+   *
+   * @param type
+   * @param path
+   * @param component
+   * @param options
+   */
+  register(type: string, path: string, component: any, options: object) {
+    if (type === "GET") {
+      this.routesGET[path] = {
+        path: path,
+        component: component,
+        options: options,
+      };
+    } else if (type === "POST") {
+      this.routesPOST[path] = {
+        path: path,
+        component: component,
+        options: options,
+      };
+    }
+  }
+
+  /**
+   * Loads the matching route based on the request-url
+   *
+   * @param req
+   * @returns
+   */
+  dissolve(req: IncomingMessage): RouteObject | null {
+    if (!req.url) {
+      return null;
+    }
+
+    if (req.method === "GET") {
+      return this.dissolveRoute(this.routesGET, req.url);
+    } else if (req.method === "POST") {
+      return this.dissolveRoute(this.routesPOST, req.url);
+    } else if (req.method === "PUT") {
+      return this.dissolveRoute(this.routesPUT, req.url);
+    } else if (req.method === "DELETE") {
+      return this.dissolveRoute(this.routesDELETE, req.url);
+    }
+    return null;
+  }
+
+  /**
+   * Dissolves the matching route based on the request-url and an object of routes
+   *
+   * @param routes
+   * @param url
+   * @returns
+   */
+  dissolveRoute(routes: any, url: string) {
+    if (routes[url]) {
+      // If url matches directly -> instant return
+      return { ...routes[url], params: {} };
+    } else {
+      // Try to find the matching route: Run through the slash-separated parts of the route
+      const partsRequest = url.split("/");
+
+      for (let path in routes) {
+        let status = true;
+        const parts = path.split("/");
+        const params: { [key: string]: any } = {};
+
+        for (let i in partsRequest) {
+          if (partsRequest[i] !== parts[i]) {
+            // Handle URL-Params
+            if (parts[i] && parts[i].trim().substring(0, 1) === ":") {
+              params[parts[i].trim().substring(1).toString()] = partsRequest[i];
+              continue;
+            }
+
+            status = false;
+            continue;
+          }
+        }
+
+        if (status) {
+          return { ...routes[path], params: params };
+        }
+      }
+    }
+  }
+
+  /**
+   * Sends the default 404-Page
+   *
+   * @param res
+   */
+  sendError(res: ServerResponse, code: number, message?: string) {
+    res.writeHead(code, { "Content-Type": "text/html" });
+    res.end(
+      message
+        ? message
+        : code === 404
+        ? "Oops! Page not found ..."
+        : "Oops! There was an unexpected error ..."
+    );
+  }
+
+  /**
+   * Processes a request
+   *
+   * @param req
+   * @param res
+   */
+  async handleRequest(req: IncomingMessage, res: ServerResponse) {
+    const route = this.dissolve(req);
+
+    // Check-Middleware
+    if (
+      route &&
+      route.options &&
+      route.options.middleware &&
+      route.options.middleware.length > 0
+    ) {
+      for (let middlewareKey of route.options.middleware) {
+        const middleware = Kernel.middleware[middlewareKey];
+        if (!middleware) {
+          return this.sendError(
+            res,
+            500,
+            "Unknown middleware `" + middlewareKey + "` ..."
+          );
+        }
+
+        try {
+          await new Promise((resolve, reject) => {
+            try {
+              middleware(
+                resolve,
+                (status: number, data: any) => {
+                  reject({ status: status, data: data });
+                },
+                req,
+                res
+              );
+            } catch (e) {
+              console.error(e);
+
+              return this.sendError(
+                res,
+                500,
+                "Error in middleware `" + middlewareKey + "` ..."
+              );
+            }
+          });
+        } catch (e: any) {
+          // Send Middleware-Abort
+          res.writeHead(
+            e.status,
+            typeof e.data === "object"
+              ? { "Content-Type": "application/json" }
+              : { "Content-Type": "text/html" }
+          );
+          res.end(
+            typeof e.data === "object"
+              ? JSON.stringify(e.data)
+              : e.data
+              ? e.data
+              : " "
+          );
+          return;
+        }
+      }
+    }
+
+    // Resolve route-component (handle controller definition)
+    if (route && typeof route.component === "string") {
+      const split = route.component.split("@");
+      const controller = Kernel.controller[split[0]];
+      if (!controller) {
+        res.writeHead(500, { "Content-Type": "text/html" });
+        res.end("Controller `" + split[0] + "` not found ...");
+        return;
+      }
+
+      // Set Controller method as route-component
+      const controllerInstance = new controller();
+      route.component = controllerInstance[split[1]];
+    }
+
+    if (route && route.component !== undefined) {
+      let body: any = [];
+      const bodyPlain: any = await new Promise((resolve: Function) => {
+        req
+          .on("data", (chunk) => {
+            body.push(chunk);
+          })
+          .on("end", () => {
+            resolve(Buffer.concat(body).toString());
+          });
+      });
+
+      try {
+        await route.component(
+          {
+            body: bodyPlain ? qs.parse(bodyPlain) : {},
+            bodyPlain: bodyPlain,
+            params: route.params,
+            httpVersionMajor: req.httpVersionMajor,
+            httpVersionMinor: req.httpVersionMinor,
+            httpVersion: req.httpVersion,
+            headers: req.headers,
+            rawHeaders: req.rawHeaders,
+            url: req.url,
+            method: req.method,
+          },
+          new Response().setServerResponse(res)
+        );
+        res.end();
+      } catch (e) {
+        console.error(e);
+        this.sendError(res, 500);
+      }
+    } else {
+      this.sendError(res, 404);
+    }
+  }
+}
+
+export const Router = new RouterFacade();

package/src/WebApplication.ts

@@ -0,0 +1,21 @@
+import http, { Server } from "http";
+import { Router } from "./Router/Router";
+
+export class WebApplication {
+  private server!: Server;
+
+  /**
+   * Init the routes and start the http-server
+   */
+  boot() {
+    Router.init();
+
+    this.server = http
+      .createServer((req, res) => {
+        Router.handleRequest(req, res);
+      })
+      .listen(3000, () => {
+        console.log("Server started and listening on port 3000");
+      });
+  }
+}