@webtypen/webframez-core 0.0.2 → 0.0.4

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

@@ -14,6 +14,7 @@ jobs:
                   node-version: 18
                   registry-url: https://npm.pkg.github.com/
             - run: npm install
+            - run: npm run build
             - run: npm publish
               env:
                   NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
@@ -26,6 +27,7 @@ jobs:
                   node-version: 18
                   registry-url: https://registry.npmjs.org/
             - run: npm install
+            - run: npm run build
             - run: npm publish --access public
               env:
                   NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/lib/BaseKernel.d.ts

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

package/lib/BaseKernel.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseKernel = void 0;
+class BaseKernel {
+}
+exports.BaseKernel = BaseKernel;
+BaseKernel.commands = [];
+BaseKernel.controller = {};

package/lib/Controller/Controller.d.ts

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

package/lib/Controller/Controller.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Controller = void 0;
+class Controller {
+}
+exports.Controller = Controller;

package/lib/Database/BaseDBDriver.d.ts

@@ -0,0 +1,11 @@
+import { Model } from "./Model";
+import { QueryBuilder } from "./QueryBuilder";
+export declare class BaseDBDriver {
+    config?: object;
+    setConfig(config: object): void;
+    connect(): Promise<void>;
+    close(client: any): Promise<void>;
+    handleQueryBuilder(client: any, queryBuilder: QueryBuilder): Promise<void>;
+    execute(client: any, data: any): Promise<void>;
+    onModelSave(model: Model, saveStatus: any | null | undefined): Promise<Model>;
+}

package/lib/Database/BaseDBDriver.js

@@ -0,0 +1,35 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDBDriver = void 0;
+class BaseDBDriver {
+    setConfig(config) {
+        this.config = config;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    close(client) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    handleQueryBuilder(client, queryBuilder) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    execute(client, data) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    onModelSave(model, saveStatus) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return model;
+        });
+    }
+}
+exports.BaseDBDriver = BaseDBDriver;

package/lib/Database/DBConnection.d.ts

@@ -0,0 +1,17 @@
+import { QueryBuilder } from "./QueryBuilder";
+declare class DBConnectionFacade {
+    connections: {
+        [key: string]: any;
+    };
+    getConnectionConfig(connection: string): any;
+    getConnectionDriver(connection: string): any;
+    getConnection(connectionName?: string): Promise<any>;
+    runQuery(query: QueryBuilder, options?: {
+        [name: string]: any;
+    }): Promise<any>;
+    execute(data: any, connectionName?: string): Promise<any>;
+    getDriver(connectionName?: string): Promise<any>;
+    mapDataToModel(model: any, data: any): any;
+}
+export declare const DBConnection: DBConnectionFacade;
+export {};

package/lib/Database/DBConnection.js

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBConnection = void 0;
+const DBDriver_1 = require("./DBDriver");
+// @ts-ignore
+const database_1 = __importDefault(require("../../../../../config/database"));
+class DBConnectionFacade {
+    constructor() {
+        this.connections = {};
+    }
+    getConnectionConfig(connection) {
+        if (!connection) {
+            connection = database_1.default.defaultConnection;
+        }
+        if (!connection ||
+            !database_1.default ||
+            !database_1.default.connections ||
+            !database_1.default.connections[connection]) {
+            throw new Error("No connection given ...");
+        }
+        return database_1.default.connections[connection];
+    }
+    getConnectionDriver(connection) {
+        const config = this.getConnectionConfig(connection);
+        if (!config || !config["driver"]) {
+            return null;
+        }
+        const driverClass = DBDriver_1.DBDrivers.get(config["driver"]);
+        const driver = new driverClass();
+        driver.setConfig(config);
+        return driver;
+    }
+    getConnection(connectionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!connectionName) {
+                connectionName = database_1.default.defaultConnection;
+            }
+            if (!connectionName) {
+                return null;
+            }
+            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 = yield driver.connect();
+            this.connections[connectionName] = {
+                driver: driver,
+                client: client,
+            };
+            return this.connections[connectionName];
+        });
+    }
+    runQuery(query, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            const data = yield connection.driver.handleQueryBuilder(connection.client, query);
+            if (options && options.raw) {
+                return data;
+            }
+            if (!data) {
+                return null;
+            }
+            // @ToDo: Model-Mapping
+            return data;
+        });
+    }
+    execute(data, connectionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection(connectionName);
+            return yield connection.driver.execute(connection.client, data);
+        });
+    }
+    getDriver(connectionName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection(connectionName);
+            return connection.driver;
+        });
+    }
+    mapDataToModel(model, data) {
+        const obj = new model();
+        if (data) {
+            for (let i in data) {
+                obj[i] = data[i];
+            }
+        }
+        return obj;
+    }
+}
+exports.DBConnection = new DBConnectionFacade();

package/lib/Database/DBDriver.d.ts

@@ -0,0 +1,8 @@
+export declare class DBDriversFacade {
+    drivers: {
+        [key: string]: any;
+    };
+    register(name: string, component: any): void;
+    get(name: string): any;
+}
+export declare const DBDrivers: DBDriversFacade;

package/lib/Database/DBDriver.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBDrivers = exports.DBDriversFacade = void 0;
+class DBDriversFacade {
+    constructor() {
+        this.drivers = {};
+    }
+    register(name, component) {
+        this.drivers[name] = component;
+    }
+    get(name) {
+        return this.drivers[name];
+    }
+}
+exports.DBDriversFacade = DBDriversFacade;
+exports.DBDrivers = new DBDriversFacade();

package/lib/Database/Model.d.ts

@@ -0,0 +1,44 @@
+import { QueryBuilder } from "./QueryBuilder";
+export declare class Model {
+    [key: string]: any | undefined;
+    __primaryKey: string;
+    __table: string;
+    __connection: string | undefined;
+    __hidden: string[];
+    __unmapped: string[];
+    __unmappedSystem: string[];
+    /**
+     * 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;
+    /**
+     * Executes a database-aggregation (mostly used by no-sql connections)
+     * @param aggregation
+     * @returns any
+     */
+    static aggregate(aggregation: any): Promise<any>;
+    /**
+     * Returns the model-data without system- and unmapped-fields (new js-object)
+     * @returns object
+     */
+    getModelData(): object;
+    /**
+     * Returns the model-data without system-, unmapped- and hidden-fields (new js-object)
+     * @returns object
+     */
+    toArray(): object;
+    /**
+     * Saves the object in the database
+     * @returns Model
+     */
+    save(): Promise<any>;
+    /**
+     * Deletes the object from the database
+     * @returns boolean
+     */
+    delete(): Promise<boolean>;
+}

package/lib/Database/Model.js

@@ -0,0 +1,139 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const DBConnection_1 = require("./DBConnection");
+const QueryBuilder_1 = require("./QueryBuilder");
+class Model {
+    constructor() {
+        this.__primaryKey = "_id";
+        this.__table = "";
+        this.__connection = undefined;
+        this.__hidden = [];
+        this.__unmapped = [];
+        this.__unmappedSystem = [
+            "__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, operator, value) {
+        const model = new this();
+        const queryBuilder = new QueryBuilder_1.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 aggregate(aggregation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = new this();
+            return yield DBConnection_1.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() {
+        const out = {};
+        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() {
+        const out = {};
+        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
+     */
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let status = null;
+            if (this[this.__primaryKey] !== undefined && this[this.__primaryKey]) {
+                // Update
+                status = yield DBConnection_1.DBConnection.execute({
+                    type: "updateOne",
+                    table: this.__table,
+                    primaryKey: this.__primaryKey,
+                    filter: { [this.__primaryKey]: this[this.__primaryKey] },
+                    data: this.getModelData(),
+                });
+            }
+            else {
+                // Insert
+                status = yield DBConnection_1.DBConnection.execute({
+                    type: "insertOne",
+                    table: this.__table,
+                    data: this.getModelData(),
+                });
+            }
+            // onModelSave
+            const driver = yield DBConnection_1.DBConnection.getDriver(this.__connection);
+            return driver.onModelSave(this, status);
+        });
+    }
+    /**
+     * Deletes the object from the database
+     * @returns boolean
+     */
+    delete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this[this.__primaryKey]) {
+                return false;
+            }
+            const queryBuilder = new QueryBuilder_1.QueryBuilder();
+            queryBuilder.setModelMapping(this);
+            queryBuilder.table(this.__table);
+            queryBuilder.where(this.__primaryKey, "=", this[this.__primaryKey]);
+            yield queryBuilder.delete({ mode: "deleteOne" });
+            this.__is_deleted = true;
+            return true;
+        });
+    }
+}
+exports.Model = Model;

package/lib/Database/QueryBuilder.d.ts

@@ -0,0 +1,15 @@
+export declare class QueryBuilder {
+    database: string | null;
+    query: any[];
+    queryTable: string;
+    mode: string;
+    modelMapping: null;
+    setModelMapping(model?: any | null): void;
+    table(table: string): void;
+    where(column: any, operator: any, value: any): void;
+    get(options?: any): Promise<any>;
+    first(options?: any): Promise<any>;
+    delete(options?: {
+        mode: string;
+    }): Promise<boolean>;
+}

package/lib/Database/QueryBuilder.js

@@ -0,0 +1,71 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+const DBConnection_1 = require("./DBConnection");
+class QueryBuilder {
+    constructor() {
+        this.database = null;
+        this.query = [];
+        this.queryTable = "";
+        this.mode = "get";
+        this.modelMapping = null;
+    }
+    setModelMapping(model) {
+        this.modelMapping = model;
+    }
+    table(table) {
+        this.queryTable = table;
+    }
+    where(column, operator, value) {
+        this.query.push({
+            type: "where",
+            column: column,
+            operator: operator,
+            value: value,
+        });
+    }
+    get(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.mode = "get";
+            const result = yield DBConnection_1.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) => DBConnection_1.DBConnection.mapDataToModel(this.modelMapping, el))
+                : result && result.length > 0
+                    ? result
+                    : null;
+        });
+    }
+    first(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.mode = "first";
+            const result = yield DBConnection_1.DBConnection.runQuery(this);
+            if (options && options.disableModelMapping) {
+                return result ? result : null;
+            }
+            return result && this.modelMapping !== null
+                ? DBConnection_1.DBConnection.mapDataToModel(this.modelMapping, result)
+                : null;
+        });
+    }
+    delete(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.mode =
+                options && options.mode === "deleteOne" ? "deleteOne" : "delete";
+            yield DBConnection_1.DBConnection.runQuery(this);
+            return true;
+        });
+    }
+}
+exports.QueryBuilder = QueryBuilder;

package/lib/Router/Request.d.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/lib/Router/Request.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Router/Response.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { ServerResponse } from "http";
+export declare class Response {
+    res?: ServerResponse;
+    /**
+     * Sets the ServerResponse (res) Object (nodejs/http module)
+     * @param res
+     * @returns
+     */
+    setServerResponse(res: ServerResponse): this;
+    /**
+     * Set the http-status-code
+     *
+     * @param status
+     * @returns
+     */
+    status(status: number): Response;
+    /**
+     * Set a header attribute: Content-Type: application/json
+     *
+     * @param type
+     * @param value
+     * @returns
+     */
+    header(type: string, value: string): this;
+    /**
+     * Sends data to the client
+     * Any objects will be stringified to JSON
+     *
+     * @param content
+     */
+    send(content: any): void;
+}

package/lib/Router/Response.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+class Response {
+    /**
+     * Sets the ServerResponse (res) Object (nodejs/http module)
+     * @param res
+     * @returns
+     */
+    setServerResponse(res) {
+        this.res = res;
+        return this;
+    }
+    /**
+     * Set the http-status-code
+     *
+     * @param status
+     * @returns
+     */
+    status(status) {
+        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, value) {
+        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) {
+        var _a, _b, _c;
+        if (typeof content === "object") {
+            (_a = this.res) === null || _a === void 0 ? void 0 : _a.setHeader("Content-Type", "application/json");
+            (_b = this.res) === null || _b === void 0 ? void 0 : _b.write(JSON.stringify(content));
+        }
+        else {
+            (_c = this.res) === null || _c === void 0 ? void 0 : _c.write(content);
+        }
+    }
+}
+exports.Response = Response;

package/lib/Router/Route.d.ts

@@ -0,0 +1,48 @@
+export declare class RouteFacade {
+    tempGroupPrefix: string | null;
+    tempGroupMiddleware: string[] | null;
+    /**
+     * Register a GET-Method
+     *
+     * @param path
+     * @param component
+     * @param options
+     */
+    get(path: string, component: any, options?: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Register a POST-Method
+     *
+     * @param path
+     * @param component
+     * @param options
+     */
+    post(path: string, component: any, options?: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Register a PUT-Method
+     *
+     * @param path
+     * @param component
+     * @param options
+     */
+    put(path: string, component: any, options?: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Register a DELETE-Method
+     *
+     * @param path
+     * @param component
+     * @param options
+     */
+    delete(path: string, component: any, options?: {
+        [key: string]: any;
+    }): void;
+    group(config: {
+        [key: string]: any;
+    }, children: any): void;
+}
+export declare const Route: RouteFacade;

package/lib/Router/Route.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route = exports.RouteFacade = void 0;
+const Router_1 = require("./Router");
+class RouteFacade {
+    constructor() {
+        this.tempGroupPrefix = null;
+        this.tempGroupMiddleware = null;
+    }
+    /**
+     * Register a GET-Method
+     *
+     * @param path
+     * @param component
+     * @param options
+     */
+    get(path, component, options) {
+        Router_1.Router.register("GET", (this.tempGroupPrefix ? this.tempGroupPrefix : "") + path, component, options || this.tempGroupMiddleware
+            ? Object.assign(Object.assign({}, (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, component, options) {
+        Router_1.Router.register("POST", (this.tempGroupPrefix ? this.tempGroupPrefix : "") + path, component, options || this.tempGroupMiddleware
+            ? Object.assign(Object.assign({}, (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, component, options) {
+        Router_1.Router.register("PUT", (this.tempGroupPrefix ? this.tempGroupPrefix : "") + path, component, options || this.tempGroupMiddleware
+            ? Object.assign(Object.assign({}, (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, component, options) {
+        Router_1.Router.register("DELETE", (this.tempGroupPrefix ? this.tempGroupPrefix : "") + path, component, options || this.tempGroupMiddleware
+            ? Object.assign(Object.assign({}, (options ? options : {})), { middleware: this.tempGroupMiddleware || (options && options.middleware)
+                    ? [
+                        ...(this.tempGroupMiddleware
+                            ? this.tempGroupMiddleware
+                            : []),
+                        ...(options && options.middleware
+                            ? options.middleware
+                            : []),
+                    ]
+                    : null }) : {});
+    }
+    group(config, children) {
+        // 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;
+    }
+}
+exports.RouteFacade = RouteFacade;
+exports.Route = new RouteFacade();

package/lib/Router/Router.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from "http";
+type RouteObject = {
+    path: string;
+    component: any;
+    options: {
+        [key: string]: any;
+    };
+    params: object;
+};
+declare 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(): void;
+    /**
+     * Register a route
+     *
+     * @param type
+     * @param path
+     * @param component
+     * @param options
+     */
+    register(type: string, path: string, component: any, options: object): void;
+    /**
+     * Loads the matching route based on the request-url
+     *
+     * @param req
+     * @returns
+     */
+    dissolve(req: IncomingMessage): RouteObject | 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): any;
+    /**
+     * Sends the default 404-Page
+     *
+     * @param res
+     */
+    sendError(res: ServerResponse, code: number, message?: string): void;
+    /**
+     * Processes a request
+     *
+     * @param req
+     * @param res
+     */
+    handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void>;
+}
+export declare const Router: RouterFacade;
+export {};

package/lib/Router/Router.js

@@ -0,0 +1,240 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const qs_1 = __importDefault(require("qs"));
+const Response_1 = require("./Response");
+// @ts-ignore
+const Kernel_1 = require("../../../../../app/Kernel");
+class RouterFacade {
+    constructor() {
+        /**
+         * GET Route Store
+         */
+        this.routesGET = {};
+        /**
+         * POST Route Store
+         */
+        this.routesPOST = {};
+        /**
+         * PUT Route Store
+         */
+        this.routesPUT = {};
+        /**
+         * DELETE Route Store
+         */
+        this.routesDELETE = {};
+    }
+    /**
+     * 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, path, component, options) {
+        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) {
+        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, url) {
+        if (routes[url]) {
+            // If url matches directly -> instant return
+            return Object.assign(Object.assign({}, 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 = {};
+                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 Object.assign(Object.assign({}, routes[path]), { params: params });
+                }
+            }
+        }
+    }
+    /**
+     * Sends the default 404-Page
+     *
+     * @param res
+     */
+    sendError(res, code, message) {
+        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
+     */
+    handleRequest(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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_1.Kernel.middleware[middlewareKey];
+                    if (!middleware) {
+                        return this.sendError(res, 500, "Unknown middleware `" + middlewareKey + "` ...");
+                    }
+                    try {
+                        yield new Promise((resolve, reject) => {
+                            try {
+                                middleware(resolve, (status, data) => {
+                                    reject({ status: status, data: data });
+                                }, req, res);
+                            }
+                            catch (e) {
+                                console.error(e);
+                                return this.sendError(res, 500, "Error in middleware `" + middlewareKey + "` ...");
+                            }
+                        });
+                    }
+                    catch (e) {
+                        // 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_1.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 = [];
+                const bodyPlain = yield new Promise((resolve) => {
+                    req
+                        .on("data", (chunk) => {
+                        body.push(chunk);
+                    })
+                        .on("end", () => {
+                        resolve(Buffer.concat(body).toString());
+                    });
+                });
+                try {
+                    yield route.component({
+                        body: bodyPlain ? qs_1.default.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_1.Response().setServerResponse(res));
+                    res.end();
+                }
+                catch (e) {
+                    console.error(e);
+                    this.sendError(res, 500);
+                }
+            }
+            else {
+                this.sendError(res, 404);
+            }
+        });
+    }
+}
+exports.Router = new RouterFacade();

package/lib/WebApplication.d.ts

@@ -0,0 +1,7 @@
+export declare class WebApplication {
+    private server;
+    /**
+     * Init the routes and start the http-server
+     */
+    boot(): void;
+}

package/lib/WebApplication.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebApplication = void 0;
+const http_1 = __importDefault(require("http"));
+const Router_1 = require("./Router/Router");
+class WebApplication {
+    /**
+     * Init the routes and start the http-server
+     */
+    boot() {
+        Router_1.Router.init();
+        this.server = http_1.default
+            .createServer((req, res) => {
+            Router_1.Router.handleRequest(req, res);
+        })
+            .listen(3000, () => {
+            console.log("Server started and listening on port 3000");
+        });
+    }
+}
+exports.WebApplication = WebApplication;

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./BaseKernel"), exports);
+__exportStar(require("./Controller/Controller"), exports);
+__exportStar(require("./WebApplication"), exports);
+__exportStar(require("./Router/Route"), exports);
+__exportStar(require("./Router/Request"), exports);
+__exportStar(require("./Router/Response"), exports);
+__exportStar(require("./Database/Model"), exports);
+__exportStar(require("./Database/QueryBuilder"), exports);

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@webtypen/webframez-core",
-  "version": "0.0.2",
+  "type": "module",
+  "version": "0.0.4",
   "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
   "homepage": "https://webtypen.de/",
   "license": "MIT",
-  "main": "index.js",
+  "main": "lib/index.js",
   "author": {
     "name": "Benedict Romp",
     "email": "b.romp@webtypen.de",
@@ -17,8 +18,19 @@
     "type": "git",
     "url": "git+https://github.com/webtypen/webframez-core.git"
   },
+  "scripts": {
+    "build": "tsc",
+    "build:check": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "@types/qs": "^6.9.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.3"
+  },
   "dependencies": {
     "dotenv": "^8.2.0",
-    "lodash": "^4.17.20"
+    "lodash": "^4.17.20",
+    "qs": "^6.11.0"
   }
 }

package/src/Database/DBConnection.ts

@@ -1,4 +1,5 @@
 import { DBDrivers } from "./DBDriver";
+// @ts-ignore
 import dbconfig from "../../../../../config/database";
 import { QueryBuilder } from "./QueryBuilder";
 
@@ -39,6 +40,10 @@ class DBConnectionFacade {
       connectionName = dbconfig.defaultConnection;
     }
 
+    if (!connectionName) {
+      return null;
+    }
+
     if (
       this.connections[connectionName] &&
       this.connections[connectionName].driver

package/src/Router/Router.ts

@@ -1,6 +1,7 @@
 import qs from "qs";
 import { IncomingMessage, ServerResponse } from "http";
 import { Response } from "./Response";
+// @ts-ignore
 import { Kernel } from "../../../../../app/Kernel";
 
 type RouteObject = {

package/src/index.ts

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

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "lib": ["es6", "es2016"],
+    "types": ["node"],
+    "declaration": true,
+    "outDir": "lib",
+    "rootDir": "src",
+    "strict": true
+  },
+  "exclude": ["lib", "node_modules", "src/**/*.spec.ts"],
+  "include": ["src"]
+}

package/index.ts

@@ -1,8 +0,0 @@
-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";