@entity-access/server-pages 1.0.28 → 1.0.30

package/src/Content.tsx

@@ -1,13 +1,13 @@
 /* eslint-disable no-console */
 import { File } from "buffer";
-import { Response } from "express";
 import XNode from "./html/XNode.js";
 import { parse } from "path";
 import { LocalFile } from "./core/LocalFile.js";
 import SessionUser from "./core/SessionUser.js";
+import { WrappedResponse } from "./core/Wrapped.js";
 
 export interface IPageResult {
-    send(res: Response): Promise<any>;
+    send(res: WrappedResponse): Promise<any>;
 }
 
 export class TempFileResult implements IPageResult {
@@ -34,26 +34,18 @@ export class TempFileResult implements IPageResult {
         this.immutable = immutable;
     }
 
-    send(res: Response<any, Record<string, any>>) {
-        return new Promise<void>((resolve, reject) => {
-            res = res.header("content-disposition", `${this.contentDisposition};filename=${encodeURIComponent(this.file.fileName)}`);
-            res.sendFile(this.file.path,{
-                headers: {
-                    "content-type": this.file.contentType
-                },
-                acceptRanges: true,
-                cacheControl: this.cacheControl,
-                maxAge: this.maxAge,
-                etag: this.etag,
-                immutable: this.immutable,
-                lastModified: false
-            }, (error) => {
-                if(error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
+    send(res: WrappedResponse) {
+        res.setHeader("content-disposition", `${this.contentDisposition};filename=${encodeURIComponent(this.file.fileName)}`);
+        return res.sendFile(this.file.path,{
+            headers: {
+                "content-type": this.file.contentType
+            },
+            acceptRanges: true,
+            cacheControl: this.cacheControl,
+            maxAge: this.maxAge,
+            etag: this.etag,
+            immutable: this.immutable,
+            lastModified: false
         });
     }
 
@@ -86,22 +78,15 @@ export class FileResult implements IPageResult {
         this.fileName = parsed.base;
     }
 
-    send(res: Response<any, Record<string, any>>) {
-        return new Promise<void>((resolve, reject) => {
-            res = res.header("content-disposition", `${this.contentDisposition};filename=${encodeURIComponent(this.fileName)}`);
-            res.sendFile(this.filePath,{
-                acceptRanges: true,
-                cacheControl: this.cacheControl,
-                maxAge: this.maxAge,
-                etag: this.etag,
-                immutable: this.immutable
-            }, (error) => {
-                if(error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
+    send(res: WrappedResponse) {
+    
+        res.setHeader("content-disposition", `${this.contentDisposition};filename=${encodeURIComponent(this.fileName)}`);
+        return res.sendFile(this.filePath,{
+            acceptRanges: true,
+            cacheControl: this.cacheControl,
+            maxAge: this.maxAge,
+            etag: this.etag,
+            immutable: this.immutable
         });
     }
 
@@ -113,8 +98,8 @@ export class Redirect implements IPageResult {
 
     }
 
-    async send(res: Response) {
-        res.redirect(this.status, this.location);
+    async send(res: WrappedResponse) {
+        return res.sendRedirect(this.location);
     }
 
 }
@@ -157,10 +142,10 @@ export default class Content implements IPageResult {
         return p as Content;
     }
 
-    public async send(res: Response, user?: SessionUser) {
+    public async send(res: WrappedResponse, user?: SessionUser) {
         const { status, body, contentType } = this;
-        const r= res.setHeader("content-type", contentType)
-            .status(status);
+        res.setHeader("content-type", contentType);
+        res.statusCode = status;
         if (typeof body === "string") {
             if (status >= 300) {
                 const u = user ? `User: ${user.userID},${user.userName}` : "User: Anonymous";

package/src/Page.tsx

@@ -2,73 +2,21 @@ import busboy from "busboy";
 import HtmlDocument from "./html/HtmlDocument.js";
 import XNode from "./html/XNode.js";
 import Content, { IPageResult, Redirect } from "./Content.js";
-import { ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
-import { Request } from "express";
 import { LocalFile } from "./core/LocalFile.js";
 import TempFolder from "./core/TempFolder.js";
 import SessionUser from "./core/SessionUser.js";
+import { WrappedRequest, WrappedResponse } from "./core/Wrapped.js";
+import { ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
 
 export const isPage = Symbol("isPage");
 
 
 export interface IRouteCheck {
+    scope: ServiceProvider;
     method: string;
     current: string;
     path: string[];
-    sessionUser: SessionUser;
-    params: any;
-}
-
-export interface IPageContext {
-    /**
-     * path till the current folder where this page is located, including the name of current folder itself.
-     */
-    currentPath: string[];
-    /**
-     * Path to the next children to be precessed.
-     */
-    childPath: string[];
-
-    // /**
-    //  * List of all paths that were tried before executing this page.
-    //  */
-    // notFoundPath: string[];
-
-    /**
-     * Query string if associated, empty object is always present.
-     */
-    query: any;
-
-    body: any;
-
-    url: string;
-
-    signal:AbortSignal;
-    /**
-     * Request
-     */
-    // request: Request;
-    /**
-     * Response
-     */
-    // response: Response;
-
-    /**
-     * Request method
-     */
-    method: string;
-
-    /**
-     * Currently logged in user
-     */
-    sessionUser: SessionUser;
-
-    /**
-     * Actual file path of the page
-     */
-    filePath: string;
-
-    disposables: Disposable[];
+    request: WrappedRequest;
 }
 
 export interface IFormData {
@@ -79,7 +27,7 @@ export interface IFormData {
 /**
  * Page should not contain any reference to underlying request/response objects.
  */
-export default class Page implements IPageContext {
+export default class Page {
 
     static [isPage] = true;
 
@@ -89,10 +37,18 @@ export default class Page implements IPageContext {
      * @param pageContext page related items
      * @returns true if it can handle the path, default is true
      */
-    static canHandle(pageContext: IRouteCheck) {
+    static canHandle(pageContext: IRouteCheck) : boolean | Promise<boolean> {
         return true;
     }
 
+    request: WrappedRequest;
+
+    response: WrappedResponse;
+
+    get params() {
+        return this.request?.query;
+    }
+
     signal: AbortSignal;
 
     currentPath: string[];
@@ -124,7 +80,7 @@ export default class Page implements IPageContext {
 
     disposables: Disposable[] = [];
 
-    private formDataPromise;
+    private formDataPromise: Promise<IFormData>;
 
     constructor() {
         this.cacheControl = "no-cache, no-store, max-age=0";
@@ -135,13 +91,14 @@ export default class Page implements IPageContext {
     }
 
     readFormData(): Promise<IFormData> {
-        this.formDataPromise ??= (async () => {
+
+        return this.formDataPromise ??= (async () => {
             let tempFolder: TempFolder;
             const result: IFormData = {
                 fields: {},
                 files: []
             };
-            const req = (this as any).req as Request;
+            const req = this.request;
             const bb = busboy({ headers: req.headers , defParamCharset: "utf8" });
             const tasks = [];
             await new Promise((resolve, reject) => {
@@ -167,7 +124,6 @@ export default class Page implements IPageContext {
             await Promise.all(tasks);
             return result;
         })();
-        return this.formDataPromise;
     }
 
 

package/src/ServerPages.ts

@@ -1,18 +1,17 @@
 /* eslint-disable no-console */
 import { RegisterSingleton, ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
-import express, { Request, Response } from "express";
 import Page from "./Page.js";
 import Content from "./Content.js";
-import SessionUser from "./core/SessionUser.js";
 import RouteTree from "./core/RouteTree.js";
-import CookieService from "./services/CookieService.js";
-import cookieParser from "cookie-parser";
-import bodyParser from "body-parser";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { Server, Socket } from "socket.io";
+import { Server } from "socket.io";
 import * as http from "http";
+import * as http2 from "http2";
 import SocketService from "./socket/SocketService.js";
+import { Wrapped, WrappedRequest, WrappedResponse } from "./core/Wrapped.js";
+import { SecureContext, createSecureContext } from "node:tls";
+import { SelfSigned } from "./ssl/SelfSigned.js";
 
 RegisterSingleton
 export default class ServerPages {
@@ -46,13 +45,22 @@ export default class ServerPages {
      * All services should be registered before calling build
      * @param app Express App
      */
-    public async build(app = express(), { createSocketService = true, port = 80 } = {}) {
+    public async build({
+        createSocketService = true,
+        port = 8080,
+        protocol = "http",
+        disableHttp2Warning = false,
+        SNICallback
+    }:{
+        createSocketService?: boolean,
+        port: number,
+        disableHttp2Warning?: boolean,
+        protocol: "http" | "http2" | "https2",
+        SNICallback: (servername: string, cb: (err: Error | null, ctx?: SecureContext) => void) => void
+    }) {
         try {
-            // etag must be set by individual request processors if needed.
-            app.set("etag", false);
 
-            app.use(cookieParser());
-            app.use(bodyParser.json());
+            let httpServer = null as http.Server | http2.Http2Server | http2.Http2SecureServer;
 
             let socketServer = null as Server;
             if (createSocketService) {
@@ -61,95 +69,125 @@ export default class ServerPages {
                 (ss as any).attach(socketServer);
                 await (ss as any).init();
             }
-            app.all(/./, (req, res, next) => this.process(req, res).then(next, next));
-            return new Promise<http.Server>((resolve, reject) => {
-                const server = app.listen(port, () => {
-                    resolve(server);
+
+            switch(protocol) {
+                case "http":
+                    httpServer = http.createServer((req, res) => this.process(req, res))
+                    break;
+                case "https2":
+                    let sc = null;
+                    SNICallback ??= (name, cb) => {
+                        if (sc) {
+                            return cb(null, sc);
+                        }
+                        const { key, cert } = SelfSigned.setupSelfSigned();
+                        sc = createSecureContext({ key, cert });
+                        cb(null, sc);
+                    };
+                    httpServer = http2.createSecureServer({
+                        SNICallback
+                    }, (req, res) => this.process(req, res))
+                    break;
+                case "http2":
+                    httpServer = http2.createSecureServer({
+                    },(req, res) => this.process(req, res))
+                    if (!disableHttp2Warning) {
+                        console.warn("Http2 without SSL should not be used in production");
+                    }
+                    break;
+            }
+
+
+            await new Promise<void>((resolve, reject) => {
+                const server = httpServer.listen(port, () => {
+                    resolve();
                 });
                 socketServer?.attach(server);
             });
+            return httpServer;
         } catch (error) {
             console.error(error);
         }
         return null;
     }
 
-    protected async process(req: Request, resp: Response) {
+    protected async process(req: any, resp: any) {
+
+        req = Wrapped.request(req);
+        resp = Wrapped.response(req, resp);
+
+        req.response = resp;
 
         if((req as any).processed) {
             return;
         }
         (req as any).processed = true;
 
-        // defaulting to no cache
-        // static content delivery should override this
-        resp.setHeader("cache-control", "no-cache");
-
-        using scope = ServiceProvider.createScope(this);
-        let sent = false;
-        const acceptJson = req.accepts().some((s) => /\/json$/i.test(s));
         try {
 
-            const cookieService = scope.resolve(CookieService);
+            // defaulting to no cache
+            // static content delivery should override this
+            resp.setHeader("cache-control", "no-cache");
+
+            using scope = ServiceProvider.createScope(this);
+            let sent = false;
+            const acceptJson = req.accepts().some((s) => /\/json$/i.test(s));
+
 
             try {
-                await cookieService.createSessionUser(req, resp);
+                const path = req.path.split("/").filter((x) => x);
+                const method = req.method;
+                const { pageClass, childPath } = (await this.root.getRoute({
+                    scope,
+                    method,
+                    current: "",
+                    path,
+                    request: req
+                })) ?? {
+                    pageClass: Page,
+                    childPath: path
+                };
+                const page = scope.create(pageClass);
+                page.method = method;
+                page.childPath = childPath;
+                page.request = req;
+                page.response = resp;
+                const content = await page.all(page.params);
+                resp.setHeader("cache-control", page.cacheControl);
+                resp.removeHeader("etag");
+                sent = true;
+                await content.send(resp);
             } catch (error) {
+                if (!sent) {
+                    try {
+
+                        if (acceptJson || error.errorModel) {
+                            await Content.json(
+                                    {
+                                        ... error.errorModel ?? {},
+                                        message: error.message ?? error,
+                                        detail: error.stack ?? error,
+                                    }
+                            , 500).send(resp);
+                            return;
+                        }
+
+                        const content = Content.html(`<!DOCTYPE html>\n<html><body><pre>Server Error for ${req.url}\r\n${error?.stack ?? error}</pre></body></html>`, 500);
+                        await content.send(resp);
+                    } catch (e1) {
+                        resp.send(e1.stack ?? e1, 500);
+                        console.error(e1);
+                    }
+                    return;
+                }
                 console.error(error);
             }
-
-            const sessionUser = (req as any).user;
-            scope.add(SessionUser, sessionUser);
-            const path = req.path.split("/").filter((x) => x);
-            const method = req.method;
-            const params = { ... req.params, ... req.query, ... req.body ?? {} };
-            const { pageClass, childPath } = (await this.root.getRoute({
-                method,
-                current: "",
-                path,
-                params,
-                sessionUser
-            })) ?? {
-                pageClass: Page,
-                childPath: path
-            };
-            const page = scope.create(pageClass);
-            page.method = method;
-            page.childPath = childPath;
-            page.body = req.body;
-            page.query = req.query;
-            page.sessionUser = sessionUser;
-            (page as any).req = req;
-            (page as any).res = resp;
-            const content = await page.all(params);
-            resp.setHeader("cache-control", page.cacheControl);
-            resp.removeHeader("etag");
-            sent = true;
-            await content.send(resp);
-        } catch (error) {
-            if (!sent) {
-                try {
-
-                    if (acceptJson || error.errorModel) {
-                        await Content.json(
-                                {
-                                    ... error.errorModel ?? {},
-                                    message: error.message ?? error,
-                                    detail: error.stack ?? error,
-                                }
-                        , 500).send(resp);
-                        return;
-                    }
-
-                    const content = Content.html(`<!DOCTYPE html>\n<html><body><pre>Server Error for ${req.url}\r\n${error?.stack ?? error}</pre></body></html>`, 500);
-                    await content.send(resp);
-                } catch (e1) {
-                    resp.send(e1.stack ?? e1);
-                    console.error(e1);
+        } finally {
+            if(Array.isArray(req.disposables)) {
+                for (const iterator of req.disposables) {
+                    iterator[Symbol.dispose]?.();
                 }
-                return;
             }
-            console.error(error);
         }
     }
 

package/src/core/LocalFile.ts

@@ -1,7 +1,7 @@
-import { createReadStream, createWriteStream, existsSync, statSync } from "fs";
+import { createReadStream, createWriteStream, existsSync, read, statSync } from "fs";
 import { basename  } from "path";
 import mime from "mime-types";
-import internal, { Stream } from "stream";
+import internal, { Stream, Writable } from "stream";
 import { appendFile, open, readFile, writeFile } from "fs/promises";
 
 
@@ -54,6 +54,15 @@ export class LocalFile {
         return await readFile(this.path, { flag: "r" });
     }
 
+    public async writeTo(writable: Writable, start?: number, end?: number) {
+        const readable = createReadStream(this.path, { start, end });
+        return new Promise((resolve, reject) => {
+            readable.pipe(writable, { end: true })
+                .on("end", resolve)
+                .on("error", reject);
+        });
+    }
+
     public async delete() {
         return this.onDispose?.();
     }

package/src/core/RouteTree.ts

@@ -60,7 +60,7 @@ export default class RouteTree {
         const pageClassPromise = (this.handler[method] ??= this.handler[method.toLowerCase()]) ?? this.handler["index"];
         if (pageClassPromise) {
             const pageClass = await pageClassPromise;
-            if(pageClass.canHandle(rc)) {
+            if(await pageClass.canHandle(rc)) {
                 return { pageClass, childPath: rc.path };
             }
         }

package/src/core/SessionUser.ts

@@ -1,8 +1,8 @@
-import { Request, Response } from "express";
 import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
 import { RegisterScoped } from "@entity-access/entity-access/dist/di/di.js";
 import DateTime from "@entity-access/entity-access/dist/types/DateTime.js";
 import TokenService, { IAuthCookie } from "../services/TokenService.js";
+import { WrappedResponse } from "./Wrapped.js";
 
 const secure = (process.env["SOCIAL_MAIL_AUTH_COOKIE_SECURE"] ?? "true") === "true";
 
@@ -48,7 +48,7 @@ export default class SessionUser {
     }
 
     constructor(
-        private resp: Response,
+        private resp: WrappedResponse,
         private cookieName: string,
         private tokenService: TokenService
     ) {}