@entity-access/server-pages 1.0.28 → 1.0.30

package/src/core/Wrapped.ts

@@ -0,0 +1,359 @@
+import busboy from "busboy";
+import { IncomingMessage, OutgoingMessage, ServerResponse } from "http";
+import { Http2ServerRequest, Http2ServerResponse } from "http2";
+import SessionUser from "./SessionUser.js";
+import { parse, serialize } from "cookie";
+import TempFolder from "./TempFolder.js";
+import { LocalFile } from "./LocalFile.js";
+import { Writable } from "stream";
+import { ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
+import CookieService from "../services/CookieService.js";
+import { stat } from "fs/promises";
+
+
+type UnwrappedRequest = IncomingMessage | Http2ServerRequest;
+
+export interface IFormData {
+    fields: { [key: string]: string};
+    files: LocalFile[];
+}
+
+export interface IWrappedRequest {
+
+    get host(): string;
+
+    get path(): string;
+
+    get asyncSessionUser(): Promise<SessionUser>;
+
+    get asyncJsonBody(): Promise<any>;
+
+    get asyncForm(): Promise<IFormData>;
+
+    get query(): { [key: string]: string};
+
+    get cookies(): { [key: string]: string};
+
+    get URL(): URL;
+
+    get remoteIPAddress(): string;
+
+    accepts(): string[];
+    accepts(... types: string[]): boolean;
+}
+
+export interface IWrappedResponse {
+
+    asyncEnd();
+
+    asyncWrite(buffer: Buffer): Promise<void>;
+
+    send(data: Buffer | string | Blob, status?: number): Promise<void>;
+
+    sendRedirect(url: string, permanent?: boolean): void;
+
+    cookie(name: string, value: string, options?: { secure?: boolean, httpOnly?: boolean, maxAge?: number });
+
+    // https://github.com/phoenixinfotech1984/node-content-range
+    sendFile(filePath: string, options?: {
+        acceptRanges?: boolean,
+        cacheControl?: boolean,
+        maxAge?: number,
+        etag?: boolean,
+        immutable?: boolean,
+        headers?: { [key: string]: string},
+        lastModified?: boolean
+    }): Promise<void>;
+
+}
+
+export type WrappedRequest = UnwrappedRequest & IWrappedRequest & {
+    scope: ServiceProvider;
+    response: WrappedResponse;
+    disposables: Disposable[];
+};
+
+type UnwrappedResponse = ServerResponse | Http2ServerResponse;
+
+export type WrappedResponse = UnwrappedResponse & IWrappedResponse & {
+    request: WrappedRequest
+};
+
+const requestMethods: { [P in keyof IWrappedRequest]: (this: WrappedRequest) => any} = {
+    remoteIPAddress(this: UnwrappedRequest) {
+        return this.socket?.remoteAddress;
+    },
+
+    accepts(this: UnwrappedRequest) {
+        const accepts = (this.headers.accept ?? "").split(";");
+        return (...types: string[]) => {
+            if (types.length > 0) {
+                for (const type of types) {
+                    for (const iterator of accepts) {
+                        if (iterator.includes(type)) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+            return accepts;
+        };
+    },
+
+    URL(this: UnwrappedRequest) {
+        const w = this as WrappedRequest;
+        return new URL(this.url, `http://${w.host}`);
+    },
+
+    path(this: WrappedRequest) {
+        return this.URL.pathname;
+    },
+
+    host(this: UnwrappedRequest) {
+        return this.headers[":authority"] ?? this.headers["host"];
+    },
+    query(this: WrappedRequest) {
+        const u = this.URL;
+        const items = {};
+        for (const [key, value] of u.searchParams.entries()) {
+            items[key] = value;
+        }
+        return items;
+    },
+    cookies(this: UnwrappedRequest) {
+        const cookie = this.headers.cookie;
+        const cookies = parse(cookie);
+        return cookies;
+    },
+
+    async asyncJsonBody(this: WrappedRequest) {
+        const req = this;
+        let buffer = null as Buffer;
+        let encoding = this.headers["content-encoding"] ?? "utf-8";
+        const contentType = this.headers["content-type"];
+        if (!/\/json/i.test(contentType)) {
+            throw new Error(`Content Type ${contentType} isn't json `);
+        }
+        await new Promise<void>((resolve, reject) => {
+            req.pipe(new Writable({
+                write(chunk, enc, callback) {
+                    encoding ||= enc;
+                    let b = typeof chunk === "string"
+                        ? Buffer.from(chunk)
+                        : chunk as Buffer;
+                    buffer = buffer
+                        ? Buffer.concat([buffer, b])
+                        : b;
+                    callback();
+                },
+                final(callback) {
+                    resolve();
+                    callback();
+                },
+            }), { end: true });
+        });
+        const text = buffer.toString(encoding as any);
+        return JSON.parse(text);
+    },
+
+    async asyncSessionUser(this: WrappedRequest) {
+        try {
+            const cookieService = this.scope.resolve(CookieService);
+            const cookie = this.cookies[cookieService.cookieName];
+            const sessionUser = await cookieService.createSessionUserFromCookie(cookie, this.remoteIPAddress, this.response);
+            return sessionUser;
+        } catch (error) {
+            console.error(error);
+            return new SessionUser(null, null, null);
+        }
+    },
+
+    async asyncForm(this: WrappedRequest) {
+        let tempFolder: TempFolder;
+        const result: IFormData = {
+            fields: {},
+            files: []
+        };
+        const req = this;
+        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;
+    }
+};
+
+const responseMethods: { [P in keyof IWrappedResponse]: (this: WrappedResponse) => any} = {
+
+    asyncEnd() {
+        return () => new Promise<void>((resolve) => this.end(resolve));
+    },
+
+    asyncWrite() {
+        return (buffer: Buffer, start?: number, length?: number) => {
+            return new Promise((resolve) => 
+                this.write(buffer, resolve)
+            );
+        };
+    },
+
+    cookie() {
+        return (name: string, value: string, options = {}) => {
+            const cv = this.getHeaders()["set-cookie"];
+            const cookies = Array.isArray(cv) ? cv : [cv];
+            const nk = cookies.filter((x) => x.startsWith(name + "="));
+            nk.push(serialize(name, value, options));
+            this.setHeader("set-cookie", nk);
+        }
+    },
+
+    send(this: WrappedResponse) {
+        return async (data: Buffer | string, status: number = 200) => {
+            try {
+                this.statusCode = status;
+                this.writeHead(this.statusCode, this.getHeaders());
+                await new Promise<void>((resolve, reject) => {
+                    this.write(data, (error) => error ? reject(error) : resolve());
+                });
+                return this.asyncEnd();
+            } catch (error) {
+                console.error(error);
+            }
+        };
+    },
+    sendRedirect() {
+        return (location: string, permanent = false) => {
+            this.statusCode = 301;
+            this.writeHead(this.statusCode, {
+                location
+            });
+            return this.asyncEnd();
+        }
+    },
+    sendFile() {
+        return async (filePath: string, options?: {
+            acceptRanges?: boolean,
+            cacheControl?: boolean,
+            maxAge?: number,
+            etag?: boolean,
+            immutable?: boolean,
+            headers?: { [key: string]: string},
+            lastModified?: boolean
+        }) => {
+             /** Calculate Size of file */
+            const { size } = await stat(filePath);
+            const range = this.request.headers.range;
+
+            const lf = new LocalFile(filePath);
+
+            /** Check for Range header */
+            if (!range) {
+                this.writeHead(200, {
+                    "Content-Length": size,
+                    "Content-Type": "video/mp4"
+                });
+
+                await lf.writeTo(this);
+
+                return this.asyncEnd();
+            }
+
+            /** Extracting Start and End value from Range Header */
+            let [start, end] = range.replace(/bytes=/, "").split("-") as any[];
+            start = parseInt(start, 10);
+            end = end ? parseInt(end, 10) : size - 1;
+
+            if (!isNaN(start) && isNaN(end)) {
+                start = start;
+                end = size - 1;
+            }
+            if (isNaN(start) && !isNaN(end)) {
+                start = size - end;
+                end = size - 1;
+            }
+
+            // Handle unavailable range request
+            if (start >= size || end >= size) {
+                // Return the 416 Range Not Satisfiable.
+                this.writeHead(416, {
+                    "Content-Range": `bytes */${size}`
+                });
+                return this.asyncEnd();
+            }
+
+            /** Sending Partial Content With HTTP Code 206 */
+            this.writeHead(206, {
+                "Content-Range": `bytes ${start}-${end}/${size}`,
+                "Accept-Ranges": "bytes",
+                "Content-Length": end - start + 1,
+                "Content-Type": "video/mp4"
+            });
+
+            await lf.writeTo(this, start, end);
+
+        }
+    },
+};
+
+export const Wrapped = {
+    request: (req: UnwrappedRequest) => {
+        for (const key in requestMethods) {
+            if (Object.prototype.hasOwnProperty.call(requestMethods, key)) {
+                const element = requestMethods[key];
+                Object.defineProperty(req, key, {
+                    get() {
+                        const value = element.call(this);
+                        Object.defineProperty(this, key, { value, enumerable: true, writable: false });
+                        return value;
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+        }
+        const wr = req as WrappedRequest;
+        wr.disposables = [];
+        return wr;
+    },
+
+    response: (req: WrappedRequest, res: UnwrappedResponse) => {
+        for (const key in responseMethods) {
+            if (Object.prototype.hasOwnProperty.call(responseMethods, key)) {
+                const element = responseMethods[key];
+                Object.defineProperty(res, key, {
+                    get() {
+                        const value = element.call(this);
+                        Object.defineProperty(this, key, { value, enumerable: true, writable: false });
+                        return value;
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+        }
+        const wr = res as WrappedResponse;
+        wr.request = req;
+        req.response = wr;
+        return wr;
+    }
+}

package/src/core/cached.ts

@@ -0,0 +1,3 @@
+export function cached() {
+    
+}

package/src/decorators/Authorize.ts

@@ -0,0 +1,3 @@
+export function Authorize() {
+    
+}

package/src/parsers/json/jsonParser.ts

@@ -0,0 +1,3 @@
+export default function jsonParser() {
+    
+}

package/src/services/CookieService.ts

@@ -2,10 +2,10 @@ import Inject, { RegisterScoped, RegisterSingleton, ServiceProvider } from "@ent
 import TokenService, { IAuthCookie } from "./TokenService.js";
 import TimedCache from "@entity-access/entity-access/dist/common/cache/TimedCache.js";
 import { BaseDriver } from "@entity-access/entity-access/dist/drivers/base/BaseDriver.js";
-import { Request, Response } from "express";
 import cluster from "cluster";
 import SessionUser from "../core/SessionUser.js";
 import UserSessionProvider from "./UserSessionProvider.js";
+import { WrappedResponse } from "../core/Wrapped.js";
 
 /**
  * This will track userID,cookie pair so we can
@@ -65,13 +65,11 @@ export default class CookieService {
 
     public clearCache = clearCache;
 
-    async createSessionUser(req: Request, resp: Response) {
-        cookieName ??= this.tokenService.authCookieName;
-        const sessionCookie = req.cookies[cookieName];
-        return req.user = await this.createSessionUserFromCookie(sessionCookie, req.ip, resp);
+    public get cookieName() {
+        return cookieName ??= this.tokenService.authCookieName;
     }
 
-    async createSessionUserFromCookie(cookie: string, ip: string, resp?: Response) {
+    async createSessionUserFromCookie(cookie: string, ip: string, resp?: WrappedResponse) {
         const user = new SessionUser(resp, cookieName, this.tokenService);
         try {
             user.ipAddress = ip;
@@ -120,13 +118,13 @@ export default class CookieService {
                 parsedCookie.expiry = new Date(parsedCookie.expiry);
             }
 
-            const r = await this.createUserInfo(parsedCookie.id, cookie, parsedCookie.expiry);
+            const r = await this.createUserInfo(cookie, parsedCookie);
             return r;
         });
     }
 
-    private async createUserInfo(id: number, cookie: string, expiry: Date) {
-        const r = await this.userSessionProvider.getUserSession(id, expiry);
+    private async createUserInfo(cookie: string, parsedCookie: IAuthCookie) {
+        const r = await this.userSessionProvider.getUserSession(parsedCookie);
         if (r === null) {
             return {};
         }

package/src/services/TokenService.ts

@@ -7,6 +7,7 @@ import KeyProvider from "./KeyProvider.js";
 
 export interface IAuthCookie {
     id: number;
+    userID: number;
     expiry: Date;
     sign: string;
     version: string;

package/src/services/UserSessionProvider.ts

@@ -1,13 +1,15 @@
 import { RegisterScoped, RegisterSingleton } from "@entity-access/entity-access/dist/di/di.js";
 import SessionUser from "../core/SessionUser.js";
 import DateTime from "@entity-access/entity-access/dist/types/DateTime.js";
+import { IAuthCookie } from "./TokenService.js";
 
 @RegisterScoped
 export default class UserSessionProvider {
 
-    async getUserSession(id: number, expiry: Date = DateTime.now.addHours(1).asJSDate): Promise<Partial<SessionUser>> {
+    async getUserSession({ userID, id: sessionID, expiry}: IAuthCookie): Promise<Partial<SessionUser>> {
         return {
-            userID: 1,
+            sessionID,
+            userID,
             expiry
         }
     }

package/src/ssl/SelfSigned.ts

@@ -0,0 +1,78 @@
+import * as forge from "node-forge";
+import * as crypto from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+
+export class SelfSigned {
+    public static setupSelfSigned(sslMode = "./") {
+
+        const selfSigned = `${sslMode}/self-signed/`;
+
+        mkdirSync(selfSigned, { recursive: true });
+
+        const certPath  = `${selfSigned}/cert.crt`;
+        const keyPath  = `${selfSigned}/key.pem`;
+
+        let key;
+        let cert;
+
+        if (existsSync(certPath) && existsSync(keyPath)) {
+            key = readFileSync(keyPath);
+            cert = readFileSync(certPath);
+            return { key, cert };
+        }
+
+        const pki = forge.default.pki;
+
+        // generate a key pair or use one you have already
+        const keys = pki.rsa.generateKeyPair(2048);
+
+        // create a new certificate
+        const crt = pki.createCertificate();
+
+        // fill the required fields
+        crt.publicKey = keys.publicKey;
+        crt.serialNumber = '01';
+        crt.validity.notBefore = new Date();
+        crt.validity.notAfter = new Date();
+        crt.validity.notAfter.setFullYear(crt.validity.notBefore.getFullYear() + 40);
+
+        // use your own attributes here, or supply a csr (check the docs)
+        const attrs = [
+            {
+                name: 'commonName',
+                value: 'dev.socialmail.in'
+            }, {
+                name: 'countryName',
+                value: 'IN'
+            }, {
+                shortName: 'ST',
+                value: 'Maharashtra'
+            }, {
+                name: 'localityName',
+                value: 'Navi Mumbai'
+            }, {
+                name: 'organizationName',
+                value: 'NeuroSpeech Technologies Pvt Ltd'
+            }, {
+                shortName: 'OU',
+                value: 'Test'
+            }
+        ];
+
+        // here we set subject and issuer as the same one
+        crt.setSubject(attrs);
+        crt.setIssuer(attrs);
+
+        // the actual certificate signing
+        crt.sign(keys.privateKey);
+
+        // now convert the Forge certificate to PEM format
+        cert = pki.certificateToPem(crt);
+        key = pki.privateKeyToPem(keys.privateKey);
+
+        writeFileSync(certPath, cert);
+        writeFileSync(keyPath, key);
+
+        return { key, cert };
+    }
+}

package/test.js

@@ -7,6 +7,4 @@ import { fileURLToPath } from "node:url";
 const sp = ServerPages.create();
 sp.registerRoutes(join(dirname( fileURLToPath(import.meta.url)), "./dist/tests/logger"));
 
-const app = sp.build();
-
-app.listen(8080);
+const app = sp.build({ createSocketService: false, protocol: "https2" });