@webtypen/webframez-core 0.3.18 → 0.3.20

package/dist/Facades/Storage.d.ts

@@ -119,6 +119,11 @@ declare class StorageFacade {
     }>;
     file(filepath: string): Promise<StorageFileInstance>;
     readDir(dirpath: string, options: StorageReadDirOptions): Promise<any[]>;
+    upload(req: any, options: {
+        storagePath: string;
+        storageFilename: string;
+        payload?: any;
+    }): Promise<boolean>;
 }
 declare class StorageFileFacade {
     storage: StorageFacade;

package/dist/Facades/Storage.js

@@ -198,6 +198,11 @@ class StorageFacade {
             return yield this.disk().readDir(dirpath, options);
         });
     }
+    upload(req, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.disk().driver.upload(req, options);
+        });
+    }
 }
 class StorageFileFacade {
     constructor(storage) {

package/dist/Facades/StorageDrivers/BaseStorageDriver.d.ts

@@ -44,4 +44,9 @@ export interface BaseStorageDriver {
     extension(filepath: string): Promise<string | null>;
     mime(filepath: string): Promise<string | null>;
     readDir(dirpath: string, options?: StorageReadDirOptions): Promise<any[]>;
+    upload(req: any, options: {
+        storagePath: string;
+        storageFilename: string;
+        payload?: any;
+    }): Promise<boolean>;
 }

package/dist/Facades/StorageDrivers/LocalStorageDriver.d.ts

@@ -1,14 +1,15 @@
 /// <reference types="node" />
 import { BaseStorageDriver, StorageDeleteOptions, StorageMkdirOptions, StorageReadDirOptions } from "./BaseStorageDriver";
+import { Request } from "../../Router/Request";
 export declare class LocalStorageDriver implements BaseStorageDriver {
     config: any;
     basepath: string;
     constructor(conf: any);
     path(...args: string[]): string;
-    put(filepath: string, contents: string | Buffer): Promise<{
+    put(filepath: string, contents: string | Buffer, payload?: any): Promise<{
         status: string;
         filepath: string;
-        payload: {};
+        payload: any;
     }>;
     copy(filepath: string, target: string): Promise<{
         status: string;
@@ -38,4 +39,9 @@ export declare class LocalStorageDriver implements BaseStorageDriver {
     extension(filepath: string): Promise<string | null>;
     mime(filepath: string): Promise<string | null>;
     readDir(dirpath: string, options?: StorageReadDirOptions): Promise<string[]>;
+    upload(req: Request, options: {
+        storagePath: string;
+        storageFilename: string;
+        payload?: any;
+    }): Promise<boolean>;
 }

package/dist/Facades/StorageDrivers/LocalStorageDriver.js

@@ -16,6 +16,7 @@ exports.LocalStorageDriver = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const mime_types_1 = __importDefault(require("mime-types"));
+const busboy_1 = __importDefault(require("busboy"));
 const FileFunctions_1 = require("../../Functions/FileFunctions");
 class LocalStorageDriver {
     constructor(conf) {
@@ -25,13 +26,33 @@ class LocalStorageDriver {
     path(...args) {
         return path_1.default.join(this.basepath, ...args);
     }
-    put(filepath, contents) {
+    put(filepath, contents, payload) {
         return __awaiter(this, void 0, void 0, function* () {
-            fs_1.default.writeFileSync(this.path(filepath), contents);
+            const p = this.path(filepath);
+            // @ts-ignore
+            fs_1.default.writeFileSync(p, contents);
+            if (this.config.fileHandlers) {
+                const keys = Object.keys(this.config.fileHandlers);
+                const mime = yield this.mime(p);
+                if (mime) {
+                    const configKey = keys.find((key) => {
+                        if (key.includes("*")) {
+                            const regex = new RegExp("^" + key.replace("*", ".+") + "$");
+                            return regex.test(mime);
+                        }
+                        return key === mime;
+                    });
+                    if (configKey && this.config.fileHandlers[configKey]) {
+                        for (let handler of this.config.fileHandlers[configKey]) {
+                            yield handler(p, contents, payload);
+                        }
+                    }
+                }
+            }
             return {
                 status: "success",
                 filepath: filepath,
-                payload: {},
+                payload: payload,
             };
         });
     }
@@ -124,5 +145,61 @@ class LocalStorageDriver {
             return entries && entries.length > 0 ? entries : [];
         });
     }
+    upload(req, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const busboy = (0, busboy_1.default)({ headers: req.headers });
+            const dir = path_1.default.join((0, FileFunctions_1.storageDir)(), options.storagePath);
+            if (!fs_1.default.existsSync(dir)) {
+                fs_1.default.mkdirSync(dir, { recursive: true });
+            }
+            let hasSuccess = false;
+            const promises = [
+                new Promise((resolve) => {
+                    if (!req.message) {
+                        throw Error("Missing IncomingMessage ...");
+                    }
+                    let fileOptions = null;
+                    let filepath = null;
+                    busboy.on("file", (fieldname, file, options) => __awaiter(this, void 0, void 0, function* () {
+                        if (fileOptions === null && options) {
+                            fileOptions = options;
+                        }
+                        filepath = path_1.default.join(dir, options.storageFilename);
+                        const writeStream = fs_1.default.createWriteStream(filepath);
+                        file.pipe(writeStream);
+                    }));
+                    busboy.on("error", (error, error2) => {
+                        console.error("Busboy error:", error);
+                        resolve(false);
+                    });
+                    busboy.on("finish", () => __awaiter(this, void 0, void 0, function* () {
+                        if (this.config.fileHandlers) {
+                            const keys = Object.keys(this.config.fileHandlers);
+                            const mime = yield this.mime(filepath);
+                            if (mime) {
+                                const configKey = keys.find((key) => {
+                                    if (key.includes("*")) {
+                                        const regex = new RegExp("^" + key.replace("*", ".+") + "$");
+                                        return regex.test(mime);
+                                    }
+                                    return key === mime;
+                                });
+                                if (configKey && this.config.fileHandlers[configKey]) {
+                                    for (let handler of this.config.fileHandlers[configKey]) {
+                                        yield handler(filepath, fs_1.default.readFileSync(filepath), options.payload);
+                                    }
+                                }
+                            }
+                        }
+                        hasSuccess = true;
+                        resolve(true);
+                    }));
+                    req.message.pipe(busboy);
+                }),
+            ];
+            yield Promise.all(promises);
+            return hasSuccess;
+        });
+    }
 }
 exports.LocalStorageDriver = LocalStorageDriver;

package/dist/Router/Router.js

@@ -215,9 +215,9 @@ class RouterFacade {
                         .replace(/\/:\w+\?/g, "(?:/([^/]+))?")
                         .replace(/\/:\w+/g, "/([^/]+)")
                         .replace(/\/\*\*/g, "/(.*)") // Catchall wildcard: /**
-                        .replace(/\/\*/g, "/([^/]*)")
+                        .replace(/\/\*/g, "(?:/(.*))??") // Single wildcard: /* (optional trailing content)
                         .replace(/\*\*/g, "(.*)")
-                        .replace(/\*/g, "([^/]*)")
+                        .replace(/\*/g, "(.*)")
                         .replace(/\//g, "\\/") +
                     "$";
                 const match = url.match(regex);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.3.18",
+    "version": "0.3.20",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",

package/src/Facades/Storage.ts

@@ -170,6 +170,10 @@ class StorageFacade {
     async readDir(dirpath: string, options: StorageReadDirOptions) {
         return await this.disk().readDir(dirpath, options);
     }
+
+    async upload(req: any, options: { storagePath: string; storageFilename: string; payload?: any }) {
+        return await this.disk().driver.upload(req, options);
+    }
 }
 
 class StorageFileFacade {

package/src/Facades/StorageDrivers/BaseStorageDriver.ts

@@ -27,4 +27,5 @@ export interface BaseStorageDriver {
     extension(filepath: string): Promise<string | null>;
     mime(filepath: string): Promise<string | null>;
     readDir(dirpath: string, options?: StorageReadDirOptions): Promise<any[]>;
+    upload(req: any, options: { storagePath: string; storageFilename: string; payload?: any }): Promise<boolean>;
 }

package/src/Facades/StorageDrivers/LocalStorageDriver.ts

@@ -1,8 +1,10 @@
 import fs from "fs";
 import path from "path";
 import mime from "mime-types";
+import Busboy from "busboy";
 import { BaseStorageDriver, StorageDeleteOptions, StorageMkdirOptions, StorageReadDirOptions } from "./BaseStorageDriver";
 import { storageDir } from "../../Functions/FileFunctions";
+import { Request } from "../../Router/Request";
 
 export class LocalStorageDriver implements BaseStorageDriver {
     config: any;
@@ -17,13 +19,35 @@ export class LocalStorageDriver implements BaseStorageDriver {
         return path.join(this.basepath, ...args);
     }
 
-    async put(filepath: string, contents: string | Buffer) {
-        fs.writeFileSync(this.path(filepath), contents);
+    async put(filepath: string, contents: string | Buffer, payload?: any) {
+        const p = this.path(filepath);
+        // @ts-ignore
+        fs.writeFileSync(p, contents);
+
+        if (this.config.fileHandlers) {
+            const keys = Object.keys(this.config.fileHandlers);
+            const mime = await this.mime(p);
+            if (mime) {
+                const configKey = keys.find((key) => {
+                    if (key.includes("*")) {
+                        const regex = new RegExp("^" + key.replace("*", ".+") + "$");
+                        return regex.test(mime);
+                    }
+                    return key === mime;
+                });
+
+                if (configKey && this.config.fileHandlers[configKey]) {
+                    for (let handler of this.config.fileHandlers[configKey]) {
+                        await handler(p, contents, payload);
+                    }
+                }
+            }
+        }
 
         return {
             status: "success",
             filepath: filepath,
-            payload: {},
+            payload: payload,
         };
     }
 
@@ -107,4 +131,68 @@ export class LocalStorageDriver implements BaseStorageDriver {
         const entries = fs.readdirSync(this.path(dirpath));
         return entries && entries.length > 0 ? entries : [];
     }
+
+    async upload(req: Request, options: { storagePath: string; storageFilename: string; payload?: any }) {
+        const busboy = Busboy({ headers: req.headers });
+        const dir = path.join(storageDir(), options.storagePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+
+        let hasSuccess = false;
+        const promises = [
+            new Promise((resolve) => {
+                if (!req.message) {
+                    throw Error("Missing IncomingMessage ...");
+                }
+
+                let fileOptions: any = null;
+                let filepath: any = null;
+                busboy.on("file", async (fieldname: any, file: any, options: any) => {
+                    if (fileOptions === null && options) {
+                        fileOptions = options;
+                    }
+
+                    filepath = path.join(dir, options.storageFilename);
+                    const writeStream = fs.createWriteStream(filepath);
+                    file.pipe(writeStream);
+                });
+
+                busboy.on("error", (error: any, error2: any) => {
+                    console.error("Busboy error:", error);
+                    resolve(false);
+                });
+
+                busboy.on("finish", async () => {
+                    if (this.config.fileHandlers) {
+                        const keys = Object.keys(this.config.fileHandlers);
+                        const mime = await this.mime(filepath);
+                        if (mime) {
+                            const configKey = keys.find((key) => {
+                                if (key.includes("*")) {
+                                    const regex = new RegExp("^" + key.replace("*", ".+") + "$");
+                                    return regex.test(mime);
+                                }
+                                return key === mime;
+                            });
+
+                            if (configKey && this.config.fileHandlers[configKey]) {
+                                for (let handler of this.config.fileHandlers[configKey]) {
+                                    await handler(filepath, fs.readFileSync(filepath), options.payload);
+                                }
+                            }
+                        }
+                    }
+
+                    hasSuccess = true;
+                    resolve(true);
+                });
+
+                req.message.pipe(busboy);
+            }),
+        ];
+        await Promise.all(promises);
+
+        return hasSuccess;
+    }
 }

package/src/Router/Router.ts

@@ -246,9 +246,9 @@ class RouterFacade {
                         .replace(/\/:\w+\?/g, "(?:/([^/]+))?")
                         .replace(/\/:\w+/g, "/([^/]+)")
                         .replace(/\/\*\*/g, "/(.*)") // Catchall wildcard: /**
-                        .replace(/\/\*/g, "/([^/]*)")
+                        .replace(/\/\*/g, "(?:/(.*))??") // Single wildcard: /* (optional trailing content)
                         .replace(/\*\*/g, "(.*)")
-                        .replace(/\*/g, "([^/]*)")
+                        .replace(/\*/g, "(.*)")
                         .replace(/\//g, "\\/") +
                     "$";
                 const match = url.match(regex);