structured-fw 1.4.0 → 1.6.0

package/build/system/server/FormValidation.js

@@ -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

@@ -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.d.ts

@@ -1,7 +1,7 @@
 import { LooseObject } from '../types/general.types.js';
-import { RequestContext } from "../types/request.types.js";
 import { Application } from "./Application.js";
 import { Document } from "./Document.js";
+import { RequestContext } from './RequestContext.js';
 export declare class Layout {
     layoutComponent: string;
     app: Application;
@@ -9,5 +9,5 @@ export declare class Layout {
     attributes: Record<string, string>;
     constructor(app: Application, layoutComponent: string, language?: string, attributes?: Record<string, string>);
     private layoutComponentExists;
-    document(ctx: RequestContext, title: string, componentName: string, data?: LooseObject, attributes?: Record<string, string>): Promise<Document>;
+    document(ctx: RequestContext<any>, title: string, componentName: string, data?: LooseObject, attributes?: Record<string, string>): Promise<Document>;
 }

package/build/system/server/Layout.js

@@ -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

@@ -1,24 +1,14 @@
 import { IncomingMessage, ServerResponse } from "node:http";
 import { LooseObject } from '../types/general.types.js';
-import { RequestMethod, PostedDataDecoded, RequestBodyFile, RequestCallback } from "../types/request.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;
     constructor(app: Application);
-    pageNotFoundCallback: RequestCallback<void | Document, LooseObject>;
     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;
     private getHandler;
     handle(request: IncomingMessage, response: ServerResponse): Promise<void>;
-    private extractURIArguments;
     private patternToSegments;
-    private parseBody;
-    private dataRaw;
-    redirect(response: ServerResponse, to: string, statusCode?: number): void;
     loadHandlers(basePath?: string): Promise<void>;
-    static queryStringDecode(queryString: string, initialValue?: PostedDataDecoded, trimValues?: boolean): PostedDataDecoded;
-    static parseBodyMultipart(bodyRaw: string, boundary: string): PostedDataDecoded;
-    static multipartBodyFiles(bodyRaw: string, boundary: string): Record<string, RequestBodyFile>;
-    private sendResponse;
 }

package/build/system/server/Request.js

@@ -1,19 +1,13 @@
-import { mergeDeep, queryStringDecode, queryStringDecodedSetValue } from "../Util.js";
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
-import { Buffer } from "node:buffer";
-import { Document } from "./Document.js";
-import zlib from "node:zlib";
+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];
@@ -90,128 +84,23 @@ export class Request {
         if (this.app.config.url.removeTrailingSlash && uri.length > 1 && uri.endsWith('/')) {
             uri = uri.substring(0, uri.length - 1);
         }
-        let getArgs = {};
         if (uri.indexOf('?') > -1) {
             const uriParts = uri.split('?');
             uri = uriParts[0];
-            getArgs = queryStringDecode(uriParts[1]);
         }
         const handler = this.getHandler(uri, requestMethod);
-        const context = {
-            request,
-            response,
-            handler,
-            args: {},
-            data: {},
-            body: undefined,
-            getArgs,
-            cookies: this.app.cookies.parse(request),
-            timeStart: new Date().getTime(),
-            isAjax: request.headers['x-requested-with'] == 'xmlhttprequest',
-            respondWith: async (data) => {
-                if (typeof data === 'string' || Buffer.isBuffer(data)) {
-                    this.sendResponse(request, response, data, 'text/plain; charset=utf-8');
-                }
-                else if (typeof data === 'number') {
-                    this.sendResponse(request, response, data.toString(), 'text/plain; charset=utf-8');
-                }
-                else if (data instanceof Document) {
-                    this.sendResponse(request, response, await data.toString(), 'text/html; charset=utf-8');
-                }
-                else if (data === undefined || data === null) {
-                    this.sendResponse(request, response, '', 'text/plain; charset=utf-8');
-                }
-                else {
-                    this.sendResponse(request, response, JSON.stringify(data, null, 4), 'application/json; charset=utf-8');
-                }
-            },
-            redirect: (to, statusCode = 302) => {
-                this.redirect(response, to, statusCode);
-            },
-            show404: async () => {
-                this.app.emit('pageNotFound', context);
-                response.statusCode = 404;
-                const res = await this.pageNotFoundCallback.apply(this.app, [context]);
-                if (res instanceof Document) {
-                    await context.respondWith(res);
-                }
-            }
-        };
-        if (handler !== null) {
-            if (!handler.staticAsset) {
-                const results = await this.app.emit('beforeRequestHandler', context);
-                if (results.includes(false)) {
-                    context.response.end();
-                    return;
-                }
-                try {
-                    await this.parseBody(context);
-                }
-                catch (e) {
-                    console.error(`Error parsing request body: ${e.message}`);
-                }
-                const URIArgs = this.extractURIArguments(uri, handler.match);
-                context.args = URIArgs;
-            }
-            try {
-                const response = await handler.callback.apply(handler.scope, [context]);
-                if (!context.response.headersSent) {
-                    await context.respondWith(response);
-                }
-            }
-            catch (e) {
-                console.log('Error executing request handler ', e, handler.callback.toString());
-            }
-            if (!handler.staticAsset) {
-                await this.app.emit('afterRequestHandler', context);
-            }
-        }
-        else {
-            let staticAsset = false;
-            if (this.app.config.url.isAsset(context.request.url || '')) {
-                const basePath = context.request.url?.startsWith('/assets/ts/') ? './' : '../';
-                const assetPath = path.resolve(basePath + context.request.url);
-                if (existsSync(assetPath)) {
-                    await this.app.emit('beforeAssetAccess', context);
-                    const extension = (context.request.url || '').split('.').pop();
-                    let contentType = 'application/javascript';
-                    if (extension) {
-                        const typeByExtension = this.app.contentType(extension);
-                        if (typeByExtension) {
-                            contentType = typeByExtension;
-                        }
-                    }
-                    this.sendResponse(request, response, readFileSync(assetPath), contentType);
-                    staticAsset = true;
-                    await this.app.emit('afterAssetAccess', context);
-                }
-            }
-            if (!staticAsset) {
-                await context.show404();
-            }
+        try {
+            const ctx = new RequestContext(this.app, request, response, handler);
+            await ctx.exec();
         }
-        response.end();
-    }
-    extractURIArguments(uri, match) {
-        if (match instanceof RegExp) {
-            const matches = match.exec(uri);
-            if (matches) {
-                return {
-                    matches
-                };
+        catch (e) {
+            if (e instanceof StructuredError) {
+                e.log();
             }
             else {
-                return {};
+                throw e;
             }
         }
-        const uriArgs = {};
-        const segments = uri.split('/');
-        match.forEach((segmentPattern, i) => {
-            if (segmentPattern.name) {
-                uriArgs[segmentPattern.name] = segmentPattern.type === 'number' ? parseInt(segments[i]) : segments[i];
-            }
-        });
-        return uriArgs;
     }
     patternToSegments(pattern) {
         const segments = [];
@@ -244,81 +133,6 @@ export class Request {
         });
         return segments;
     }
-    async parseBody(ctx) {
-        if (ctx.request.headers['content-type']) {
-            ctx.bodyRaw = await this.dataRaw(ctx.request);
-            if (ctx.request.headers['content-type'].indexOf('urlencoded') > -1) {
-                const bodyRaw = ctx.bodyRaw.toString('utf-8');
-                try {
-                    ctx.body = queryStringDecode(bodyRaw);
-                }
-                catch (e) {
-                    console.error(`Error parsing urlencoded request body for request to ${ctx.request.url}, (${e.message}).
-                    Raw data:
-                        ${bodyRaw}
-
-                    `);
-                }
-            }
-            else if (ctx.request.headers['content-type'].indexOf('multipart/form-data') > -1) {
-                let boundary = /^multipart\/form-data; boundary=(.+)$/.exec(ctx.request.headers['content-type']);
-                if (boundary) {
-                    boundary = `--${boundary[1]}`;
-                    try {
-                        ctx.body = Request.parseBodyMultipart(ctx.bodyRaw.toString('utf-8'), boundary);
-                    }
-                    catch (e) {
-                        console.error(`Error parsing multipart request body for request to ${ctx.request.url}, (${e.message}).
-                        Raw data:
-                            ${ctx.bodyRaw.toString('utf-8')}
-                            
-                        `);
-                    }
-                    try {
-                        ctx.files = Request.multipartBodyFiles(ctx.bodyRaw.toString('binary'), boundary);
-                    }
-                    catch (e) {
-                        console.error(`Error parsing multipart request body files for request to ${ctx.request.url}, (${e.message}).
-                        Raw data:
-                            ${ctx.bodyRaw.toString('utf-8')}
-                            
-                        `);
-                    }
-                }
-            }
-            else if (ctx.request.headers['content-type'].indexOf('application/json') > -1) {
-                try {
-                    ctx.body = JSON.parse(ctx.bodyRaw.toString());
-                }
-                catch (e) {
-                    ctx.body = undefined;
-                }
-            }
-        }
-        return;
-    }
-    dataRaw(request) {
-        const chunks = [];
-        return new Promise((resolve, reject) => {
-            request.on('data', (chunk) => {
-                chunks.push(chunk);
-            });
-            request.on('close', () => {
-                const size = chunks.reduce((prev, curr) => {
-                    return prev + curr.length;
-                }, 0);
-                const data = Buffer.concat(chunks, size);
-                resolve(data);
-            });
-            request.on('error', (e) => {
-                reject(e);
-            });
-        });
-    }
-    redirect(response, to, statusCode = 302) {
-        response.setHeader('Location', to);
-        response.writeHead(statusCode);
-    }
     async loadHandlers(basePath) {
         let routesPath;
         if (basePath) {
@@ -348,76 +162,5 @@ export class Request {
                 }
             }
         }
-        return;
-    }
-    static queryStringDecode(queryString, initialValue = {}, trimValues = true) {
-        return queryStringDecode(queryString, initialValue, trimValues);
-    }
-    static parseBodyMultipart(bodyRaw, boundary) {
-        const pairsRaw = bodyRaw.split(boundary);
-        const pairs = pairsRaw.map((pair) => {
-            const parts = pair.split(/\r?\n\r?\n/, 2).filter((part) => { return part.length > 0; });
-            if (parts.length > 0) {
-                const header = parts[0];
-                const data = typeof parts[1] === 'string' ? parts[1].trim() : '';
-                const headerParts = /Content-Disposition: form-data; name="([^\r\n"]+)"/m.exec(header);
-                if (headerParts) {
-                    return {
-                        key: headerParts[1],
-                        value: data
-                    };
-                }
-            }
-            return null;
-        });
-        const urlEncoded = pairs.reduce((prev, curr) => {
-            if (curr !== null) {
-                prev.push(`${curr.key}=${encodeURIComponent(curr.value.replaceAll('&', '%26'))}`);
-            }
-            return prev;
-        }, []).join('&');
-        return queryStringDecode(urlEncoded);
-    }
-    static multipartBodyFiles(bodyRaw, boundary) {
-        let files = {};
-        const pairsRaw = bodyRaw.split(boundary);
-        pairsRaw.map((pair) => {
-            const parts = /Content-Disposition: form-data; name="(.+?)"; filename="(.+?)"\r\nContent-Type: (.*)\r\n\r\n([\s\S]+)$/m.exec(pair);
-            if (parts) {
-                const file = {
-                    data: Buffer.from(parts[4].substring(0, parts[4].length - 2).trim(), 'binary'),
-                    fileName: parts[2],
-                    type: parts[3]
-                };
-                files = mergeDeep(files, queryStringDecodedSetValue(parts[1], file));
-            }
-            return null;
-        });
-        return files;
-    }
-    sendResponse(request, response, buffer, contentType) {
-        const mimeType = contentType.split(';')[0];
-        const gzipResponse = this.app.config.gzip.enabled &&
-            this.app.config.gzip.types.includes(mimeType) &&
-            request.headers['accept-encoding']?.includes('gzip') &&
-            buffer.length >= this.app.config.gzip.minSize;
-        if (!response.hasHeader('Content-Type')) {
-            response.setHeader('Content-Type', contentType);
-        }
-        if (typeof buffer === 'string') {
-            buffer = Buffer.from(buffer, 'utf-8');
-        }
-        if (gzipResponse) {
-            response.setHeader('Content-Encoding', 'gzip');
-            const compressed = zlib.gzipSync(buffer, {
-                level: this.app.config.gzip.compressionLevel
-            });
-            response.setHeader('Content-Length', compressed.length);
-            response.write(compressed);
-        }
-        else {
-            response.setHeader('Content-Length', buffer.length);
-            response.write(buffer);
-        }
     }
 }