structured-fw 0.7.2

package/build/system/server/FormValidation.js

@@ -0,0 +1,197 @@
+export class FormValidation {
+    constructor() {
+        this.fieldRules = [];
+        this.singleError = false;
+        this.validators = {
+            'required': async (data, field) => {
+                if (!(field in data)) {
+                    return false;
+                }
+                const value = data[field];
+                if (typeof value !== 'string') {
+                    return false;
+                }
+                return value.trim().length > 0;
+            },
+            'number': async (data, field) => {
+                const value = data[field];
+                if (typeof value !== 'string') {
+                    return false;
+                }
+                return /^-?\d+$/.test(value);
+            },
+            'float': async (data, field) => {
+                const value = data[field];
+                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 !== '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 !== '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);
+            }
+        };
+        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`;
+            }
+        };
+    }
+    addRule(fieldName, nameHumanReadable, rules) {
+        const rule = {
+            field: [fieldName, nameHumanReadable],
+            rules
+        };
+        this.fieldRules.push(rule);
+    }
+    registerValidator(name, validator, decorator) {
+        this.validators[name] = validator;
+        if (typeof decorator === 'function') {
+            this.decorators[name] = decorator;
+        }
+    }
+    registerDecorator(name, decorator) {
+        this.decorators[name] = decorator;
+    }
+    async validate(data) {
+        const result = {
+            valid: true,
+            errors: {}
+        };
+        for (let i = 0; i < this.fieldRules.length; i++) {
+            const entry = this.fieldRules[i];
+            const isRequired = entry.rules.includes('required');
+            const value = data[entry.field[0]];
+            const possiblyValidDataExists = typeof value === 'string';
+            const isContent = !isRequired && (!possiblyValidDataExists || value.trim().length === 0);
+            if (!isContent) {
+                for (let j = 0; j < entry.rules.length; j++) {
+                    const rule = entry.rules[j];
+                    if (typeof rule === 'function') {
+                        const valid = await rule.apply(this, [data, entry.field[0], 0, entry.rules]);
+                        if (!valid) {
+                            await this.addError(result.errors, data, entry.field, 'callback');
+                        }
+                    }
+                    else {
+                        if (typeof rule === 'string') {
+                            if (this.validators[rule]) {
+                                const valid = await this.validators[rule].apply(this, [data, entry.field[0], 0, entry.rules]);
+                                if (!valid) {
+                                    await this.addError(result.errors, data, entry.field, rule);
+                                }
+                            }
+                        }
+                        else {
+                            const validatorName = rule[0];
+                            const arg = rule[1];
+                            if (this.validators[validatorName]) {
+                                const valid = await this.validators[validatorName].apply(this, [data, entry.field[0], arg, entry.rules]);
+                                if (!valid) {
+                                    await this.addError(result.errors, data, entry.field, validatorName, arg);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        result.valid = Object.keys(result.errors).length == 0;
+        return result;
+    }
+    async addError(errors, data, field, rule, arg) {
+        let errorMessage = '';
+        if (this.decorators[rule]) {
+            errorMessage = await this.decorators[rule](field[1], data, field[0], arg);
+        }
+        else {
+            errorMessage = rule;
+        }
+        if (!this.singleError) {
+            if (!errors[field[0]]) {
+                errors[field[0]] = [];
+            }
+            errors[field[0]].push(errorMessage);
+        }
+        else {
+            if (!errors[field[0]]) {
+                errors[field[0]] = errorMessage;
+            }
+        }
+    }
+}

package/build/system/server/Handlebars.d.ts

@@ -0,0 +1,11 @@
+import { HelperDelegate } from "handlebars";
+import { default as HandlebarsInstance } from 'handlebars';
+import { LooseObject } from "../Types.js";
+export declare class Handlebars {
+    readonly instance: typeof HandlebarsInstance;
+    readonly helpers: Record<string, HelperDelegate>;
+    register(name: string, helper: HelperDelegate): void;
+    loadHelpers(path: string): Promise<void>;
+    applyTo(handlebarsInstance: typeof HandlebarsInstance): void;
+    compile(html: string, data: LooseObject): string;
+}

package/build/system/server/Handlebars.js

@@ -0,0 +1,34 @@
+import { default as HandlebarsInstance } from 'handlebars';
+export class Handlebars {
+    constructor() {
+        this.instance = HandlebarsInstance;
+        this.helpers = {};
+    }
+    register(name, helper) {
+        this.helpers[name] = helper;
+        this.instance.registerHelper(name, helper);
+    }
+    async loadHelpers(path) {
+        try {
+            const helpers = await import(path);
+            if (!('default' in helpers)) {
+                throw new Error('File has no default export, expected default: Record<string, HelperDelegate>');
+            }
+            for (const name in helpers.default) {
+                this.register(name, helpers.default[name]);
+            }
+        }
+        catch (e) {
+            throw new Error(e.message);
+        }
+    }
+    applyTo(handlebarsInstance) {
+        for (const name in this.helpers) {
+            handlebarsInstance.registerHelper(name, this.helpers[name]);
+        }
+    }
+    compile(html, data) {
+        const template = this.instance.compile(html);
+        return template(data);
+    }
+}

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

@@ -0,0 +1,21 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { PostedDataDecoded, RequestBodyFile, RequestCallback, RequestMethod } from "../Types.js";
+import { Application } from "./Application.js";
+export declare class Request {
+    private app;
+    constructor(app: Application);
+    pageNotFoundCallback: RequestCallback;
+    private readonly handlers;
+    on(methods: RequestMethod | Array<RequestMethod>, pattern: string | RegExp | Array<string | RegExp>, callback: RequestCallback, 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>;
+}

package/build/system/server/Request.js

@@ -0,0 +1,356 @@
+import { mergeDeep, queryStringDecode, queryStringDecodedSetValue } from "../Util.js";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import { Document } from "./Document.js";
+export class Request {
+    constructor(app) {
+        this.pageNotFoundCallback = async ({ response }) => {
+            response.statusCode = 404;
+            response.write('Page not found');
+            response.end();
+        };
+        this.handlers = [];
+        this.app = app;
+    }
+    on(methods, pattern, callback, scope, isStaticAsset = false) {
+        if (!(methods instanceof Array)) {
+            methods = [methods];
+        }
+        if (scope === undefined) {
+            scope = this.app;
+        }
+        if (pattern instanceof Array) {
+            pattern.forEach((p) => {
+                this.on(methods, p, callback, scope);
+            });
+            return;
+        }
+        const match = (typeof pattern === 'string' ? this.patternToSegments(pattern) : pattern);
+        const handler = {
+            match,
+            methods,
+            callback,
+            scope,
+            staticAsset: isStaticAsset
+        };
+        this.handlers.push(handler);
+        this.handlers.sort((a, b) => {
+            const valA = a.match instanceof RegExp ? 1 : 0;
+            const valB = b.match instanceof RegExp ? 1 : 0;
+            return valA - valB;
+        });
+    }
+    getHandler(uri, method) {
+        const segments = uri.split('/');
+        let possible = this.handlers.filter((handler) => {
+            return handler.methods.includes(method) && (handler.match instanceof RegExp || handler.match.length === segments.length);
+        });
+        for (let i = 0; i < segments.length; i++) {
+            possible = possible.filter((handler) => {
+                if (handler.match instanceof RegExp) {
+                    return handler.match.test(uri);
+                }
+                else {
+                    const pattern = handler.match[i].pattern;
+                    if (typeof pattern === 'string') {
+                        return pattern === segments[i];
+                    }
+                    return pattern.test(segments[i]);
+                }
+            });
+        }
+        if (possible.length === 0) {
+            return null;
+        }
+        if (possible.length > 1) {
+            console.warn(`Multiple request handlers for ${uri}`);
+        }
+        possible.sort((a, b) => {
+            if (a.match instanceof Array && b.match instanceof Array) {
+                for (let i = a.match.length - 1; i > -1; i--) {
+                    const aVal = a.match[i].pattern instanceof RegExp ? 1 : 0;
+                    const bVal = b.match[i].pattern instanceof RegExp ? 1 : 0;
+                    if (aVal != bVal) {
+                        return aVal - bVal;
+                    }
+                }
+                return 0;
+            }
+            const aVal = a.match instanceof RegExp ? 1 : 0;
+            const bVal = b.match instanceof RegExp ? 1 : 0;
+            return aVal - bVal;
+        });
+        return possible[0];
+    }
+    async handle(request, response) {
+        const requestMethod = request.method;
+        let uri = request.url || '/';
+        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: {},
+            getArgs,
+            cookies: this.app.cookies.parse(request),
+            isAjax: request.headers['x-requested-with'] == 'xmlhttprequest',
+            respondWith: function (data) {
+                if (typeof data === 'string' || Buffer.isBuffer(data)) {
+                    response.write(data);
+                }
+                else if (typeof data === 'number') {
+                    response.write(data.toString());
+                }
+                else if (data instanceof Document) {
+                    response.setHeader('Content-Type', 'text/html');
+                    response.write(data.toString());
+                }
+                else if (data === undefined || data === null) {
+                    response.write('');
+                }
+                else {
+                    response.setHeader('Content-Type', 'application/json');
+                    response.write(JSON.stringify(data, null, 4));
+                }
+            },
+            redirect: (to, statusCode = 302) => {
+                this.redirect(response, to, statusCode);
+            },
+            show404: async () => {
+                await this.pageNotFoundCallback.apply(this.app, [context]);
+                this.app.emit('pageNotFound', context);
+            }
+        };
+        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) {
+                    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();
+                    if (extension) {
+                        const contentType = this.app.contentType(extension);
+                        if (contentType) {
+                            response.setHeader('Content-Type', contentType);
+                        }
+                    }
+                    response.write(readFileSync(assetPath));
+                    staticAsset = true;
+                    await this.app.emit('afterAssetAccess', context);
+                }
+            }
+            if (!staticAsset) {
+                await context.show404();
+            }
+        }
+        response.end();
+    }
+    extractURIArguments(uri, match) {
+        if (match instanceof RegExp) {
+            const matches = match.exec(uri);
+            if (matches) {
+                return {
+                    matches
+                };
+            }
+            else {
+                return {};
+            }
+        }
+        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 = [];
+        const segmentsIn = pattern.split('/');
+        segmentsIn.forEach((segmentIn) => {
+            const named = /^\([^\/]+\)$/.test(segmentIn);
+            const segmentPattern = {
+                pattern: segmentIn,
+                type: 'string'
+            };
+            if (named) {
+                const nameParts = /^\(([^\/:\)]+)/.exec(segmentIn);
+                const isNumber = /:num\)$/.test(segmentIn);
+                if (nameParts) {
+                    segmentPattern.name = nameParts[1];
+                    if (isNumber) {
+                        segmentPattern.pattern = /^(\d+)$/;
+                        segmentPattern.type = 'number';
+                    }
+                    else {
+                        segmentPattern.pattern = /^([^\/]+)$/;
+                        segmentPattern.type = 'string';
+                    }
+                }
+                else {
+                    console.warn(`Invalid URI segment pattern ${segmentIn} in URI ${pattern}`);
+                }
+            }
+            segments.push(segmentPattern);
+        });
+        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) {
+                ctx.body = queryStringDecode(ctx.bodyRaw.toString('utf-8'));
+            }
+            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]}`;
+                    ctx.body = Request.parseBodyMultipart(ctx.bodyRaw.toString('utf-8'), boundary);
+                    ctx.files = Request.multipartBodyFiles(ctx.bodyRaw.toString('binary'), boundary);
+                }
+            }
+            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) {
+            routesPath = basePath;
+        }
+        else {
+            routesPath = path.resolve((this.app.config.runtime === 'Node.js' ? '../build/' : './') + this.app.config.routes.path);
+        }
+        const files = readdirSync(routesPath);
+        for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            if (!(file.endsWith('.js') || file.endsWith('.ts'))) {
+                continue;
+            }
+            const filePath = path.resolve(routesPath + '/' + file);
+            const isDirectory = statSync(filePath).isDirectory();
+            if (isDirectory) {
+                await this.loadHandlers(filePath);
+            }
+            else {
+                const fn = (await import('file:///' + filePath)).default;
+                if (typeof fn === 'function') {
+                    fn(this.app);
+                }
+            }
+        }
+        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 = /Content-Disposition: form-data; name="([^\r\n"]+)"\r?\n\r?\n([^$]+)/m.exec(pair);
+            if (parts) {
+                return {
+                    key: parts[1],
+                    value: parts[2]
+                };
+            }
+            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;
+    }
+}

package/build/system/server/Session.d.ts

@@ -0,0 +1,23 @@
+import { LooseObject, SessionEntry } from '../Types.js';
+import { Application } from './Application.js';
+export declare class Session {
+    application: Application;
+    enabled: boolean;
+    sessions: {
+        [key: string]: SessionEntry;
+    };
+    constructor(app: Application);
+    start(): void;
+    stop(): void;
+    private sessionInit;
+    private generateId;
+    private garbageCollect;
+    setValue(sessionId: string | undefined, key: string, value: any): void;
+    getValue<T>(sessionId: string | undefined, key: string): T | null;
+    getClear<T>(sessionId: string | undefined, key: string): T | null;
+    removeValue(sessionId: string | undefined, key: string): void;
+    clear(sessionId: string | undefined): void;
+    extract(sessionId: string | undefined, keys: Array<string | {
+        [keyInSession: string]: string;
+    }>): LooseObject;
+}