@webtypen/webframez-core 0.3.30 → 0.3.32

package/dev/storage/test-storage-check/a.txt

@@ -0,0 +1 @@
+hello

package/dist/BaseKernelWeb.js

@@ -5,3 +5,4 @@ class BaseKernelWeb {
 }
 exports.BaseKernelWeb = BaseKernelWeb;
 BaseKernelWeb.controller = {};
+BaseKernelWeb.middleware = {};

package/dist/Commands/ConsoleCommand.js

@@ -16,6 +16,7 @@ exports.ConsoleCommand = void 0;
 const readline_1 = __importDefault(require("readline"));
 const ConsoleProgressBar_1 = require("./ConsoleProgressBar");
 const ConsoleOutputHelper_1 = require("./ConsoleOutputHelper");
+const ErrorHandler_1 = require("../ErrorHandling/ErrorHandler");
 class ConsoleCommand {
     constructor(args) {
         this.rl = null;
@@ -41,7 +42,15 @@ class ConsoleCommand {
                 yield this.handle();
             }
             catch (e) {
-                console.error(e);
+                yield ErrorHandler_1.ErrorHandler.report(e, {
+                    scope: "command",
+                    source: "console.command.handleSystem",
+                    command: {
+                        signature: this.constructor.signature,
+                        className: this.constructor.name,
+                        args: this.args,
+                    },
+                });
             }
             finally {
                 yield this.finallySystem();

package/dist/Commands/QueueStopCommand.js

@@ -63,7 +63,7 @@ class QueueStopCommand extends ConsoleCommand_1.ConsoleCommand {
             let promises = [];
             for (let worker of stopping) {
                 if (!worker || !worker.worker || !worker.pid)
-                    return;
+                    continue;
                 promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
                     try {
                         yield this.stopWorker(worker.worker, worker.pid);

package/dist/Commands/QueueWorkerCommand.js

@@ -23,6 +23,7 @@ const StringFunctions_1 = require("../Functions/StringFunctions");
 const Config_1 = require("../Config");
 const DBConnection_1 = require("../Database/DBConnection");
 const DateFunctions_1 = require("../Functions/DateFunctions");
+const ErrorHandler_1 = require("../ErrorHandling/ErrorHandler");
 class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
     constructor() {
         super(...arguments);
@@ -70,6 +71,18 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                 yield this.run();
             }
             catch (e) {
+                yield ErrorHandler_1.ErrorHandler.report(e, {
+                    scope: "command",
+                    source: "queue.worker.run",
+                    command: {
+                        signature: this.constructor.signature,
+                        className: this.constructor.name,
+                        args: this.args,
+                    },
+                    metadata: {
+                        worker: this.workerKey,
+                    },
+                });
                 this.error(`Queue run failed: ${e instanceof Error ? e.message : String(e)}`);
             }
             finally {
@@ -354,7 +367,18 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                 }
             }
             catch (e) {
-                console.error(e);
+                yield ErrorHandler_1.ErrorHandler.report(e, {
+                    scope: "command",
+                    source: "queue.worker.automation",
+                    command: {
+                        signature: this.constructor.signature,
+                        className: this.constructor.name,
+                        args: this.args,
+                    },
+                    metadata: {
+                        worker: this.workerKey,
+                    },
+                });
             }
         });
     }
@@ -500,6 +524,19 @@ class QueueWorkerCommand extends ConsoleCommand_1.ConsoleCommand {
                     this.log(`Finished Job #${job.number} - ${job.jobclass} - ${(job.executions[0].duration_ms / 1000).toFixed(2)}s`);
                 }
                 catch (e) {
+                    yield ErrorHandler_1.ErrorHandler.report(e, {
+                        scope: "job",
+                        source: "queue.worker.job.handle",
+                        job: {
+                            id: job && job._id ? job._id.toString() : undefined,
+                            number: job && job.number ? job.number : undefined,
+                            jobclass: job && job.jobclass ? job.jobclass : undefined,
+                            worker: this.workerKey,
+                        },
+                        metadata: {
+                            executionKey: executionKey,
+                        },
+                    });
                     const errorMessage = e instanceof Error ? e.stack || e.message : String(e);
                     const endedAt = new Date();
                     job.status = "failed";

package/dist/ConsoleApplication.js

@@ -23,6 +23,7 @@ const QueueStopCommand_1 = require("./Commands/QueueStopCommand");
 const QueueLogCommand_1 = require("./Commands/QueueLogCommand");
 const QueueWorkerAutorestartCommand_1 = require("./Commands/QueueWorkerAutorestartCommand");
 const info_1 = require("./info");
+const ErrorHandler_1 = require("./ErrorHandling/ErrorHandler");
 class ConsoleApplication {
     constructor() {
         this.systemCommands = [
@@ -44,6 +45,14 @@ class ConsoleApplication {
                 Config_1.Config.register(key, options.config[key]);
             }
         }
+        if (options && options.errorHandler) {
+            if (Array.isArray(options.errorHandler)) {
+                ErrorHandler_1.ErrorHandler.setHandlers(options.errorHandler);
+            }
+            else {
+                ErrorHandler_1.ErrorHandler.setHandler(options.errorHandler);
+            }
+        }
         // if (options && options.signoz) {
         //     void SigNozTelemetry.init(options.signoz);
         // }
@@ -62,10 +71,23 @@ class ConsoleApplication {
                 return;
             }
             (() => __awaiter(this, void 0, void 0, function* () {
-                const commandInstance = new command(args);
-                yield commandInstance.handleSystem();
-                if (options && options.onEnd) {
-                    yield options.onEnd(command.signature);
+                try {
+                    const commandInstance = new command(args);
+                    yield commandInstance.handleSystem();
+                    if (options && options.onEnd) {
+                        yield options.onEnd(command.signature);
+                    }
+                }
+                catch (e) {
+                    yield ErrorHandler_1.ErrorHandler.report(e, {
+                        scope: "command",
+                        source: "console.application.boot",
+                        command: {
+                            signature: command.signature,
+                            className: command.name,
+                            args: args,
+                        },
+                    });
                 }
             }))();
         }

package/dist/DataBuilder/DataBuilder.js

@@ -199,6 +199,19 @@ class DataBuilder {
                     newData.forms = {};
                     if (typeof type.forms === "function") {
                         newData.forms = yield type.forms(req);
+                        if (newData === null || newData === void 0 ? void 0 : newData.forms) {
+                            for (let form in newData.forms) {
+                                if (typeof newData.forms[form].pageActions === "function") {
+                                    newData.forms[form].pageActions = yield newData.forms[form].pageActions(req);
+                                }
+                                if (typeof newData.forms[form].fields === "function") {
+                                    newData.forms[form].fields = yield newData.forms[form].fields(req);
+                                }
+                                if (typeof newData.forms[form].backLink === "function") {
+                                    newData.forms[form].backLink = yield newData.forms[form].backLink(req);
+                                }
+                            }
+                        }
                     }
                     for (let form in type.forms) {
                         if (!type.forms[form] || !type.forms[form].fields) {

package/dist/ErrorHandling/ErrorHandler.d.ts

@@ -0,0 +1,46 @@
+export type WebframezErrorScope = "controller" | "command" | "job";
+export type WebframezErrorContext = {
+    scope: WebframezErrorScope;
+    source?: string;
+    metadata?: {
+        [key: string]: any;
+    };
+    command?: {
+        signature?: string;
+        className?: string;
+        args?: {
+            arguments: string[];
+            options: {
+                [key: string]: boolean | string;
+            };
+        };
+    };
+    controller?: {
+        routePath?: string;
+        method?: string;
+        url?: string;
+    };
+    job?: {
+        id?: string;
+        number?: number;
+        jobclass?: string;
+        worker?: string | null;
+    };
+};
+export type WebframezErrorEvent = WebframezErrorContext & {
+    timestamp: Date;
+    error: Error;
+    originalError: any;
+};
+export type WebframezGlobalErrorHandler = (event: WebframezErrorEvent) => void | Promise<void>;
+declare class ErrorHandlerFacade {
+    private handlers;
+    private normalizeToError;
+    setHandler(handler: WebframezGlobalErrorHandler | null | undefined): this;
+    setHandlers(handlers: WebframezGlobalErrorHandler[] | null | undefined): this;
+    addHandler(handler: WebframezGlobalErrorHandler | null | undefined): this;
+    clearHandlers(): this;
+    report(error: any, context: WebframezErrorContext): Promise<void>;
+}
+export declare const ErrorHandler: ErrorHandlerFacade;
+export {};

package/dist/ErrorHandling/ErrorHandler.js

@@ -0,0 +1,79 @@
+"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.ErrorHandler = void 0;
+class ErrorHandlerFacade {
+    constructor() {
+        this.handlers = [];
+    }
+    normalizeToError(error) {
+        if (error instanceof Error) {
+            return error;
+        }
+        if (typeof error === "string") {
+            return new Error(error);
+        }
+        try {
+            return new Error(JSON.stringify(error));
+        }
+        catch (e) {
+            return new Error(String(error));
+        }
+    }
+    setHandler(handler) {
+        this.handlers = [];
+        if (handler && typeof handler === "function") {
+            this.handlers.push(handler);
+        }
+        return this;
+    }
+    setHandlers(handlers) {
+        this.handlers = [];
+        if (handlers && Array.isArray(handlers) && handlers.length > 0) {
+            for (const handler of handlers) {
+                if (handler && typeof handler === "function") {
+                    this.handlers.push(handler);
+                }
+            }
+        }
+        return this;
+    }
+    addHandler(handler) {
+        if (handler && typeof handler === "function") {
+            this.handlers.push(handler);
+        }
+        return this;
+    }
+    clearHandlers() {
+        this.handlers = [];
+        return this;
+    }
+    report(error, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const normalizedError = this.normalizeToError(error);
+            const event = Object.assign({ timestamp: new Date(), error: normalizedError, originalError: error }, context);
+            if (!this.handlers || this.handlers.length < 1) {
+                console.error(normalizedError);
+                return;
+            }
+            for (const handler of this.handlers) {
+                try {
+                    yield handler(event);
+                }
+                catch (handlerError) {
+                    const handlerErrorMessage = this.normalizeToError(handlerError);
+                    console.error("[webframez:error-handler] Handler failed:", handlerErrorMessage);
+                }
+            }
+        });
+    }
+}
+exports.ErrorHandler = new ErrorHandlerFacade();

package/dist/Facades/Storage.d.ts

@@ -19,11 +19,7 @@ declare class StorageFileInstance {
         filepath: string | string[];
         payload?: any;
     }>;
-    extension(options?: StorageDeleteOptions): Promise<{
-        status: string;
-        filepath: string | string[];
-        payload?: any;
-    }>;
+    extension(): Promise<string | null>;
     mime(): Promise<string | null>;
 }
 declare class StorageDisk {
@@ -59,16 +55,8 @@ declare class StorageDisk {
         dirpath: string;
         payload?: any;
     }>;
-    isDir(filepath: string): Promise<{
-        status: string;
-        dirpath: string;
-        payload?: any;
-    }>;
-    isFile(filepath: string): Promise<{
-        status: string;
-        dirpath: string;
-        payload?: any;
-    }>;
+    isDir(filepath: string): Promise<boolean>;
+    isFile(filepath: string): Promise<boolean>;
     file(filepath: string): Promise<StorageFileInstance>;
     readDir(dirpath: string, options: StorageReadDirOptions): Promise<any[]>;
 }
@@ -107,16 +95,8 @@ declare class StorageFacade {
         dirpath: string;
         payload?: any;
     }>;
-    isDir(filepath: string): Promise<{
-        status: string;
-        dirpath: string;
-        payload?: any;
-    }>;
-    isFile(filepath: string): Promise<{
-        status: string;
-        dirpath: string;
-        payload?: any;
-    }>;
+    isDir(filepath: string): Promise<boolean>;
+    isFile(filepath: string): Promise<boolean>;
     file(filepath: string): Promise<StorageFileInstance>;
     readDir(dirpath: string, options: StorageReadDirOptions): Promise<any[]>;
     upload(req: any, options: {
@@ -128,6 +108,7 @@ declare class StorageFacade {
 declare class StorageFileFacade {
     storage: StorageFacade;
     constructor(storage: StorageFacade);
+    private createFileInstance;
     exists(filepath: string, diskKey?: string): Promise<boolean>;
     isDir(filepath: string, diskKey?: string): Promise<boolean>;
     isFile(filepath: string, diskKey?: string): Promise<boolean>;
@@ -136,11 +117,7 @@ declare class StorageFileFacade {
         filepath: string | string[];
         payload?: any;
     }>;
-    extension(filepath: string, diskKey?: string): Promise<{
-        status: string;
-        filepath: string | string[];
-        payload?: any;
-    }>;
+    extension(filepath: string, diskKey?: string): Promise<string | null>;
     mime(filepath: string, diskKey?: string): Promise<string | null>;
 }
 export declare const Storage: StorageFacade;

package/dist/Facades/Storage.js

@@ -49,9 +49,9 @@ class StorageFileInstance {
             return this.driver.delete(this.filepath, options);
         });
     }
-    extension(options) {
+    extension() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.driver.delete(this.filepath, options);
+            return this.driver.extension(this.filepath);
         });
     }
     mime() {
@@ -116,14 +116,14 @@ class StorageDisk {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.driver)
                 throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
-            return yield this.driver.mkdir(filepath);
+            return yield this.driver.isDir(filepath);
         });
     }
     isFile(filepath) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.driver)
                 throw new Error(`[STORAGE ERROR] No driver configured for disk '${this.diskKey}'.`);
-            return yield this.driver.mkdir(filepath);
+            return yield this.driver.isFile(filepath);
         });
     }
     file(filepath) {
@@ -209,34 +209,38 @@ class StorageFileFacade {
     constructor(storage) {
         this.storage = storage;
     }
+    createFileInstance(filepath, diskKey) {
+        const disk = this.storage.disk(diskKey);
+        return new StorageFileInstance(filepath, disk.driver);
+    }
     exists(filepath, diskKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).exists();
+            return this.createFileInstance(filepath, diskKey).exists();
         });
     }
     isDir(filepath, diskKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).isDir();
+            return this.createFileInstance(filepath, diskKey).isDir();
         });
     }
     isFile(filepath, diskKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).isFile();
+            return this.createFileInstance(filepath, diskKey).isFile();
         });
     }
     delete(filepath, options, diskKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).delete(options);
+            return this.createFileInstance(filepath, diskKey).delete(options);
         });
     }
     extension(filepath, diskKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).extension();
+            return this.createFileInstance(filepath, diskKey).extension();
         });
     }
     mime(filepath, diskKey) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new StorageFileInstance(filepath, this.storage.disk(diskKey)).mime();
+            return this.createFileInstance(filepath, diskKey).mime();
         });
     }
 }

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

@@ -6,6 +6,7 @@ export declare class LocalStorageDriver implements BaseStorageDriver {
     basepath: string;
     constructor(conf: any);
     path(...args: string[]): string;
+    private resolveHandlers;
     put(filepath: string, contents: string | Buffer, payload?: any): Promise<{
         status: string;
         filepath: string;

package/dist/Facades/StorageDrivers/LocalStorageDriver.js

@@ -26,8 +26,26 @@ class LocalStorageDriver {
     path(...args) {
         return path_1.default.join(this.basepath, ...args);
     }
+    resolveHandlers(entry) {
+        if (!entry) {
+            return [];
+        }
+        if (typeof entry === "function") {
+            return [entry];
+        }
+        if (Array.isArray(entry)) {
+            return entry.filter((handler) => typeof handler === "function");
+        }
+        if (entry.handlers) {
+            const handlers = Array.isArray(entry.handlers) ? entry.handlers : Object.values(entry.handlers);
+            return handlers.filter((handler) => typeof handler === "function");
+        }
+        if (typeof entry === "object") {
+            return Object.values(entry).filter((handler) => typeof handler === "function");
+        }
+        return [];
+    }
     put(filepath, contents, payload) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const p = this.path(filepath);
             // @ts-ignore
@@ -43,12 +61,10 @@ class LocalStorageDriver {
                         }
                         return key === mime;
                     });
-                    if (configKey && ((_a = this.config.fileHandlers[configKey]) === null || _a === void 0 ? void 0 : _a.handlers)) {
-                        for (let handlerKey in this.config.fileHandlers[configKey].handlers) {
-                            const handler = this.config.fileHandlers[configKey].handlers[handlerKey];
-                            if (typeof handler === "function") {
-                                yield handler(p, contents, payload);
-                            }
+                    if (configKey) {
+                        const handlers = this.resolveHandlers(this.config.fileHandlers[configKey]);
+                        for (const handler of handlers) {
+                            yield handler(p, contents, payload);
                         }
                     }
                 }
@@ -164,9 +180,9 @@ class LocalStorageDriver {
                     }
                     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;
+                    busboy.on("file", (fieldname, file, opts) => __awaiter(this, void 0, void 0, function* () {
+                        if (fileOptions === null && opts) {
+                            fileOptions = opts;
                         }
                         filepath = path_1.default.join(dir, options.storageFilename);
                         const writeStream = fs_1.default.createWriteStream(filepath);
@@ -188,8 +204,9 @@ class LocalStorageDriver {
                                     }
                                     return key === mime;
                                 });
-                                if (configKey && this.config.fileHandlers[configKey]) {
-                                    for (let handler of this.config.fileHandlers[configKey]) {
+                                if (configKey) {
+                                    const handlers = this.resolveHandlers(this.config.fileHandlers[configKey]);
+                                    for (const handler of handlers) {
                                         yield handler(filepath, fs_1.default.readFileSync(filepath), options.payload);
                                     }
                                 }

package/dist/LambdaApplication.js

@@ -5,6 +5,7 @@ const Config_1 = require("./Config");
 const DatatableRegistry_1 = require("./Datatable/DatatableRegistry");
 const QueueJobsRegisty_1 = require("./Queue/QueueJobsRegisty");
 const Router_1 = require("./Router/Router");
+const ErrorHandler_1 = require("./ErrorHandling/ErrorHandler");
 class LambdaApplication {
     /**
      * Init the routes and handle the request
@@ -15,6 +16,14 @@ class LambdaApplication {
                 Config_1.Config.register(key, options.config[key]);
             }
         }
+        if (options && options.errorHandler) {
+            if (Array.isArray(options.errorHandler)) {
+                ErrorHandler_1.ErrorHandler.setHandlers(options.errorHandler);
+            }
+            else {
+                ErrorHandler_1.ErrorHandler.setHandler(options.errorHandler);
+            }
+        }
         Router_1.Router.init({
             mode: "aws-lambda",
             kernel: options && options.kernel ? options.kernel : null,

package/dist/Queue/QueueJobsRegisty.d.ts

@@ -1,6 +1,10 @@
 declare class QueueJobsRegistyFacade {
     private jobs;
+    private registeredByKey;
+    private registeredByReference;
     getJobs(): any[];
+    private getJobKey;
+    private addJob;
     registerJob(data: any): this;
 }
 export declare const QueueJobsRegisty: QueueJobsRegistyFacade;

package/dist/Queue/QueueJobsRegisty.js

@@ -4,18 +4,51 @@ exports.QueueJobsRegisty = void 0;
 class QueueJobsRegistyFacade {
     constructor() {
         this.jobs = [];
+        this.registeredByKey = {};
+        this.registeredByReference = new Set();
     }
     getJobs() {
         return this.jobs;
     }
+    getJobKey(job) {
+        if (!job) {
+            return null;
+        }
+        if (typeof job === "function" && job.name && job.name.trim() !== "") {
+            return "function:" + job.name.trim();
+        }
+        if (job.name && typeof job.name === "string" && job.name.trim() !== "") {
+            return "name:" + job.name.trim();
+        }
+        return null;
+    }
+    addJob(job) {
+        if (!job) {
+            return;
+        }
+        const key = this.getJobKey(job);
+        if (key) {
+            if (this.registeredByKey[key]) {
+                return;
+            }
+            this.registeredByKey[key] = true;
+            this.jobs.push(job);
+            return;
+        }
+        if (this.registeredByReference.has(job)) {
+            return;
+        }
+        this.registeredByReference.add(job);
+        this.jobs.push(job);
+    }
     registerJob(data) {
         if (Array.isArray(data)) {
             for (let el of data) {
-                this.jobs.push(el);
+                this.addJob(el);
             }
         }
         else {
-            this.jobs.push(data);
+            this.addJob(data);
         }
         return this;
     }

package/dist/Router/Router.d.ts

@@ -12,6 +12,10 @@ type RouteObject = {
     };
     params: object;
 };
+type MiddlewareRejectSignal = {
+    __middlewareReject: true;
+    reason?: any;
+};
 declare class RouterFacade {
     /**
      * Basename
@@ -25,6 +29,7 @@ declare class RouterFacade {
      * Mode
      */
     mode: any | null;
+    maxRequestBodySizeBytes: number | null;
     /**
      * GET Route Store
      */
@@ -105,6 +110,10 @@ declare class RouterFacade {
      * @returns {Object} - Ein Objekt mit den extrahierten Parametern.
      */
     extractParams(path: string, match: any): any;
+    escapeRegexPart(value: string): string;
+    buildRouteRegex(path: string): RegExp;
+    createMiddlewareRejectSignal(reason?: any): MiddlewareRejectSignal;
+    isMiddlewareRejectSignal(error: any): error is MiddlewareRejectSignal;
     /**
      * Dissolves the matching route based on the request-url and an object of routes
      *