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

structured-fw 1.4.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 (32) hide show

package/README.md +64 -23
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 +3 -2
package/build/system/server/Application.js +19 -7
package/build/system/server/Component.js +15 -7
package/build/system/server/Components.js +3 -2
package/build/system/server/Document.d.ts +1 -1
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.d.ts +2 -2
package/build/system/server/Layout.js +4 -0
package/build/system/server/Request.d.ts +1 -11
package/build/system/server/Request.js +12 -269
package/build/system/server/RequestContext.d.ts +43 -0
package/build/system/server/RequestContext.js +322 -0
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/build/system/types/component.types.d.ts +1 -1
package/build/system/types/request.types.d.ts +1 -19
package/package.json +2 -1

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

@@ -0,0 +1,43 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+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 handler;
+    readonly request: IncomingMessage;
+    readonly response: ServerResponse;
+    args: URIArguments;
+    cookies: Record<string, string>;
+    body: Body;
+    bodyRaw?: Buffer;
+    files?: Record<string, RequestBodyRecordValue>;
+    data: RequestContextData;
+    sessionId?: string;
+    getArgs: PostedDataDecoded;
+    readonly timeStart: number;
+    private streamingData;
+    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>;
+    layoutDocument(layout: Layout, title: string, component: string, data?: LooseObject, attributes?: Record<string, string>): Promise<Document>;
+    show404(): Promise<void>;
+    private initGetArgs;
+    private parseCookies;
+    redirect(to: string, statusCode?: number): void;
+    private dataRaw;
+    private parseBody;
+    private parseBodyMultipart;
+    private multipartBodyFiles;
+    private extractURIArguments;
+    private handle;
+    isAjax(): boolean;
+    duration(): number;
+    complete(): boolean;
+}

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

@@ -0,0 +1,322 @@
+import zlib from "node:zlib";
+import { mergeDeep, queryStringDecode, queryStringDecodedSetValue } from "../Util.js";
+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 {
+    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;
+        this.request = request;
+        this.response = response;
+        this.handler = handler;
+        this.body = undefined;
+    }
+    async exec() {
+        if (this.executionStartedAt !== null) {
+            return;
+        }
+        this.executionStartedAt = Date.now();
+        try {
+            this.initGetArgs();
+            this.parseCookies();
+            if (this.handler) {
+                await this.parseBody();
+            }
+            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);
+        }
+    }
+    async respondWith(data) {
+        if (typeof data === 'string' || Buffer.isBuffer(data)) {
+            this.sendResponse(data, 'text/plain; charset=utf-8');
+        }
+        else if (typeof data === 'number') {
+            this.sendResponse(data.toString(), 'text/plain; charset=utf-8');
+        }
+        else if (data instanceof Document) {
+            this.sendResponse(await data.toString(), 'text/html; charset=utf-8');
+        }
+        else if (data === undefined || data === null) {
+            this.sendResponse('', 'text/plain; charset=utf-8');
+        }
+        else if (data instanceof ReadStream) {
+            this.streamingData = true;
+            data.once('end', () => {
+                this.response.end();
+            });
+            data.pipe(this.response);
+        }
+        else {
+            this.sendResponse(JSON.stringify(data, null, 4), 'application/json; charset=utf-8');
+        }
+    }
+    sendResponse(buffer, contentType) {
+        const mimeType = contentType.split(';')[0];
+        const gzipResponse = this.app.config.gzip.enabled &&
+            this.app.config.gzip.types.includes(mimeType) &&
+            this.request.headers['accept-encoding']?.includes('gzip') &&
+            buffer.length >= this.app.config.gzip.minSize;
+        if (!this.response.hasHeader('Content-Type')) {
+            this.response.setHeader('Content-Type', contentType);
+        }
+        if (typeof buffer === 'string') {
+            buffer = Buffer.from(buffer, 'utf-8');
+        }
+        if (gzipResponse) {
+            this.response.setHeader('Content-Encoding', 'gzip');
+            const compressed = zlib.gzipSync(buffer, {
+                level: this.app.config.gzip.compressionLevel
+            });
+            this.response.setHeader('Content-Length', compressed.length);
+            this.response.write(compressed);
+        }
+        else {
+            this.response.setHeader('Content-Length', buffer.length);
+            this.response.write(buffer);
+        }
+    }
+    async createDocument(title, component, data) {
+        const doc = new Document(this.app, title, this);
+        await doc.loadComponent(component, data);
+        return doc;
+    }
+    async layoutDocument(layout, title, component, data, attributes) {
+        return await layout.document(this, title, component, data, attributes);
+    }
+    async show404() {
+        this.response.statusCode = 404;
+        const res = await this.app.emit('pageNotFound', this);
+        if (res.length > 0 && !!res[0]) {
+            await this.respondWith(res[0]);
+        }
+    }
+    initGetArgs() {
+        if (this.uri.indexOf('?') > -1) {
+            const uriParts = this.uri.split('?');
+            this.uri = uriParts[0];
+            this.getArgs = queryStringDecode(uriParts[1]);
+        }
+    }
+    parseCookies() {
+        this.cookies = this.app.cookies.parse(this.request);
+    }
+    redirect(to, statusCode = 302) {
+        this.response.setHeader('Location', to);
+        this.response.writeHead(statusCode);
+    }
+    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);
+            });
+        });
+    }
+    async parseBody() {
+        if (this.request.headers['content-type']) {
+            this.bodyRaw = await this.dataRaw(this.request);
+            if (this.request.headers['content-type'].indexOf('urlencoded') > -1) {
+                const bodyRaw = this.bodyRaw.toString('utf-8');
+                try {
+                    this.body = queryStringDecode(bodyRaw);
+                }
+                catch (e) {
+                    throw new StructuredError(`Error parsing urlencoded request body, raw data: ${bodyRaw}`, e);
+                }
+            }
+            else if (this.request.headers['content-type'].indexOf('multipart/form-data') > -1) {
+                let boundary = /^multipart\/form-data; boundary=(.+)$/.exec(this.request.headers['content-type']);
+                if (boundary) {
+                    boundary = `--${boundary[1]}`;
+                    try {
+                        this.body = this.parseBodyMultipart(this.bodyRaw.toString('utf-8'), boundary);
+                    }
+                    catch (e) {
+                        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) {
+                        throw new StructuredError(`Error parsing multipart request body files, raw data ${this.bodyRaw.toString('utf-8')}`, e);
+                    }
+                }
+            }
+            else if (this.request.headers['content-type'].indexOf('application/json') > -1) {
+                try {
+                    this.body = JSON.parse(this.bodyRaw.toString());
+                }
+                catch (e) {
+                    throw new StructuredError(`Error parsing JSON request body, raw data: ${this.bodyRaw.toString('utf-8')}`, e);
+                }
+            }
+        }
+    }
+    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);
+    }
+    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;
+    }
+    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;
+    }
+    async handle() {
+        if (this.handler !== null) {
+            if (!this.handler.staticAsset) {
+                const results = await this.app.emit('beforeRequestHandler', this);
+                if (results.includes(false)) {
+                    this.response.end();
+                    return;
+                }
+                const URIArgs = this.extractURIArguments(this.uri, this.handler.match);
+                this.args = URIArgs;
+            }
+            try {
+                const response = await this.handler.callback.apply(this.handler.scope, [this]);
+                if (!this.response.headersSent) {
+                    await this.respondWith(response);
+                }
+            }
+            catch (e) {
+                throw new StructuredError(`Error executing request handler ${this.handler.callback.name}`, e);
+            }
+            if (!this.handler.staticAsset) {
+                await this.app.emit('afterRequestHandler', this);
+            }
+        }
+        else {
+            let staticAsset = false;
+            if (this.app.config.url.isAsset(this.request.url || '')) {
+                const basePath = this.request.url?.startsWith('/assets/ts/') ? './' : '../';
+                const assetPath = path.resolve(basePath + this.request.url);
+                if (existsSync(assetPath)) {
+                    await this.app.emit('beforeAssetAccess', this);
+                    const extension = (this.request.url || '').split('.').pop();
+                    let contentType = 'application/javascript';
+                    if (extension) {
+                        const typeByExtension = this.app.contentType(extension);
+                        if (typeByExtension) {
+                            contentType = typeByExtension;
+                        }
+                    }
+                    this.sendResponse(readFileSync(assetPath), contentType);
+                    staticAsset = true;
+                    await this.app.emit('afterAssetAccess', this);
+                }
+            }
+            if (!staticAsset) {
+                await this.show404();
+            }
+        }
+        if (!this.streamingData) {
+            this.response.end();
+        }
+    }
+    isAjax() {
+        return this.request.headers['x-requested-with'] == 'xmlhttprequest';
+    }
+    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/build/system/types/component.types.d.ts CHANGED Viewed

@@ -2,9 +2,9 @@ import { ClientComponent } from "../client/ClientComponent.js";
 import { Net } from "../client/Net.js";
 import { Application } from "../server/Application.js";
 import { Component } from "../server/Component.js";
+import { RequestContext } from "../server/RequestContext.js";
 import { EventEmitterCallback } from "./eventEmitter.types.js";
 import { KeysOfUnion, LooseObject } from './general.types.js';
-import { RequestContext } from "./request.types.js";
 export type ComponentEntry = {
     name: string;
     path: {

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

@@ -1,6 +1,6 @@
-import { IncomingMessage, ServerResponse } from "http";
 import { LooseObject } from './general.types.js';
 import { symbolArrays } from "../Symbols.js";
+import { RequestContext } from '../server/RequestContext.js';
 export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 export type RequestCallback<R extends any, Body extends LooseObject | undefined> = (ctx: RequestContext<Body>) => Promise<R>;
 export type RequestHandler = {
@@ -10,24 +10,6 @@ export type RequestHandler = {
     scope: any;
     staticAsset: boolean;
 };
-export type RequestContext<Body extends LooseObject | undefined = LooseObject> = {
-    request: IncomingMessage;
-    response: ServerResponse;
-    args: URIArguments;
-    handler: null | RequestHandler;
-    cookies: Record<string, string>;
-    body: Body;
-    bodyRaw?: Buffer;
-    files?: Record<string, RequestBodyRecordValue>;
-    data: RequestContextData;
-    sessionId?: string;
-    isAjax: boolean;
-    getArgs: PostedDataDecoded;
-    timeStart: number;
-    respondWith: (data: any) => Promise<void>;
-    redirect: (to: string, statusCode?: number) => void;
-    show404: () => Promise<void>;
-};
 export type PostedDataDecoded = Record<string, string | boolean | Array<string | boolean | PostedDataDecoded> | Record<string, string | boolean | Array<string | boolean | PostedDataDecoded>> | Record<string, string | boolean | Array<string | boolean>>>;
 export type RequestBodyRecordValue = string | Array<RequestBodyRecordValue> | {
     [key: string]: RequestBodyRecordValue;

package/package.json CHANGED Viewed

@@ -19,7 +19,7 @@
   "license": "MIT",
   "type": "module",
   "main": "build/index",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "scripts": {
     "develop": "tsc --watch",
     "startDev": "cd build && nodemon --watch '../app/**/*' --watch '../build/**/*' -e js,html,hbs,css index.js",
@@ -49,6 +49,7 @@
   ],
   "exports": {
     "./Types": "./build/system/Types.js",
+    "./RequestContext": "./build/system/server/RequestContext.js",
     "./Symbols": "./build/system/Symbols.js",
     "./Util": "./build/system/Util.js",
     "./Application": "./build/system/server/Application.js",