@entity-access/server-pages 1.0.5

package/src/Page.tsx

@@ -0,0 +1,217 @@
+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";
+
+export const isPage = Symbol("isPage");
+
+
+export interface IRouteCheck {
+    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[];
+}
+
+export interface IFormData {
+    fields: { [key: string]: string};
+    files: LocalFile[];
+}
+
+/**
+ * Page should not contain any reference to underlying request/response objects.
+ */
+export default class Page implements IPageContext {
+
+    static [isPage] = true;
+
+    
+    /**
+     * This static method determines if the path can be handled by this page or not.
+     * @param pageContext page related items
+     * @returns true if it can handle the path, default is true
+     */
+    static canHandle(pageContext: IRouteCheck) {
+        return true;
+    }
+
+    signal: AbortSignal;
+
+    currentPath: string[];
+
+    childPath: string[];
+
+    /**
+     * List of all paths that were tried before executing this page.
+     */
+    notFoundPath: string[];
+
+    query: any;
+
+    body: any;
+
+    url: string;
+
+    // request: Request;
+
+    // response: Response;
+
+    method: string;
+
+    sessionUser: SessionUser;
+
+    filePath: string;
+
+    cacheControl: string;
+
+    disposables: Disposable[] = [];
+
+    private formDataPromise;
+
+    constructor() {
+        this.cacheControl = "no-cache, no-store, max-age=0";
+    }
+
+    all(params: any): IPageResult | Promise<IPageResult> {
+        return this.notFound();
+    }
+
+    readFormData(): Promise<IFormData> {
+        this.formDataPromise ??= (async () => {
+            let tempFolder: TempFolder;
+            const result: IFormData = {
+                fields: {},
+                files: []
+            };
+            const req = (this as any).req as Request;
+            const bb = busboy({ headers: req.headers , defParamCharset: "utf8" });
+            const tasks = [];
+            await new Promise((resolve, reject) => {
+
+                bb.on("field", (name, value) => {
+                    result.fields[name] = value;
+                });
+
+                bb.on("file", (name, file, info) => {
+                    if(!tempFolder) {
+                        tempFolder = new TempFolder();
+                        this.disposables.push(tempFolder);
+                    }
+                    const tf = tempFolder.get(info.filename, info.mimeType);
+                    tasks.push(tf.writeAll(file).then(() => {
+                        result.files.push(tf);
+                    }));
+                });
+                bb.on("error", reject);
+                bb.on("close", resolve);
+                req.pipe(bb);
+            });
+            await Promise.all(tasks);
+            return result;
+        })();
+        return this.formDataPromise;
+    }
+
+
+    protected content(body: string, status = 200, contentType = "text/html") {
+        return Content.create({ body, status, contentType });
+    }
+
+    protected json(o: any, indent = 0) {
+        const content = indent
+            ? JSON.stringify(o, undefined, indent)
+            : JSON.stringify(o);
+        return this.content(content, 200, "application/json");
+    }
+
+    protected redirect(location: string) {
+        return new Redirect(location);
+    }
+
+    protected notFound(): Content | Promise<Content> {
+        return Content.html(<HtmlDocument>
+                <head>
+                    <title>Not found</title>
+                </head>
+                <body>
+                    The page you are looking for is not found.
+                    <pre>{this.url} not found</pre>
+                </body>
+            </HtmlDocument>,
+            404
+        );
+    }
+
+    protected serverError(error, status = 500): Content | Promise<Content> {
+        return Content.create({
+            body: <HtmlDocument>
+                    <head>
+                        <title>Server Error</title>
+                    </head>
+                    <body>
+                        There was an error processing you request.
+                        <pre>{error.stack ?? error}</pre>
+                    </body>
+                </HtmlDocument>,
+            status
+        });
+    }
+}

package/src/ServerPages.ts

@@ -0,0 +1,129 @@
+/* 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";
+
+RegisterSingleton
+export default class ServerPages {
+
+    public static create(globalServiceProvider: ServiceProvider = new ServiceProvider()) {
+        const sp = globalServiceProvider.create(ServerPages);
+        return sp;
+    }
+
+    private root: RouteTree = new RouteTree();
+
+    /**
+     * We will register all sub folders starting with given path.
+     * @param folder string
+     * @param start string
+     */
+    public registerRoutes(folder: string, start: string = "/") {
+        const startRoute = start.split("/").filter((x) => x);
+        let root = this.root;
+        for (const iterator of startRoute) {
+            root = root.getOrCreate(iterator);
+        }
+        root.register(folder);
+    }
+
+    /**
+     * All services should be registered before calling build
+     * @param app Express App
+     */
+    public build(app = express()) {
+        try {
+            const cookieService = ServiceProvider.resolve(this, CookieService);
+
+            // etag must be set by individual request processors if needed.
+            app.set("etag", false);
+
+            app.use(cookieParser());
+            app.use((req, res, next) => cookieService.createSessionUser(req, res).then(next, next));
+
+            app.use(bodyParser.json());
+
+            app.all(/./, (req, res, next) => this.process(req, res).then(next, next));
+            return app;
+        } catch (error) {
+            console.error(error);
+        }
+    }
+
+    protected async process(req: Request, resp: Response) {
+
+        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 sessionUser = (req as any).user;
+            scope.add(SessionUser, sessionUser);
+            const path = req.path.substring(1).split("/");
+            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);
+                }
+                return;
+            }
+            console.error(error);
+        }
+    }
+
+}

package/src/core/LocalFile.ts

@@ -0,0 +1,92 @@
+import { createReadStream, createWriteStream, existsSync, statSync } from "fs";
+import { basename  } from "path";
+import mime from "mime-types";
+import internal, { Stream } from "stream";
+import { appendFile, open, readFile, writeFile } from "fs/promises";
+
+
+export class LocalFile {
+
+    public readonly contentType: string;
+
+    public readonly fileName: string;
+
+    public get exists() {
+        return existsSync(this.path);
+    }
+
+    public get contentSize() {
+        if (!this.exists) {
+            return 0;
+        }
+        const s = statSync(this.path);
+        return s.size;
+    }
+
+    constructor(public readonly path: string, name?: string, mimeType?: string, private onDispose?: () => void) {
+        this.fileName = name ?? basename(path);
+        this.contentType = (mimeType || mime.lookup(this.fileName)) || "application/octet-stream";
+        this[Symbol.asyncDispose] = onDispose;
+    }
+
+    public openRead(): Stream {
+        return createReadStream(this.path);
+    }
+
+    public openReadStream(): internal.Readable {
+        return createReadStream(this.path);
+    }
+
+    public openWrite(): Stream {
+        return createWriteStream(this.path);
+    }
+
+    public async appendLine(line: string) {
+        await appendFile(this.path, line + "\n");
+        return this;
+    }
+
+    public async readAsText() {
+        return await readFile(this.path, "utf-8");
+    }
+
+    public async readAsBuffer() {
+        return await readFile(this.path, { flag: "r" });
+    }
+
+    public async delete() {
+        return this.onDispose?.();
+    }
+
+    public writeAllText(text: string) {
+        return writeFile(this.path, text);
+    }
+
+    public writeAll(buffer: string | Buffer | internal.Readable | Stream) {
+        return writeFile(this.path, buffer);
+    }
+
+    public async *readBuffers(bufferSize = 16 * 1024 * 1024) {
+        const size = this.contentSize;
+        let buffer = Buffer.alloc(bufferSize);
+        for (let offset = 0; offset < size; offset += bufferSize) {
+            const length = ((offset + bufferSize) > size )
+                ? (size - offset)
+                : bufferSize;
+            let fd = await open(this.path);
+            try {
+                if (buffer.length !== length) {
+                    buffer = Buffer.alloc(length);
+                }
+                await fd.read({ position: offset, length, buffer });
+                await fd.close();
+                fd = null;
+                yield buffer;
+            } finally {
+                if (fd) {
+                    await fd.close();
+                }
+            }
+        }
+    }
+}

package/src/core/RouteTree.ts

@@ -0,0 +1,125 @@
+import { readdirSync } from "fs";
+import { join } from "path";
+import Page from "../Page.js";
+import SessionUser from "./SessionUser.js";
+import { IRouteCheck, isPage } from "../Page.js";
+import { pathToFileURL } from "url";
+import Content, { IPageResult } from "../Content.js";
+
+export interface IRouteHandler {
+    get?: Promise<typeof Page>;
+    post?: Promise<typeof Page>;
+    put?: Promise<typeof Page>;
+    patch?: Promise<typeof Page>;
+    delete?: Promise<typeof Page>;
+    head?: Promise<typeof Page>;
+    index?: Promise<typeof Page>;
+}
+
+type IPageRoute = { default: typeof Page };
+
+export default class RouteTree {
+    
+    private children = new Map<string,RouteTree>();
+
+    private handler: IRouteHandler;
+
+    constructor(public readonly path: string = "/") {
+
+    }
+
+    getOrCreate(name: string): RouteTree {
+        let child = this.children.get(name);
+        if (!child) {
+            child = new RouteTree(this.path + name + "/");
+            this.children.set(name, child);
+        }
+        return child;
+    }
+
+    public async getRoute(rc: IRouteCheck): Promise<{ pageClass: typeof Page, childPath: string[] }> {
+        const { method, path: [current, ... rest] } = rc;
+        const childRouteCheck = { ... rc, current, path: rest };
+        const childRoute = this.children.get(current);
+        if (childRoute) {
+            const nested = await childRoute.getRoute(childRouteCheck);
+            if (nested) {
+                return nested;
+            }
+        }
+
+        if (!this.handler) {
+            // we will not be able to handle this route
+            return;
+        }
+
+        const pageClassPromise = this.handler[method] ?? this.handler["index"];
+        if (pageClassPromise) {
+            const pageClass = await pageClassPromise;
+            if(pageClass.canHandle(rc)) {
+                return { pageClass, childPath: rc.path };
+            }
+        }
+    }
+    
+    public register(folder: string) {
+
+        for (const iterator of readdirSync(folder, { withFileTypes: true , recursive: false})) {
+            if (iterator.isDirectory()) {
+                const rt = this.getOrCreate(iterator.name);
+                rt.register(folder + "/" + iterator.name);
+                continue;
+            }
+
+            if (!iterator.name.endsWith(".js")) {
+                continue;
+            }
+
+            let name: keyof IRouteHandler;
+
+            switch(iterator.name) {
+                case "index.js":
+                    name = "index";
+                    break;
+                case "get.js":
+                    name = "get";
+                    break;
+                case "post.js":
+                    name = "post";
+                    break;
+                case "put.js":
+                    name = "put";
+                    break;
+                case "patch.js":
+                    name = "patch";
+                    break;
+                case "head.js":
+                    name = "head";
+                    break;
+                case "delete.js":
+                    name = "delete";
+                    break;
+            }
+
+            const handler = pathToFileURL(join(folder, iterator.name)).toString();
+            console.log(`Registering Route ${this.path} with ${handler}`);
+
+            const promise = (async () => {
+                const { default: pageClass } = await import(handler);
+                if (pageClass[isPage]) {
+                    return pageClass as typeof Page;
+                }
+                return class extends Page {
+                    async all(params: any) {
+                        const r = await pageClass.call(this, params);
+                        return Content.create(r);
+                    }
+                }
+            })();
+
+            (this.handler ??= { [name]: promise});
+        }
+
+    }
+
+}

package/src/core/SessionUser.ts

@@ -0,0 +1,95 @@
+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";
+
+const secure = (process.env["SOCIAL_MAIL_AUTH_COOKIE_SECURE"] ?? "true") === "true";
+
+export type roles = "Administrator" | "Contributor" | "Reader" | "Guest";
+
+@RegisterScoped
+export default class SessionUser {
+
+    /**
+     * SessionID saved in database for current session.
+     */
+    sessionID: number;
+
+    /**
+     * UserID
+     */
+    userID?: number;
+
+    /**
+     * Logged in user name
+     */
+    userName?: string;
+
+    /**
+     * Application Roles, user is associated with.
+     */
+    roles?: string[];
+
+    /**
+     * Expiry date, after which this session is invalid
+     */
+    expiry?: Date;
+
+    /**
+     * If set to true, session is no longer valid.
+     */
+    invalid?: boolean;
+
+    ipAddress: string;
+
+    get isAdmin() {
+        return this.roles?.includes("Administrator") ?? false;
+    }
+
+    constructor(
+        private resp: Response,
+        private cookieName: string,
+        private tokenService: TokenService
+    ) {}
+
+    isInRole(role: roles) {
+        return this.roles?.includes(role) ?? false;
+    }
+
+    ensureLoggedIn() {
+        if (!this.userName) {
+            throw new EntityAccessError();
+        }
+    }
+
+    ensureRole(role: roles) {
+        if (this.isInRole(role)) {
+            return;
+        }
+        throw new EntityAccessError();
+    }
+
+    ensureIsAdmin() {
+        return this.ensureRole("Administrator");
+    }
+
+    async setAuthCookie(authCookie: Omit<IAuthCookie, "sign">) {
+        const cookie = await this.tokenService.getAuthToken(authCookie);
+        const maxAge = ((authCookie.expiry ?  DateTime.from(authCookie.expiry) : null) ?? DateTime.now.addDays(30)).diff(DateTime.now).totalMilliseconds;
+        this.resp.cookie(
+            cookie.cookieName,
+            cookie.cookie, {
+                secure,
+                httpOnly: true,
+                maxAge
+            });
+    }
+
+    clearAuthCookie() {
+        this.resp.cookie(this.cookieName, "{}", {
+            secure,
+            httpOnly: true
+        });
+    }
+}

package/src/core/TempFolder.ts

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+import { existsSync, mkdirSync, rmSync, rmdirSync } from "node:fs";
+import * as os from "node:os";
+import { join } from "path";
+import { LocalFile } from "./LocalFile.js";
+
+const doNothing = () => void 0;
+
+const tmpdir = os.tmpdir();
+
+const tmpFolder =  join(tmpdir, "tmp-folders");
+
+if (!existsSync(tmpFolder)) {
+    try {
+        mkdirSync(tmpFolder, { recursive: true });
+    } catch {
+        // ignore
+    }
+}
+
+let id = 1;
+
+export default class TempFolder implements Disposable {
+
+    constructor(public readonly folder = join(tmpFolder, `tf-${id++}`)) {
+        mkdirSync(folder);
+    }
+
+    get(name, mimeType?: string, keep = false) {
+        return new LocalFile(join(this.folder, name), name, mimeType, keep ? doNothing : void 0);
+    }
+
+    [Symbol.dispose]() {
+        try {
+            rmSync(this.folder, { recursive: true, force: true, maxRetries: 10, retryDelay: 10000});
+        } catch (error) {
+            console.warn(error);
+        }
+    }
+
+}

package/src/html/HtmlDocument.tsx

@@ -0,0 +1,10 @@
+import XNode from "./XNode.js";
+
+export default function HtmlDocument({ lang = "en"}, ... nodes: (XNode | string)[]): XNode {
+    return XNode.create("", { },
+        "<!DOCTYPE html>",
+        <html lang={lang}>
+            { ... nodes}
+        </html>
+    );
+}