npm - structured-fw - Versions diffs - 1.5.0 → 1.6.0 - Mend

structured-fw 1.5.0 → 1.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

package/README.md +6 -4
package/build/system/EventEmitter.js +4 -6
package/build/system/StructuredError.d.ts +8 -0
package/build/system/StructuredError.js +40 -0
package/build/system/bin/structured.js +1 -2
package/build/system/client/ClientApplication.js +3 -2
package/build/system/client/ClientComponent.js +21 -13
package/build/system/client/DataStore.js +2 -4
package/build/system/client/DataStoreView.js +3 -1
package/build/system/client/NetRequest.js +7 -2
package/build/system/server/Application.d.ts +1 -1
package/build/system/server/Application.js +12 -7
package/build/system/server/Component.js +15 -7
package/build/system/server/Components.js +3 -2
package/build/system/server/Document.js +10 -7
package/build/system/server/DocumentHead.js +9 -8
package/build/system/server/FormValidation.js +121 -123
package/build/system/server/Handlebars.js +2 -4
package/build/system/server/Layout.js +4 -0
package/build/system/server/Request.d.ts +0 -2
package/build/system/server/Request.js +15 -7
package/build/system/server/RequestContext.d.ts +7 -5
package/build/system/server/RequestContext.js +54 -39
package/build/system/server/Session.js +3 -2
package/build/system/server/dom/DOMNode.js +11 -7
package/build/system/server/dom/HTMLParser.js +10 -8
package/build/system/types/application.types.d.ts +1 -1
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -134,13 +134,14 @@ new Application(config);
     - `serverStarted` - executed once the built-in http server is started and running. Callback receives Server (exported from node:http) instance as the first argument
     - `beforeRequestHandler` - runs before any request handler (route) is executed. Callback receives `RequestContext` as the first argument. Useful for example to set `RequestContext.data: RequestContextData` (user defined data, to make it available to routes and components)
     - `afterRequestHandler` - runs after any request handler (route) is executed. Callback receives `RequestContext` as the first argument
+    - `requestHandleError` - runs if there were errors while serving the request. Callback's result is sent as a response - a good use case is showing a "server error" page. Callback receives `RequestContext` as the first argument
     - `afterRoutes` - runs after all routes are loaded from `StructuredConfig.routes.path`. Callback receives no arguments
     - `beforeComponentsLoad` - runs before components are loaded from `StructuredConfig.components.path`. Callback receives no arguments
     - `afterComponentsLoaded` - runs after all components are loaded from `StructuredConfig.components.path`. Callback receives instance of Components as the first argument
     - `documentCreated` - runs whenever an instance of a [Document](#document) is created. Callback receives the Document instance as the first argument. You will often use this, for example if you want to include a CSS file to all pages `Document.head.addCSS(...)`
     - `beforeAssetAccess` - runs when assets are being accessed, before response is sent. Callback receives `RequestContext` as the first argument
     - `afterAssetAccess` - runs when assets are being accessed, after response is sent. Callback receives `RequestContext` as the first argument
-    - `pageNotFound` - runs when a request is received for which there is no registered request handler (route), and the requested URL is not an asset. Callback receives `RequestContext` as the first argument
+    - `pageNotFound` - runs when a request is received for which there is no registered request handler (route), and the requested URL is not an asset. Callback's result is sent as a response - a good use case is showing a 404 page. Callback receives `RequestContext` as the first argument
     - **Callback to any of the `ApplicationEvents` is expected to be an async function**
 - `importEnv<T extends LooseObject>(smartPrimitives: boolean = true): T` - import ENV variables that start with `StructuredConfig.envPrefix`_ (if envPrefix is omitted from config, all ENV variables are returned). It is a generic method so that you can specify the expected return type. If `smartPrimitives = true` importEnv will convert the ENV values to type it feels is appropriate:
     - numeric values -> `number`
@@ -322,9 +323,10 @@ class RequestContext<Body extends LooseObject | undefined = LooseObject> = {
     // redirect to given URI, with given statusCode (default 302)
     redirect: (to: string, statusCode?: number) => void;
-    // show a 404 page and send a 404 status code
-    // by default it will be a page with content "Page not found"
-    // to change this you can set app.request.pageNotFoundCallback to a function that returns a Document
+    // show a blank page and send a 404 status code
+    // to show a custom page, text, json, etc... register an event handler for pageNotFound event
+    // for example:
+    // app.on('pageNotFound', (ctx) => { return await ctx.createDocument('Page not found', 'NotFound'); })
     show404: () => Promise<void>
 }
 ```

package/build/system/EventEmitter.js CHANGED Viewed

@@ -1,10 +1,8 @@
 export class EventEmitter {
-    constructor() {
-        this.listeners = {};
-        this.destroyed = false;
-        this.ready = false;
-        this.eventQueue = [];
-    }
+    listeners = {};
+    destroyed = false;
+    ready = false;
+    eventQueue = [];
     on(eventName, callback) {
         if (this.destroyed) {
             return;

package/build/system/StructuredError.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+export declare class StructuredError extends Error {
+    causedBy: StructuredError | null;
+    stack: string | undefined;
+    constructor(message: string | Error, cause: StructuredError | Error | null);
+    toString(depth?: number): string;
+    log(depth?: number): void;
+    private formatLines;
+}

package/build/system/StructuredError.js ADDED Viewed

@@ -0,0 +1,40 @@
+export class StructuredError extends Error {
+    causedBy;
+    stack;
+    constructor(message, cause) {
+        super(typeof message === 'string' ? message : message.message);
+        if (message instanceof Error) {
+            this.stack = message.stack;
+        }
+        if (cause === null) {
+            this.causedBy = null;
+        }
+        else {
+            this.causedBy = cause instanceof StructuredError ? cause : new StructuredError(cause, null);
+        }
+    }
+    toString(depth = 0) {
+        const errorParts = [this.message];
+        if (this.stack) {
+            errorParts.push('Stack trace:');
+            errorParts.push(this.stack);
+        }
+        if (this.causedBy !== null) {
+            errorParts.push('Originated from:');
+            errorParts.push(this.causedBy.toString(depth + 1));
+        }
+        return this.formatLines(errorParts.join('\n'), depth);
+    }
+    log(depth = 0) {
+        console.error(this.formatLines(this.toString(), depth));
+    }
+    formatLines(text, depth) {
+        const linesFormatted = [];
+        const lines = text.split('\n');
+        const prepend = '  '.repeat(depth);
+        lines.forEach((line) => {
+            linesFormatted.push(prepend + line);
+        });
+        return linesFormatted.join('\n');
+    }
+}

package/build/system/bin/structured.js CHANGED Viewed

@@ -64,11 +64,10 @@ function createTsconfig() {
                 "moduleResolution": "node16",
                 "outDir": "./build",
                 "module": "Node16",
-                "target": "ES2021",
+                "target": "es2022",
                 "allowSyntheticDefaultImports": true,
                 "preserveSymlinks": true,
                 "removeComments": true,
-                "baseUrl": ".",
                 "rootDir": ".",
                 paths
             },

package/build/system/client/ClientApplication.js CHANGED Viewed

@@ -1,9 +1,10 @@
 import { DataStore } from './DataStore.js';
 import { ClientComponent } from './ClientComponent.js';
 export class ClientApplication {
+    root;
+    store = new DataStore();
+    initializers = {};
     constructor() {
-        this.store = new DataStore();
-        this.initializers = {};
         this.loadInitializers();
         this.root = new ClientComponent(null, 'root', document.body, this);
     }

package/build/system/client/ClientComponent.js CHANGED Viewed

@@ -4,21 +4,29 @@ import { Net } from './Net.js';
 import { NetRequest } from './NetRequest.js';
 import { EventEmitter } from '../EventEmitter.js';
 export class ClientComponent extends EventEmitter {
+    name;
+    children = [];
+    parent;
+    domNode;
+    isRoot;
+    root;
+    store;
+    app;
+    net = new Net();
+    initializerExecuted = false;
+    fn;
+    destroyed = false;
+    redrawRequest = null;
+    bound = [];
+    conditionals = [];
+    conditionalCallbacks = {};
+    conditionalClassNames = [];
+    refs = {};
+    refsArray = {};
+    isReady = false;
+    data = {};
     constructor(parent, name, domNode, app) {
         super();
-        this.children = [];
-        this.net = new Net();
-        this.initializerExecuted = false;
-        this.destroyed = false;
-        this.redrawRequest = null;
-        this.bound = [];
-        this.conditionals = [];
-        this.conditionalCallbacks = {};
-        this.conditionalClassNames = [];
-        this.refs = {};
-        this.refsArray = {};
-        this.isReady = false;
-        this.data = {};
         this.name = name;
         this.domNode = domNode;
         if (parent === null) {

package/build/system/client/DataStore.js CHANGED Viewed

@@ -1,9 +1,7 @@
 import { equalDeep } from '../Util.js';
 export class DataStore {
-    constructor() {
-        this.data = {};
-        this.changeListeners = {};
-    }
+    data = {};
+    changeListeners = {};
     set(component, key, val, force = false, triggerListeners = true) {
         const componentId = component.getData('componentId');
         const oldValue = this.get(componentId, key);

package/build/system/client/DataStoreView.js CHANGED Viewed

@@ -1,6 +1,8 @@
 export class DataStoreView {
+    store;
+    component;
+    destroyed = false;
     constructor(store, component) {
-        this.destroyed = false;
         this.store = store;
         this.component = component;
     }

package/build/system/client/NetRequest.js CHANGED Viewed

@@ -1,7 +1,12 @@
 export class NetRequest {
+    xhr = new XMLHttpRequest();
+    method;
+    url;
+    headers;
+    responseType;
+    body;
+    requestSent = false;
     constructor(method, url, headers = {}, responseType = 'text', body) {
-        this.xhr = new XMLHttpRequest();
-        this.requestSent = false;
         this.method = method;
         this.url = url;
         this.headers = headers;

package/build/system/server/Application.d.ts CHANGED Viewed

@@ -25,7 +25,7 @@ export declare class Application {
     constructor(config: StructuredConfig);
     init(): Promise<void>;
     private start;
-    on<E extends ApplicationEvents>(evt: E, callback: (payload: E extends 'beforeRequestHandler' | 'afterRequestHandler' | 'beforeAssetAccess' | 'afterAssetAccess' | 'pageNotFound' ? RequestContext : E extends 'documentCreated' ? Document : E extends 'afterComponentsLoaded' ? Components : E extends 'serverStarted' ? Server : undefined) => void): void;
+    on<E extends ApplicationEvents>(evt: E, callback: (payload: E extends 'beforeRequestHandler' | 'afterRequestHandler' | 'beforeAssetAccess' | 'afterAssetAccess' | 'pageNotFound' | 'requestHandleError' ? RequestContext<RequestContextData> : E extends 'documentCreated' ? Document : E extends 'afterComponentsLoaded' ? Components : E extends 'serverStarted' ? Server : undefined) => void): void;
     emit(eventName: ApplicationEvents, payload?: any): Promise<Array<any>>;
     importEnv<T extends LooseObject>(smartPrimitives?: boolean): T;
     exportContextFields(...fields: Array<keyof RequestContextData>): void;

package/build/system/server/Application.js CHANGED Viewed

@@ -11,14 +11,19 @@ import { Request } from './Request.js';
 import { Handlebars } from './Handlebars.js';
 import { Cookies } from './Cookies.js';
 export class Application {
+    config;
+    initialized = false;
+    server = null;
+    listening = false;
+    eventEmitter = new EventEmitter();
+    cookies;
+    session;
+    request;
+    components;
+    handlebars = new Handlebars();
+    exportedRequestContextData = [];
+    data = {};
     constructor(config) {
-        this.initialized = false;
-        this.server = null;
-        this.listening = false;
-        this.eventEmitter = new EventEmitter();
-        this.handlebars = new Handlebars();
-        this.exportedRequestContextData = [];
-        this.data = {};
         this.config = config;
         this.cookies = new Cookies();
         this.session = new Session(this);

package/build/system/server/Component.js CHANGED Viewed

@@ -2,14 +2,22 @@ import { Document } from './Document.js';
 import { attributeValueFromString, attributeValueToString, objectEach, toCamelCase } from '../Util.js';
 import { DOMFragment } from './dom/DOMFragment.js';
 import { EventEmitter } from '../EventEmitter.js';
+import { StructuredError } from '../StructuredError.js';
 export class Component extends EventEmitter {
+    id;
+    name;
+    document;
+    parent;
+    children = [];
+    path = [];
+    attributesRaw = {};
+    attributes = {};
+    dom;
+    data = {};
+    entry;
+    isRoot;
     constructor(name, node, parent, autoInit = true) {
         super();
-        this.children = [];
-        this.path = [];
-        this.attributesRaw = {};
-        this.attributes = {};
-        this.data = {};
         const isDocument = this instanceof Document;
         this.name = name;
         this.emitterReady();
@@ -96,7 +104,7 @@ export class Component extends EventEmitter {
                 await this.entry.serverPart.getData(Object.assign(importedParentData, this.attributes, data || {}), this.document.ctx, this.document.application, this) : {}) || {};
         }
         catch (e) {
-            throw new Error(`Error executing getData in component ${this.name}: ${e.message}`);
+            throw new StructuredError(`Error executing getData in component ${this.name}`, e);
         }
         if (data === undefined) {
             if (this.entry && this.entry.hasServerPart) {
@@ -271,7 +279,7 @@ export class Component extends EventEmitter {
             this.dom.innerHTML = this.document.application.handlebars.compile(html, data);
         }
         catch (e) {
-            throw new Error(`Error compiling Handlebars template in component ${this.name}, error: ${e.message}`);
+            throw new StructuredError(`Error compiling Handlebars template in component ${this.name}`, e);
         }
     }
 }

package/build/system/server/Components.js CHANGED Viewed

@@ -2,9 +2,10 @@ import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import * as path from 'node:path';
 import { stripBOM } from '../Util.js';
 export class Components {
+    config;
+    components = {};
+    componentNames = [];
     constructor(app) {
-        this.components = {};
-        this.componentNames = [];
         this.config = app.config;
     }
     loadComponents(relativeToPath) {

package/build/system/server/Document.js CHANGED Viewed

@@ -5,15 +5,18 @@ import path from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 export class Document extends Component {
+    head;
+    language = 'en';
+    application;
+    htmlTagAttributes = {};
+    bodyTagAttributes = {};
+    initializers = {};
+    initializersInitialized = false;
+    componentIds = [];
+    ctx;
+    appendHTML = '';
     constructor(app, title, ctx) {
         super('root');
-        this.language = 'en';
-        this.htmlTagAttributes = {};
-        this.bodyTagAttributes = {};
-        this.initializers = {};
-        this.initializersInitialized = false;
-        this.componentIds = [];
-        this.appendHTML = '';
         this.application = app;
         this.ctx = ctx;
         this.document = this;

package/build/system/server/DocumentHead.js CHANGED Viewed

@@ -1,13 +1,14 @@
 export class DocumentHead {
+    title;
+    js = [];
+    css = [];
+    custom = [];
+    charset = 'UTF-8';
+    favicon = {
+        image: null,
+        type: 'image/png'
+    };
     constructor(title) {
-        this.js = [];
-        this.css = [];
-        this.custom = [];
-        this.charset = 'UTF-8';
-        this.favicon = {
-            image: null,
-            type: 'image/png'
-        };
         this.title = title;
     }
     setTitle(title) {

package/build/system/server/FormValidation.js CHANGED Viewed

@@ -1,132 +1,130 @@
 export class FormValidation {
-    constructor() {
-        this.fieldRules = [];
-        this.singleError = false;
-        this.customValidators = [];
-        this.validators = {
-            'required': async (data, field) => {
-                if (!(field in data)) {
-                    return false;
-                }
-                const value = data[field];
-                if (value === null ||
-                    value === undefined ||
-                    (typeof value === 'string' && value.trim().length === 0)) {
-                    return false;
-                }
+    fieldRules = [];
+    singleError = false;
+    customValidators = [];
+    validators = {
+        'required': async (data, field) => {
+            if (!(field in data)) {
+                return false;
+            }
+            const value = data[field];
+            if (value === null ||
+                value === undefined ||
+                (typeof value === 'string' && value.trim().length === 0)) {
+                return false;
+            }
+            return true;
+        },
+        'number': async (data, field) => {
+            const value = data[field];
+            if (typeof value === 'number') {
                 return true;
-            },
-            'number': async (data, field) => {
-                const value = data[field];
-                if (typeof value === 'number') {
-                    return true;
-                }
-                if (typeof value !== 'string') {
-                    return false;
-                }
-                return /^-?\d+$/.test(value);
-            },
-            'float': async (data, field) => {
-                const value = data[field];
-                if (typeof value === 'number') {
-                    return true;
-                }
-                if (typeof value !== 'string') {
-                    return false;
-                }
-                return /^-?\d+\.\d+$/.test(value);
-            },
-            'numeric': async (data, field, arg, rules) => {
-                return await this.validators['number'](data, field, arg, rules) || await this.validators['float'](data, field, arg, rules);
-            },
-            'min': async (data, field, arg, rules) => {
-                const value = data[field];
-                if (typeof value === 'number') {
-                    return value >= arg;
-                }
-                if (typeof value !== 'string') {
-                    return false;
-                }
-                if (await this.validators['numeric'](data, field, arg, rules)) {
-                    return parseFloat(value) >= arg;
-                }
+            }
+            if (typeof value !== 'string') {
                 return false;
-            },
-            'max': async (data, field, arg, rules) => {
-                const value = data[field];
-                if (typeof value === 'number') {
-                    return value <= arg;
-                }
-                if (typeof value !== 'string') {
-                    return false;
-                }
-                if (await this.validators['numeric'](data, field, arg, rules)) {
-                    return parseFloat(value) <= arg;
-                }
+            }
+            return /^-?\d+$/.test(value);
+        },
+        'float': async (data, field) => {
+            const value = data[field];
+            if (typeof value === 'number') {
+                return true;
+            }
+            if (typeof value !== 'string') {
                 return false;
-            },
-            'minLength': async (data, field, arg) => {
-                const value = data[field];
-                if (typeof value !== 'string') {
-                    return false;
-                }
-                return value.length >= arg;
-            },
-            'maxLength': async (data, field, arg) => {
-                const value = data[field];
-                if (typeof value !== 'string') {
-                    return false;
-                }
-                return value.length <= arg;
-            },
-            'alphanumeric': async (data, field) => {
-                const value = data[field];
-                if (typeof value !== 'string') {
-                    return false;
-                }
-                return /^[a-zA-Z0-9]+$/.test(value);
-            },
-            'validEmail': async (data, field) => {
-                const value = data[field];
-                if (typeof value !== 'string') {
-                    return false;
-                }
-                return /^(?=.{1,254}$)(?=.{1,64}@)[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+(\.[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+)*@[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/.test(value);
             }
-        };
-        this.decorators = {
-            'required': (fieldHuman) => {
-                return `${fieldHuman} is required`;
-            },
-            'number': (fieldHuman) => {
-                return `${fieldHuman} has to be a whole number`;
-            },
-            'float': (fieldHuman) => {
-                return `${fieldHuman} has to be a decimal number`;
-            },
-            'numeric': (fieldHuman) => {
-                return `${fieldHuman} has to contain a numeric value`;
-            },
-            'min': (fieldHuman, data, field, arg) => {
-                return `${fieldHuman} has to be a value greater than ${arg}`;
-            },
-            'max': (fieldHuman, data, field, arg) => {
-                return `${fieldHuman} has to be a value lower than ${arg}`;
-            },
-            'minLength': (fieldHuman, data, field, arg) => {
-                return `${fieldHuman} has to contain at least ${arg} characters`;
-            },
-            'maxLength': (fieldHuman, data, field, arg) => {
-                return `${fieldHuman} has to contain no more than ${arg} characters`;
-            },
-            'alphanumeric': (fieldHuman) => {
-                return `${fieldHuman} can contain only letter and numbers`;
-            },
-            'validEmail': () => {
-                return `Please enter a valid email address`;
+            return /^-?\d+\.\d+$/.test(value);
+        },
+        'numeric': async (data, field, arg, rules) => {
+            return await this.validators['number'](data, field, arg, rules) || await this.validators['float'](data, field, arg, rules);
+        },
+        'min': async (data, field, arg, rules) => {
+            const value = data[field];
+            if (typeof value === 'number') {
+                return value >= arg;
             }
-        };
-    }
+            if (typeof value !== 'string') {
+                return false;
+            }
+            if (await this.validators['numeric'](data, field, arg, rules)) {
+                return parseFloat(value) >= arg;
+            }
+            return false;
+        },
+        'max': async (data, field, arg, rules) => {
+            const value = data[field];
+            if (typeof value === 'number') {
+                return value <= arg;
+            }
+            if (typeof value !== 'string') {
+                return false;
+            }
+            if (await this.validators['numeric'](data, field, arg, rules)) {
+                return parseFloat(value) <= arg;
+            }
+            return false;
+        },
+        'minLength': async (data, field, arg) => {
+            const value = data[field];
+            if (typeof value !== 'string') {
+                return false;
+            }
+            return value.length >= arg;
+        },
+        'maxLength': async (data, field, arg) => {
+            const value = data[field];
+            if (typeof value !== 'string') {
+                return false;
+            }
+            return value.length <= arg;
+        },
+        'alphanumeric': async (data, field) => {
+            const value = data[field];
+            if (typeof value !== 'string') {
+                return false;
+            }
+            return /^[a-zA-Z0-9]+$/.test(value);
+        },
+        'validEmail': async (data, field) => {
+            const value = data[field];
+            if (typeof value !== 'string') {
+                return false;
+            }
+            return /^(?=.{1,254}$)(?=.{1,64}@)[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+(\.[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+)*@[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/.test(value);
+        }
+    };
+    decorators = {
+        'required': (fieldHuman) => {
+            return `${fieldHuman} is required`;
+        },
+        'number': (fieldHuman) => {
+            return `${fieldHuman} has to be a whole number`;
+        },
+        'float': (fieldHuman) => {
+            return `${fieldHuman} has to be a decimal number`;
+        },
+        'numeric': (fieldHuman) => {
+            return `${fieldHuman} has to contain a numeric value`;
+        },
+        'min': (fieldHuman, data, field, arg) => {
+            return `${fieldHuman} has to be a value greater than ${arg}`;
+        },
+        'max': (fieldHuman, data, field, arg) => {
+            return `${fieldHuman} has to be a value lower than ${arg}`;
+        },
+        'minLength': (fieldHuman, data, field, arg) => {
+            return `${fieldHuman} has to contain at least ${arg} characters`;
+        },
+        'maxLength': (fieldHuman, data, field, arg) => {
+            return `${fieldHuman} has to contain no more than ${arg} characters`;
+        },
+        'alphanumeric': (fieldHuman) => {
+            return `${fieldHuman} can contain only letter and numbers`;
+        },
+        'validEmail': () => {
+            return `Please enter a valid email address`;
+        }
+    };
     addRule(fieldName, nameHumanReadable, rules) {
         const rule = {
             field: [fieldName, nameHumanReadable],

package/build/system/server/Handlebars.js CHANGED Viewed

@@ -1,9 +1,7 @@
 import { default as HandlebarsInstance } from 'handlebars';
 export class Handlebars {
-    constructor() {
-        this.instance = HandlebarsInstance;
-        this.helpers = {};
-    }
+    instance = HandlebarsInstance;
+    helpers = {};
     register(name, helper) {
         this.helpers[name] = helper;
         this.instance.registerHelper(name, helper);

package/build/system/server/Layout.js CHANGED Viewed

@@ -1,6 +1,10 @@
 import { Component } from "./Component.js";
 import { Document } from "./Document.js";
 export class Layout {
+    layoutComponent;
+    app;
+    language;
+    attributes;
     constructor(app, layoutComponent, language = 'en', attributes) {
         this.app = app;
         this.layoutComponent = layoutComponent;

package/build/system/server/Request.d.ts CHANGED Viewed

@@ -2,10 +2,8 @@ import { IncomingMessage, ServerResponse } from "node:http";
 import { LooseObject } from '../types/general.types.js';
 import { RequestMethod, RequestCallback } from "../types/request.types.js";
 import { Application } from "./Application.js";
-import { Document } from "./Document.js";
 export declare class Request {
     private app;
-    pageNotFoundCallback: RequestCallback<void | Document, LooseObject | undefined>;
     constructor(app: Application);
     private readonly handlers;
     on<R extends any, Body extends LooseObject | undefined = LooseObject>(methods: RequestMethod | Array<RequestMethod>, pattern: string | RegExp | Array<string | RegExp>, callback: RequestCallback<R, Body>, scope?: any, isStaticAsset?: boolean): void;

package/build/system/server/Request.js CHANGED Viewed

@@ -1,16 +1,13 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { RequestContext } from "./RequestContext.js";
+import { StructuredError } from "../StructuredError.js";
 export class Request {
+    app;
     constructor(app) {
-        this.pageNotFoundCallback = async ({ response }) => {
-            response.statusCode = 404;
-            response.write('Page not found');
-            response.end();
-        };
-        this.handlers = [];
         this.app = app;
     }
+    handlers = [];
     on(methods, pattern, callback, scope, isStaticAsset = false) {
         if (!(methods instanceof Array)) {
             methods = [methods];
@@ -92,7 +89,18 @@ export class Request {
             uri = uriParts[0];
         }
         const handler = this.getHandler(uri, requestMethod);
-        new RequestContext(this.app, request, response, handler, this.pageNotFoundCallback);
+        try {
+            const ctx = new RequestContext(this.app, request, response, handler);
+            await ctx.exec();
+        }
+        catch (e) {
+            if (e instanceof StructuredError) {
+                e.log();
+            }
+            else {
+                throw e;
+            }
+        }
     }
     patternToSegments(pattern) {
         const segments = [];

package/build/system/server/RequestContext.d.ts CHANGED Viewed

@@ -1,12 +1,13 @@
 import { IncomingMessage, ServerResponse } from "node:http";
-import { LooseObject, PostedDataDecoded, RequestBodyRecordValue, RequestCallback, RequestHandler, URIArguments } from "../Types.js";
+import { LooseObject, PostedDataDecoded, RequestBodyRecordValue, RequestHandler, URIArguments } from "../Types.js";
 import { Application } from "./Application.js";
 import { Document } from "./Document.js";
 import { Layout } from "./Layout.js";
 export declare class RequestContext<Body extends LooseObject | undefined = LooseObject> {
+    private executionStartedAt;
+    private executionCompletedAt;
     readonly app: Application;
     uri: string;
-    private readonly pageNotFoundCallback;
     private readonly handler;
     readonly request: IncomingMessage;
     readonly response: ServerResponse;
@@ -20,8 +21,8 @@ export declare class RequestContext<Body extends LooseObject | undefined = Loose
     getArgs: PostedDataDecoded;
     readonly timeStart: number;
     private streamingData;
-    constructor(app: Application, request: IncomingMessage, response: ServerResponse, handler: RequestHandler | null, pageNotFoundCallback: RequestCallback<void | Document, LooseObject | undefined>);
-    private exec;
+    constructor(app: Application, request: IncomingMessage, response: ServerResponse, handler: RequestHandler | null);
+    exec(): Promise<void>;
     respondWith(data: any): Promise<void>;
     private sendResponse;
     createDocument(title: string, component: string, data?: LooseObject): Promise<Document>;
@@ -37,5 +38,6 @@ export declare class RequestContext<Body extends LooseObject | undefined = Loose
     private extractURIArguments;
     private handle;
     isAjax(): boolean;
-    private error;
+    duration(): number;
+    complete(): boolean;
 }

package/build/system/server/RequestContext.js CHANGED Viewed

@@ -3,13 +3,26 @@ import { mergeDeep, queryStringDecode, queryStringDecodedSetValue } from "../Uti
 import { Document } from "./Document.js";
 import path from "node:path";
 import { existsSync, readFileSync, ReadStream } from "node:fs";
+import { StructuredError } from "../StructuredError.js";
 export class RequestContext {
-    constructor(app, request, response, handler, pageNotFoundCallback) {
-        this.args = {};
-        this.cookies = {};
-        this.data = {};
-        this.getArgs = {};
-        this.streamingData = false;
+    executionStartedAt = null;
+    executionCompletedAt = null;
+    app;
+    uri;
+    handler;
+    request;
+    response;
+    args = {};
+    cookies = {};
+    body;
+    bodyRaw;
+    files;
+    data = {};
+    sessionId;
+    getArgs = {};
+    timeStart;
+    streamingData = false;
+    constructor(app, request, response, handler) {
         this.timeStart = Date.now();
         this.uri = request.url || '/';
         this.app = app;
@@ -17,21 +30,31 @@ export class RequestContext {
         this.response = response;
         this.handler = handler;
         this.body = undefined;
-        this.pageNotFoundCallback = pageNotFoundCallback;
-        this.exec();
     }
     async exec() {
-        this.initGetArgs();
-        this.parseCookies();
-        if (this.handler) {
-            try {
+        if (this.executionStartedAt !== null) {
+            return;
+        }
+        this.executionStartedAt = Date.now();
+        try {
+            this.initGetArgs();
+            this.parseCookies();
+            if (this.handler) {
                 await this.parseBody();
             }
-            catch (e) {
-                this.error(e);
+            await this.handle();
+            this.executionCompletedAt = Date.now();
+        }
+        catch (e) {
+            const res = await this.app.emit('requestHandleError', this);
+            if (res.length > 0) {
+                if (!!res[0]) {
+                    await this.respondWith(res[0]);
+                }
             }
+            this.response.end();
+            throw new StructuredError(`Error in request to ${this.uri}`, e);
         }
-        await this.handle();
     }
     async respondWith(data) {
         if (typeof data === 'string' || Buffer.isBuffer(data)) {
@@ -91,11 +114,10 @@ export class RequestContext {
         return await layout.document(this, title, component, data, attributes);
     }
     async show404() {
-        this.app.emit('pageNotFound', this);
         this.response.statusCode = 404;
-        const res = await this.pageNotFoundCallback.apply(this.app, [this]);
-        if (res instanceof Document) {
-            await this.respondWith(res);
+        const res = await this.app.emit('pageNotFound', this);
+        if (res.length > 0 && !!res[0]) {
+            await this.respondWith(res[0]);
         }
     }
     initGetArgs() {
@@ -139,11 +161,7 @@ export class RequestContext {
                     this.body = queryStringDecode(bodyRaw);
                 }
                 catch (e) {
-                    console.error(`Error parsing urlencoded request body for request to ${this.request.url}, (${e.message}).
-                    Raw data:
-                        ${bodyRaw}
-                    `);
+                    throw new StructuredError(`Error parsing urlencoded request body, raw data: ${bodyRaw}`, e);
                 }
             }
             else if (this.request.headers['content-type'].indexOf('multipart/form-data') > -1) {
@@ -154,21 +172,13 @@ export class RequestContext {
                         this.body = this.parseBodyMultipart(this.bodyRaw.toString('utf-8'), boundary);
                     }
                     catch (e) {
-                        console.error(`Error parsing multipart request body for request to ${this.request.url}, (${e.message}).
-                        Raw data:
-                            ${this.bodyRaw.toString('utf-8')}
-                        `);
+                        throw new StructuredError(`Error parsing multipart request body, raw data: ${this.bodyRaw.toString('utf-8')}`, e);
                     }
                     try {
                         this.files = this.multipartBodyFiles(this.bodyRaw.toString('binary'), boundary);
                     }
                     catch (e) {
-                        this.error(`Error parsing multipart request body files: (${e.message}).
-                        Raw data:
-                            ${this.bodyRaw.toString('utf-8')}
-                        `);
+                        throw new StructuredError(`Error parsing multipart request body files, raw data ${this.bodyRaw.toString('utf-8')}`, e);
                     }
                 }
             }
@@ -177,7 +187,7 @@ export class RequestContext {
                     this.body = JSON.parse(this.bodyRaw.toString());
                 }
                 catch (e) {
-                    this.body = undefined;
+                    throw new StructuredError(`Error parsing JSON request body, raw data: ${this.bodyRaw.toString('utf-8')}`, e);
                 }
             }
         }
@@ -263,7 +273,7 @@ export class RequestContext {
                 }
             }
             catch (e) {
-                console.log('Error executing request handler ', e, this.handler.callback.toString());
+                throw new StructuredError(`Error executing request handler ${this.handler.callback.name}`, e);
             }
             if (!this.handler.staticAsset) {
                 await this.app.emit('afterRequestHandler', this);
@@ -300,8 +310,13 @@ export class RequestContext {
     isAjax() {
         return this.request.headers['x-requested-with'] == 'xmlhttprequest';
     }
-    error(e) {
-        const message = typeof e === 'string' ? e : e.message;
-        console.error(`Error in request to ${this.uri}: ${message}`);
+    duration() {
+        if (this.executionStartedAt === null || this.executionCompletedAt === null) {
+            return 0;
+        }
+        return this.executionCompletedAt - this.executionStartedAt;
+    }
+    complete() {
+        return this.executionCompletedAt !== null;
     }
 }

package/build/system/server/Session.js CHANGED Viewed

@@ -1,8 +1,9 @@
 import { randomString } from '../Util.js';
 export class Session {
+    application;
+    enabled = false;
+    sessions = {};
     constructor(app) {
-        this.enabled = false;
-        this.sessions = {};
         this.application = app;
         this.application.on('beforeRequestHandler', async (ctx) => {
             if (this.enabled) {

package/build/system/server/dom/DOMNode.js CHANGED Viewed

@@ -7,14 +7,18 @@ export const recognizedHTMLTags = [
     'svg', 'g', 'text', 'path', 'circle', 'clipPath', 'defs', 'ellipse', 'rect', 'polygon', 'image', 'style',
 ];
 export class DOMNode {
+    tagName;
+    root;
+    parentNode = null;
+    children = [];
+    isRoot;
+    attributes = [];
+    attributeMap = {};
+    style = {};
+    selfClosing;
+    explicitSelfClosing = false;
+    potentialComponentChildren = [];
     constructor(root, parentNode, tagName) {
-        this.parentNode = null;
-        this.children = [];
-        this.attributes = [];
-        this.attributeMap = {};
-        this.style = {};
-        this.explicitSelfClosing = false;
-        this.potentialComponentChildren = [];
         this.root = root === null ? this : root;
         this.isRoot = root === null;
         this.parentNode = parentNode;

package/build/system/server/dom/HTMLParser.js CHANGED Viewed

@@ -1,15 +1,17 @@
 import { DOMFragment } from "./DOMFragment.js";
 import { DOMNode } from "./DOMNode.js";
 export class HTMLParser {
+    html;
+    offset = 0;
+    context;
+    state = 'idle';
+    tokenCurrent = '';
+    fragment = new DOMFragment();
+    explicitSelfClosing = false;
+    attributeOpenQuote = '"';
+    attributeNameCurrent = '';
+    attributeContext = null;
     constructor(html) {
-        this.offset = 0;
-        this.state = 'idle';
-        this.tokenCurrent = '';
-        this.fragment = new DOMFragment();
-        this.explicitSelfClosing = false;
-        this.attributeOpenQuote = '"';
-        this.attributeNameCurrent = '';
-        this.attributeContext = null;
         this.html = html;
         this.context = this.fragment;
         while (this.parse()) {

package/build/system/types/application.types.d.ts CHANGED Viewed

	@@ -1 +1 @@
1	- export type ApplicationEvents = 'serverStarted' \| 'beforeRequestHandler' \| 'afterRequestHandler' \| 'beforeRoutes' \| 'afterRoutes' \| 'beforeComponentsLoad' \| 'afterComponentsLoaded' \| 'documentCreated' \| 'beforeAssetAccess' \| 'afterAssetAccess' \| 'pageNotFound';
1	+ export type ApplicationEvents = 'serverStarted' \| 'beforeRequestHandler' \| 'afterRequestHandler' \| 'requestHandleError' \| 'beforeRoutes' \| 'afterRoutes' \| 'beforeComponentsLoad' \| 'afterComponentsLoaded' \| 'documentCreated' \| 'beforeAssetAccess' \| 'afterAssetAccess' \| 'pageNotFound';

package/package.json CHANGED Viewed

@@ -19,7 +19,7 @@
   "license": "MIT",
   "type": "module",
   "main": "build/index",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "scripts": {
     "develop": "tsc --watch",
     "startDev": "cd build && nodemon --watch '../app/**/*' --watch '../build/**/*' -e js,html,hbs,css index.js",