@entity-access/server-pages 1.0.29 → 1.0.31

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 } from "./core/Wrapped.js";
+import { SecureContext } from "node:tls";
+import  ACME, { IAcmeOptions } from "./ssl/ACME.js";
 
 RegisterSingleton
 export default class ServerPages {
@@ -46,13 +45,24 @@ 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,
+        acmeOptions
+    }:{
+        createSocketService?: boolean,
+        port: number,
+        disableHttp2Warning?: boolean,
+        protocol: "http" | "http2" | "https2",
+        SNICallback?: (servername: string, cb: (err: Error | null, ctx?: SecureContext) => void) => void,
+        acmeOptions?: IAcmeOptions
+    }) {
         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 +71,123 @@ 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) => {
+                        const acme = ServiceProvider.resolve(this, ACME);
+                        acme.getSecureContext({ ... ( acmeOptions ?? {}),  host: name }).then((v) => {
+                            cb(null, v);
+                        },cb);
+                    };
+                    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/AsyncStream.ts

@@ -0,0 +1,83 @@
+import { closeSync, openSync, read, statSync } from "fs";
+
+export abstract class AsyncStream implements Disposable {
+
+    abstract read(n: number): Promise<Buffer>;
+
+    abstract [Symbol.dispose]();
+
+}
+
+const maxBufferSize = 16*1024;
+
+export class AsyncFileStream extends AsyncStream {
+
+    public readonly size: number;
+
+    private fd: any;
+
+    private buffer: Buffer;
+
+    constructor(
+        private readonly filePath: string,
+        public readPosition = 0,
+        lockFile = true,
+        bufferSize = maxBufferSize
+        ) {
+        super();
+
+        if (lockFile) {
+            this.fd = openSync(filePath, "r");
+        }
+        this.buffer = Buffer.alloc(bufferSize);
+        const { size } = statSync(filePath);
+        this.size = size;
+    }
+
+    read(): Promise<Buffer> {
+
+        return new Promise<Buffer>((resolve, reject) => {
+
+            const size = this.size - this.readPosition;
+
+            if (size <= 0) {
+                resolve(null);
+                return;
+            }
+
+            const buffer = (size) > this.buffer.byteLength
+                ? this.buffer
+                : Buffer.alloc(size);
+
+            this.readPosition += size;
+
+            if (this.fd) {
+
+                read(this.fd, buffer, 0, buffer.byteLength, this.readPosition,
+                    (error) => error ? reject(error) : resolve(buffer));
+                return;
+            }
+            const fd = openSync(this.filePath, "r");
+            read(this.fd, buffer, 0, buffer.byteLength, this.readPosition,
+                (error) => {
+                    try {
+                        closeSync(fd);
+                    } catch (e) {
+                        reject(e);
+                        return;
+                    }
+                    if(error ) {
+                        reject(error);
+                        return;
+                    }
+                    resolve(buffer);
+                });
+        });
+    }
+    [Symbol.dispose]() {
+        if (this.fd) {
+            closeSync(this.fd);
+        }
+    }
+
+}

package/src/core/FileApi.ts

@@ -0,0 +1,52 @@
+import { existsSync, unlinkSync, mkdirSync } from "fs";
+
+import { dirname } from "path";
+import { AsyncFileStream } from "./AsyncStream.js";
+
+export function ensureParentFolder(filePath: string) {
+    ensureDir(dirname(filePath));
+}
+
+export default function ensureDir(folder: string) {
+
+    if (existsSync(folder)) {
+        return;
+    }
+
+    const parent = dirname(folder);
+    if (parent !== "/") {
+        ensureDir(parent);
+    }
+
+    mkdirSync(folder);
+
+}
+
+export const deleteIfExists = (path) => existsSync(path) ? unlinkSync(path) : void 0;
+
+export const areFilesEqual = async (file1: string, file2: string) => {
+
+    using f1 = new AsyncFileStream(file1);
+    using f2 = new AsyncFileStream(file2);
+
+    if(f1.size !== f2.size) {
+        return false;
+    }
+
+    for(;;) {
+        const [b1,b2] = await Promise.all([f1.read(), f2.read()]);
+        if (b1 === null && b2 === null) {
+            return f1.readPosition === f2.readPosition;
+        }
+        if (b1 === null) {
+            return false;
+        }
+        if (b2 === null) {
+            return false;
+        }
+        if (!b1.equals(b2)) {
+            return false;
+        }
+    }
+
+};

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
     ) {}