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

structured-fw 1.3.4 → 1.5.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 (13) hide show

package/README.md +76 -27
package/build/system/client/ClientComponent.d.ts +1 -1
package/build/system/server/Application.d.ts +2 -1
package/build/system/server/Application.js +7 -0
package/build/system/server/Document.d.ts +3 -3
package/build/system/server/Layout.d.ts +2 -2
package/build/system/server/Request.d.ts +2 -10
package/build/system/server/Request.js +3 -268
package/build/system/server/RequestContext.d.ts +41 -0
package/build/system/server/RequestContext.js +307 -0
package/build/system/types/component.types.d.ts +9 -10
package/build/system/types/request.types.d.ts +1 -19
package/package.json +2 -1

package/README.md CHANGED Viewed

@@ -29,6 +29,13 @@ npm init -y
 npm install @types/node
 ```
+## Set type to "module" in package.json
+```
+...
+  "type": "module",
+...
+```
 *If you have TypeScript installed globally then you can skip the following*\
 `npm install --save-dev typescript`
@@ -258,44 +265,66 @@ Route file name has no effect on how the route (request handler) behaves, the on
 RequestContext is created for every received request. It contains all the data related to the request, as well as data you include in `RequestContextData`.
 All request handlers receive a `RequestContext` as the first argument. Your component server side part also receives `RequestContext` as the second argument.
 ```
-type RequestContext<Body extends LooseObject | undefined = LooseObject> = {
-    request: IncomingMessage,
-    response: ServerResponse,
-    args: URIArguments,
-    handler: null|RequestHandler,
+class RequestContext<Body extends LooseObject | undefined = LooseObject> = {
+    app: Application;
+    uri: string;
-    cookies: Record<string, string>,
+    request: IncomingMessage;
+    response: ServerResponse;
+    // captured URI arguments
+    // for example if the requested URI was /users/8 and the pattern was /users/(userId:num)
+    // args will be { userId: 8 }
+    args: URIArguments;
+    // request cookies parsed into an object
+    cookies: Record<string, string>;
     // POSTed data, parsed to object
-    body?: LooseObject,
+    body?: LooseObject;
-    bodyRaw?: Buffer,
+    bodyRaw?: Buffer;
     // files extracted from request body
-    files?: Record<string, RequestBodyRecordValue>,
+    files?: Record<string, RequestBodyRecordValue>;
     // user defined data
-    data: RequestContextData,
+    data: RequestContextData;
-    // if session is started and user has visited any page
-    sessionId?: string,
+    // defined if session is started and user has visited any page
+    sessionId?: string;
-    // true if x-requested-with header is received and it equals 'xmlhttprequest'
-    isAjax: boolean,
+    // true if x-requested-with header value is 'xmlhttprequest'
+    isAjax: () => boolean;
     // time when request was received (unix timestamp in milliseconds)
-    timeStart: number,
+    timeStart: number;
+    // URL GET arguments, for example if the URI isss /users?id=8
+    // getArgs would be { id: '8' }
+    getArgs: PostedDataDecoded;
-    // URL GET arguments
-    getArgs: PostedDataDecoded,
+    // create a Document and load given component
+    createDocument: (title: string, component: string, data?: LooseObject) => Promise<Document>;
+    // create a Document using provided layout
+    layoutDocument: layoutDocument(
+        layout: Layout,
+        title: string,
+        component: string,
+        data?: LooseObject,
+        attributes?: Record<string, string>
+    ) => Promise<Document>;
     // send given data as a response
-    respondWith: (data: any) => Promise<void>,
+    respondWith: (data: any) => Promise<void>;
-    // redirect to given url, with given statusCode
-    redirect: (to: string, statusCode?: number) => void,
+    // redirect to given URI, with given statusCode (default 302)
+    redirect: (to: string, statusCode?: number) => void;
-    // show a 404 page
+    // 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
     show404: () => Promise<void>
 }
 ```
@@ -371,6 +400,15 @@ app.request.on('GET', '/home', async (ctx) => {
 });
 ```
+Above code could be simplified using RequestContext.createDocument method as:
+```
+app.request.on('GET', '/home', async (ctx) => {
+    return await ctx.createDocument('Home', 'Home');
+});
+```
+Much shorter, but slightly confusing due to bad example (both arguments being 'Home'). First argument is the document title, second argument is the name of the component you want to load.
 > [!TIP]
 > Since version 0.8.4 Document extends EventEmitter, and "componentCreated" event is emitted whenever a component instance is created within the Document.\
 > This makes the following possible:
@@ -444,13 +482,24 @@ That was the simplest possible example, let's make it more interesting by adding
 ### Component server-side code
 Create a new file `/app/views/HelloWorld/HelloWorld.ts` (server side component code):
 ```
+import { Application } from 'structured-fw/Application';
 import { ComponentScaffold } from 'structured-fw/Types';
-export default class HelloWorld implements ComponentScaffold {
-    async getData(): Promise<{
-        luckyNumber: number
-    }> {
+import { RequestContext } from 'structured-fw/RequestContext';
+type ComponentInput = {
+    name: string,
+}
+type ComponentOutput = {
+    greetName: string,
+    luckyNumber: number,
+}
+export default class HelloWorld implements ComponentScaffold<ComponentInput, ComponentOutput> {
+    async getData(data: ComponentInput, ctx: RequestContext, app: Application): Promise<ComponentOutput> {
         return {
-            luckyNumber: this.num()
+            greetName: data.name,
+            luckyNumber: this.num(),
         }
     }
@@ -462,7 +511,7 @@ export default class HelloWorld implements ComponentScaffold {
 Update `HelloWorld.html`:
 ```
-Hello, World!<br>
+Hello, {{greetName}}!<br>
 Your lucky number is {{luckyNumber}}
 ```

package/build/system/client/ClientComponent.d.ts CHANGED Viewed

@@ -60,7 +60,7 @@ export declare class ClientComponent extends EventEmitter {
     private destroy;
     remove(): Promise<void>;
     bind<T extends any>(element: ClientComponent, event: string, callback: EventEmitterCallback<T>): void;
-    bind<T extends LooseObject | undefined>(element: HTMLElement | Window | Array<HTMLElement | Window>, event: keyof HTMLElementEventMap | Array<keyof HTMLElementEventMap>, callback: ClientComponentEventCallback<T>): void;
+    bind<T extends LooseObject | undefined, Evt extends Event = Event>(element: HTMLElement | Window | Array<HTMLElement | Window>, event: keyof HTMLElementEventMap | Array<keyof HTMLElementEventMap>, callback: ClientComponentEventCallback<T, Evt>): void;
     unbind<T extends LooseObject | undefined = undefined>(element: HTMLElement | Window | ClientComponent, event: keyof HTMLElementEventMap | Array<keyof HTMLElementEventMap>, callback: ClientComponentEventCallback<T> | EventEmitterCallback<T>): void;
     private unbindOwn;
     private unbindAll;

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

@@ -2,13 +2,13 @@ import { Server } from 'node:http';
 import { ApplicationEvents } from '../types/application.types.js';
 import { StructuredConfig } from '../types/structured.types.js';
 import { LooseObject } from '../types/general.types.js';
-import { RequestContext } from "../types/request.types.js";
 import { Document } from './Document.js';
 import { Components } from './Components.js';
 import { Session } from './Session.js';
 import { Request } from './Request.js';
 import { Handlebars } from './Handlebars.js';
 import { Cookies } from './Cookies.js';
+import { RequestContext } from './RequestContext.js';
 export declare class Application {
     readonly config: StructuredConfig;
     initialized: boolean;
@@ -32,6 +32,7 @@ export declare class Application {
     contentType(extension: string): string | false;
     registerPlugin<Opt extends Readonly<LooseObject>>(callback: (app: Application, options: Opt) => void | Promise<void>, opts: NoInfer<Opt>): Promise<void>;
     private respondWithComponent;
+    directory(uri?: string): string;
     memoryUsage(): NodeJS.MemoryUsage;
     printMemoryUsage(): void;
 }

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

@@ -167,6 +167,13 @@ export class Application {
         }
         return false;
     }
+    directory(uri) {
+        const dir = path.resolve('../');
+        if (typeof uri === 'string') {
+            return path.resolve(dir, uri.startsWith('/') ? uri.substring(1) : uri);
+        }
+        return dir;
+    }
     memoryUsage() {
         return process.memoryUsage();
     }

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

@@ -1,10 +1,10 @@
 import { ServerResponse } from 'node:http';
 import { LooseObject } from '../types/general.types.js';
 import { Initializers } from '../types/component.types.js';
-import { RequestContext } from "../types/request.types.js";
 import { Application } from './Application.js';
 import { DocumentHead } from './DocumentHead.js';
 import { Component } from './Component.js';
+import { RequestContext } from './RequestContext.js';
 export declare class Document extends Component<{
     'componentCreated': Component;
     'beforeRender': void;
@@ -17,9 +17,9 @@ export declare class Document extends Component<{
     initializers: Initializers;
     initializersInitialized: boolean;
     componentIds: Array<string>;
-    ctx: undefined | RequestContext;
+    ctx: RequestContext;
     appendHTML: string;
-    constructor(app: Application, title: string, ctx?: RequestContext<any>);
+    constructor(app: Application, title: string, ctx: RequestContext<any>);
     push(response: ServerResponse): void;
     body(): string;
     initInitializers(): Record<string, string>;

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

@@ -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/Request.d.ts CHANGED Viewed

@@ -1,24 +1,16 @@
 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;
+    pageNotFoundCallback: RequestCallback<void | Document, LooseObject | undefined>;
     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 CHANGED Viewed

@@ -1,9 +1,6 @@
-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";
 export class Request {
     constructor(app) {
         this.pageNotFoundCallback = async ({ response }) => {
@@ -90,128 +87,12 @@ 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();
-            }
-        }
-        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;
+        new RequestContext(this.app, request, response, handler, this.pageNotFoundCallback);
     }
     patternToSegments(pattern) {
         const segments = [];
@@ -244,81 +125,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 +154,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);
-        }
     }
 }

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

@@ -0,0 +1,41 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+import { LooseObject, PostedDataDecoded, RequestBodyRecordValue, RequestCallback, 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> {
+    readonly app: Application;
+    uri: string;
+    private readonly pageNotFoundCallback;
+    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, pageNotFoundCallback: RequestCallback<void | Document, LooseObject | undefined>);
+    private exec;
+    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;
+    private error;
+}

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

@@ -0,0 +1,307 @@
+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";
+export class RequestContext {
+    constructor(app, request, response, handler, pageNotFoundCallback) {
+        this.args = {};
+        this.cookies = {};
+        this.data = {};
+        this.getArgs = {};
+        this.streamingData = false;
+        this.timeStart = Date.now();
+        this.uri = request.url || '/';
+        this.app = app;
+        this.request = request;
+        this.response = response;
+        this.handler = handler;
+        this.body = undefined;
+        this.pageNotFoundCallback = pageNotFoundCallback;
+        this.exec();
+    }
+    async exec() {
+        this.initGetArgs();
+        this.parseCookies();
+        if (this.handler) {
+            try {
+                await this.parseBody();
+            }
+            catch (e) {
+                this.error(e);
+            }
+        }
+        await this.handle();
+    }
+    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.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);
+        }
+    }
+    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) {
+                    console.error(`Error parsing urlencoded request body for request to ${this.request.url}, (${e.message}).
+                    Raw data:
+                        ${bodyRaw}
+                    `);
+                }
+            }
+            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) {
+                        console.error(`Error parsing multipart request body for request to ${this.request.url}, (${e.message}).
+                        Raw data:
+                            ${this.bodyRaw.toString('utf-8')}
+                        `);
+                    }
+                    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')}
+                        `);
+                    }
+                }
+            }
+            else if (this.request.headers['content-type'].indexOf('application/json') > -1) {
+                try {
+                    this.body = JSON.parse(this.bodyRaw.toString());
+                }
+                catch (e) {
+                    this.body = undefined;
+                }
+            }
+        }
+    }
+    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) {
+                console.log('Error executing request handler ', e, this.handler.callback.toString());
+            }
+            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';
+    }
+    error(e) {
+        const message = typeof e === 'string' ? e : e.message;
+        console.error(`Error in request to ${this.uri}: ${message}`);
+    }
+}

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: {
@@ -26,15 +26,14 @@ export type ComponentEntry = {
     attributes?: Record<string, string>;
     initializer?: InitializerFunction;
 };
-export interface ComponentScaffold<T extends LooseObject = LooseObject, K extends KeysOfUnion<T> = KeysOfUnion<T>> {
+export interface ComponentScaffold<I extends LooseObject = LooseObject, O extends LooseObject = LooseObject, K extends KeysOfUnion<O> = KeysOfUnion<O>> {
     tagName?: string;
     exportData?: boolean;
     exportFields?: ReadonlyArray<K>;
     static?: boolean;
-    deferred?: (data: Record<string, any>, ctx: RequestContext | undefined, app: Application) => boolean;
+    deferred?: (data: Record<string, any>, ctx: RequestContext, app: Application) => boolean;
     attributes?: Record<string, string>;
-    getData: (this: ComponentScaffold, data: LooseObject, ctx: undefined | RequestContext, app: Application, component: Component) => Promise<T | void>;
-    [key: string]: any;
+    getData: (this: ComponentScaffold<I, O>, data: I, ctx: RequestContext, app: Application, component: Component) => Promise<O | void>;
 }
 export type ComponentEvents = {
     componentCreated: Component;
@@ -47,13 +46,13 @@ export type ClientComponentTransition = {
 };
 export type ClientComponentTransitionEvent = 'show' | 'hide';
 export type ClientComponentTransitions = Record<ClientComponentTransitionEvent, ClientComponentTransition>;
-export type ClientComponentBoundEvent<T extends LooseObject | undefined, E extends HTMLElement | Window | ClientComponent> = {
-    element: E;
+export type ClientComponentBoundEvent<Data extends LooseObject | undefined, Element extends HTMLElement | Window | ClientComponent, Evt extends Event = Event> = {
+    element: Element;
     event: keyof HTMLElementEventMap;
-    callback: E extends ClientComponent ? EventEmitterCallback<T> : (e: Event) => void;
-    callbackOriginal: E extends ClientComponent ? EventEmitterCallback<T> : ClientComponentEventCallback<T>;
+    callback: Element extends ClientComponent ? EventEmitterCallback<Data> : (e: Event) => void;
+    callbackOriginal: Element extends ClientComponent ? EventEmitterCallback<Data> : ClientComponentEventCallback<Data, Evt>;
 };
-export type ClientComponentEventCallback<T> = (e: Event, data: T, element: HTMLElement | Window) => void;
+export type ClientComponentEventCallback<T, E extends Event = Event> = (e: E, data: T, element: HTMLElement | Window) => void;
 export type InitializerFunction = (this: ClientComponent, ctx: InitializerFunctionContext) => Promise<void>;
 export type Initializers = {
     [key: string]: InitializerFunction;

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.3.4",
+  "version": "1.5.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",