@webtypen/webframez-core 0.0.62 → 0.1.1

package/dev/README.md

@@ -0,0 +1,6 @@
+### Run server for local dev
+
+```bash
+$ npm install
+```
+

package/dev/app.ts

@@ -0,0 +1,93 @@
+import fs from "fs";
+import path from "path";
+import Busboy from "busboy";
+import { WebApplication } from "../src/WebApplication";
+import { BaseKernelWeb } from "../src/BaseKernelWeb";
+import { Route } from "../src/Router/Route";
+import { Request } from "../src/Router/Request";
+import { Response } from "../src/Router/Response";
+
+class Kernel extends BaseKernelWeb {
+    static controller: { [key: string]: any } = {};
+    static middleware: { [key: string]: any } = {};
+}
+
+const app = new WebApplication();
+app.boot({
+    kernel: Kernel,
+    config: {
+        application: {},
+        database: {},
+    },
+    port: process.env.PORT ? process.env.PORT : 3000,
+    basename: process.env.BASENAME ? process.env.BASENAME : null,
+    routesFunction: () => {
+        Route.group({ prefix: "/main", middleware: [] }, () => {
+            Route.group({ prefix: "/test", middleware: [] }, () => {
+                Route.get("/:test/details", (req: Request, res: Response) => {
+                    res.send({
+                        status: "success",
+                    });
+                });
+            });
+        });
+
+        Route.post("/fileupload", (req: Request, res: Response) => {
+            if (!req.message) {
+                throw Error("Missing IncomingMessage ...");
+            }
+
+            const busboy = Busboy({ headers: req.headers, limits: { fileSize: 10 * 1024 * 1024 } }); // 10MB Limit
+            busboy.on("file", (fieldname: any, file: any, options: any) => {
+                console.log(`Uploading:`, options);
+
+                const saveTo = path.join(__dirname, "uploads", options.filename);
+                file.pipe(fs.createWriteStream(saveTo));
+
+                file.on("data", (data: any) => {
+                    console.log(`Received ${data.length} bytes for ${options.filename}`);
+                });
+
+                file.on("end", () => {
+                    console.log(`${options.filename} upload complete.`);
+                });
+
+                file.on("error", (err: any) => {
+                    console.error(`Error uploading ${options.filename}:`, err);
+                });
+            });
+
+            busboy.on("finish", () => {
+                console.log("Upload complete.");
+            });
+
+            busboy.on("error", (err: any) => {
+                console.error("Error occurred during file upload:", err);
+            });
+
+            req.message.pipe(busboy); // Verwendet das native req-Objekt
+        });
+    },
+});
+
+function getBoundary(contentType: string) {
+    const match = contentType.match(/boundary=(.+)$/);
+    return match ? `--${match[1]}` : null;
+}
+
+function parseHeaders(headerPart: string) {
+    const headers: { [key: string]: string } = {};
+    const lines = headerPart.split("\r\n");
+    lines.forEach((line) => {
+        const parts = line.split(":");
+        if (parts.length === 2) {
+            headers[parts[0].trim()] = parts[1].trim();
+        }
+    });
+    return headers;
+}
+
+function getFilename(contentDisposition: string) {
+    const match = contentDisposition.match(/filename="(.+?)"/);
+    return match ? match[1] : null;
+}

package/{lib → dist}/LambdaApplication.d.ts

@@ -2,11 +2,11 @@ export declare class LambdaApplication {
     /**
      * Init the routes and handle the request
      */
-    boot(event: any, context: any, options?: any): Promise<void | {
+    boot(event: any, context: any, options?: any): Promise<{
         statusCode: number;
         body: any;
         headers: {
             [key: string]: any;
         };
-    }>;
+    } | undefined>;
 }

package/dist/Router/Request.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+export declare class Request {
+    [key: string]: any;
+    method: string;
+    url: string;
+    headers: any;
+    rawHeaders: any;
+    body: any;
+    bodyPlain: any;
+    query: any;
+    params: any;
+    files: any;
+    socket: any;
+    message: IncomingMessage | null;
+    skipOptionsForward: boolean;
+    /**
+     * Prevent the options request from getting an automatic 200 status code
+     * @param status
+     * @returns Response
+     */
+    setSkipOptionsForward(status: boolean): this;
+}

package/dist/Router/Request.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Request = void 0;
+class Request {
+    constructor() {
+        this.method = "GET";
+        this.url = "";
+        this.headers = {};
+        this.rawHeaders = {};
+        this.body = null;
+        this.bodyPlain = null;
+        this.query = {};
+        this.params = {};
+        this.files = {};
+        this.socket = undefined;
+        this.message = null;
+        this.skipOptionsForward = false;
+    }
+    /**
+     * Prevent the options request from getting an automatic 200 status code
+     * @param status
+     * @returns Response
+     */
+    setSkipOptionsForward(status) {
+        this.skipOptionsForward = status;
+        return this;
+    }
+}
+exports.Request = Request;

package/{lib → dist}/Router/Response.d.ts

@@ -8,18 +8,11 @@ export declare class Response {
         [key: string]: any;
     };
     events: any;
-    autoEnd: boolean;
     /**
      * Mode
      */
     mode: any | null;
     constructor(options?: any | null | undefined);
-    /**
-     * Set Response-Auto-End
-     * @param status
-     * @returns Response
-     */
-    setAutoEnd(status: boolean): this;
     /**
      * Sets the ServerResponse (res) Object (nodejs/http module)
      * @param res
@@ -49,6 +42,7 @@ export declare class Response {
      * @returns Response
      */
     send(content: any): this;
+    end(): this;
     registerEvent(eventKey: string, func: any): Promise<void>;
     /**
      * Runs the registered events for an event-type

package/{lib → dist}/Router/Response.js

@@ -15,22 +15,12 @@ class Response {
         this.statusCode = 200;
         this.headers = {};
         this.events = { after: [] };
-        this.autoEnd = true;
         /**
          * Mode
          */
         this.mode = null;
         this.mode = options && options.mode ? options.mode : null;
     }
-    /**
-     * Set Response-Auto-End
-     * @param status
-     * @returns Response
-     */
-    setAutoEnd(status) {
-        this.autoEnd = status;
-        return this;
-    }
     /**
      * Sets the ServerResponse (res) Object (nodejs/http module)
      * @param res
@@ -77,22 +67,29 @@ class Response {
      * @returns Response
      */
     send(content) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         this.content = content;
         if (this.mode === "aws-lambda") {
             // Do nothing ... Store content in variable and use it later ...
         }
         else {
             if (typeof content === "object" && !Buffer.isBuffer(content)) {
-                (_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));
+                if (!((_a = this.res) === null || _a === void 0 ? void 0 : _a.headersSent)) {
+                    (_b = this.res) === null || _b === void 0 ? void 0 : _b.setHeader("Content-Type", "application/json");
+                }
+                (_c = this.res) === null || _c === void 0 ? void 0 : _c.write(JSON.stringify(content));
             }
             else {
-                (_c = this.res) === null || _c === void 0 ? void 0 : _c.write(content);
+                (_d = this.res) === null || _d === void 0 ? void 0 : _d.write(content);
             }
         }
         return this;
     }
+    end() {
+        var _a;
+        (_a = this.res) === null || _a === void 0 ? void 0 : _a.end();
+        return this;
+    }
     registerEvent(eventKey, func) {
         return __awaiter(this, void 0, void 0, function* () {
             this.events[eventKey].push({ function: func });

package/{lib → dist}/Router/Router.d.ts

@@ -1,8 +1,12 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse } from "http";
+import { Response } from "./Response";
+import { Request } from "./Request";
 type RouteObject = {
     path: string;
-    component: any;
+    component?: any;
+    controller?: any;
+    method_name?: string;
     options: {
         [key: string]: any;
     };
@@ -67,9 +71,17 @@ declare class RouterFacade {
     };
     /**
      * Load the application-routes
-     *
      */
     init(options?: any): void;
+    /**
+     * Dissolves 'MyController@myFunction'
+     *
+     * @param str
+     */
+    dissolveStringComponent(str: string, path: string): {
+        controller: any;
+        method_name: string;
+    };
     /**
      * Register a route
      *
@@ -85,7 +97,14 @@ declare class RouterFacade {
      * @param req
      * @returns
      */
-    dissolve(req: IncomingMessage | any | null): RouteObject | null;
+    dissolve(req: Request): RouteObject | null;
+    /**
+     * Extrahiert die Parameterwerte aus einer URL basierend auf einem Routenpfad.
+     * @param {string} path - Der Routenpfad.
+     * @param {Array} match - Das Match-Array des regulären Ausdrucks.
+     * @returns {Object} - Ein Objekt mit den extrahierten Parametern.
+     */
+    extractParams(path: string, match: any): any;
     /**
      * Dissolves the matching route based on the request-url and an object of routes
      *
@@ -93,32 +112,37 @@ declare class RouterFacade {
      * @param url
      * @returns
      */
-    dissolveRoute(routes: any, url: string): any;
-    /**
-     * Sends the default 404-Page
-     *
-     * @param res
-     */
-    sendError(res: ServerResponse, code: number, message?: string): void;
-    /**
-     * Parses JSON without exception
-     */
-    parseJson(jsonObject: any): any;
+    dissolveRoute(routes: any, url: string, request?: Request): any;
     /**
      * Processes a request
      *
      * @param req
      * @param res
      */
-    handleRequest(req: null | IncomingMessage, res: null | ServerResponse, options?: any): Promise<void | {
+    handleRequest(req: null | IncomingMessage, res: null | ServerResponse, options?: any): Promise<{
+        statusCode: number;
+        body: any;
+        headers: {
+            [key: string]: any;
+        };
+    } | undefined>;
+    handleMiddleware(route: RouteObject, request: Request, response: Response): Promise<void>;
+    mapRequest(req: null | IncomingMessage, options?: any): Promise<Request>;
+    parseRequestBody(req: IncomingMessage): Promise<unknown>;
+    handleReturn(request: Request, response: Response, body: any): {
+        statusCode: number;
+        body: any;
+        headers: {
+            [key: string]: any;
+        };
+    } | undefined;
+    handleError(request: Request, response: Response, statusCode: number, error: Error | string): {
         statusCode: number;
         body: any;
         headers: {
             [key: string]: any;
         };
-    }>;
-    handleResponseAfter(response: any, req: any, payload: any): Promise<void>;
-    requestConsoleLog(req: IncomingMessage, httpCode: number): void;
+    } | undefined;
 }
 export declare const Router: RouterFacade;
 export {};