@entity-access/server-pages 1.1.348 → 1.1.350

package/src/Content.tsx

@@ -6,43 +6,71 @@ import { LocalFile } from "./core/LocalFile.js";
 import { SessionUser } from "./core/SessionUser.js";
 import { WrappedResponse } from "./core/Wrapped.js";
 import { OutgoingHttpHeaders } from "http";
-import JsonReadable from "@entity-access/entity-access/dist/common/JsonReadable.js";
+import { Readable } from "stream";
+import Utf8Readable from "./core/Utf8Readable.js";
 
-export abstract class PageResult {
-    abstract send(res: WrappedResponse, user?: SessionUser): Promise<any>;
-}
+const EmptyReader = Readable.from([]);
+
+export default class Content {
+
+    public readonly reader: Readable;
+    public readonly status: number = 200;
+    public readonly headers: OutgoingHttpHeaders;
+
+    public suppressLog: boolean;
 
-export class JsonReaderResult extends PageResult {
     constructor(
-        public readonly reader: JsonReadable,
-        public readonly status = 200,
-        public readonly headers?: OutgoingHttpHeaders
+        p: Partial<Content>
     ) {
-        super();
+        Object.setPrototypeOf(p, Content.prototype);
+        return p as Content;
     }
 
     send(res: WrappedResponse, user?: SessionUser): Promise<any> {
-        return res.asyncPipe(this.status, this.headers, this.reader);
+        return res.sendReader(this.status, this.headers, this.reader);
     }
 
-}
+    static readable(readable: Readable, { status = 200, headers = void 0 as OutgoingHttpHeaders }) {
+        return new Content({
+            reader: readable,
+            status,
+            headers
+        });
+    }
 
-export class StatusResult extends PageResult {
 
-    constructor(
-        public readonly status,
-        public readonly headers?: OutgoingHttpHeaders
-    ) {
-        super();
-    }
+    static text(
+        text: string | Iterable<string> | XNode,
+        {
+            status = 200,
+            headers = void 0 as OutgoingHttpHeaders,
+            suppressLog = false
+        } = {
+        }) {
+
+        let reader: Readable;
+
+        headers ??= {};
+        headers["content-type"] ??= "text/html; charset=utf-8"
+
+        if (typeof text === "string") {
+            reader = Readable.from([ Buffer.from(text, "utf8") ]);
+        } else if (text instanceof XNode) {
+            reader = Utf8Readable.from(text.readable());
+        } else {
+            reader = Utf8Readable.from(text);
+        }
 
-    send(res: WrappedResponse, user?: SessionUser): Promise<any> {
-        return res.sendStatus(this.status, this.headers);
+        return new Content({
+            reader,
+            status,
+            headers,
+            suppressLog
+        });
     }
-
 }
 
-export class FileResult extends PageResult {
+export class FileResult extends Content {
 
     public contentDisposition: "inline" | "attachment" = "inline";
     public cacheControl = true;
@@ -64,7 +92,7 @@ export class FileResult extends PageResult {
             headers
         }: Partial<FileResult> = {}
     ) {
-        super();
+        super({});
         this.contentDisposition = contentDisposition;
         this.cacheControl = cacheControl;
         this.maxAge = maxAge;
@@ -103,109 +131,110 @@ export class TempFileResult extends FileResult {
 
 
 
-export class Redirect extends PageResult {
+export class Redirect extends Content {
 
-    constructor(public location: string, public status = 301, public headers = void 0 as OutgoingHttpHeaders) {
-        super();
+    constructor(public location: string, status = 301, headers = void 0 as OutgoingHttpHeaders) {
+        super({ status, headers });
     }
 
+
     async send(res: WrappedResponse) {
         return res.sendRedirect(this.location, this.status, this.headers);
     }
 
 }
 
-export default class Content extends PageResult {
-
-    public static json(json: any, status = 200) {
-        return new Content({
-            body: JSON.stringify(json),
-            contentType: "application/json",
-            status,
-            compress: "gzip"
-        });
-    }
-
-    public static html(html, status = 200) {
-        return new Content({
-            body: html,
-            contentType: "text/html",
-            status,
-            compress: "gzip"
-        });
-    }
-
-    public static create(
-        body: Partial<Content>
-    ) {
-        return new Content(body);
-    }
-
-
-    public status: number;
-
-    public contentType: string;
-
-    public suppressLog: boolean;
-
-    public body: string | Buffer | XNode;
-
-    public headers: OutgoingHttpHeaders;
-
-    public compress: "gzip" | "deflate" | null = null;
-
-    private constructor(p: Partial<Content>) {
-        super();
-        Object.setPrototypeOf(p, Content.prototype);
-        p.contentType ??= "text/plain";
-        p.status ??= 200;
-        if (p.body === void 0) {
-            throw new Error(`Body cannot be undefined`);
-        }
-        return p as Content;
-    }
-
-    public async send(res: WrappedResponse, user?: SessionUser) {
-        const { status, body, contentType } = this;
-        const { headers } = this;
-        if (headers) {
-            for (const key in headers) {
-                if (Object.hasOwn(headers, key)) {
-                    const element = headers[key];
-                    res.setHeader(key, element);
-                }
-            }
-        }
-
-        res.compress = this.compress;
-
-        res.setHeader("content-type", contentType);
-        res.statusCode = status;
-        if (typeof body === "string") {
-            if (status >= 300 && !this.suppressLog) {
-                const u = user ? `User: ${user.userID},${user.userName}` : "User: Anonymous";
-                console.error(`${res.req.method} ${res.req.url}\n${status}\n${u}\n${body}`);
-            } else {
-                res.compress ||= "gzip";
-            }
-            res.send(body);
-            return;
-        }
-        if (body instanceof XNode) {
-            const text = body.render();
-            if (status >= 300 && !this.suppressLog) {
-                console.error(`${res.req.method} ${res.req.url}\n${status}\n${text}`);
-            } else {
-                res.compress ||= "gzip";
-            }
-            res.send(text);
-            return;
-        }
-        if (status >= 300 && !this.suppressLog) {
-            console.error(`${res.req.method} ${res.req.url}\n${status}\nBINARY DATA`);
-        }
-        res.send(body);
-        return;
-    }
-
-}
+// export default class Content extends PageResult {
+
+//     // public static json(json: any, status = 200) {
+//     //     return new Content({
+//     //         body: JSON.stringify(json),
+//     //         contentType: "application/json",
+//     //         status,
+//     //         compress: "gzip"
+//     //     });
+//     // }
+
+//     // public static html(html, status = 200) {
+//     //     return new Content({
+//     //         body: html,
+//     //         contentType: "text/html",
+//     //         status,
+//     //         compress: "gzip"
+//     //     });
+//     // }
+
+//     public static create(
+//         body: Partial<Content>
+//     ) {
+//         return new Content(body);
+//     }
+
+
+//     public status: number;
+
+//     public contentType: string;
+
+//     public suppressLog: boolean;
+
+//     public body: string | Buffer | XNode;
+
+//     public headers: OutgoingHttpHeaders;
+
+//     public compress: "gzip" | "deflate" | null = null;
+
+//     private constructor(p: Partial<Content>) {
+//         super();
+//         Object.setPrototypeOf(p, Content.prototype);
+//         p.contentType ??= "text/plain";
+//         p.status ??= 200;
+//         if (p.body === void 0) {
+//             throw new Error(`Body cannot be undefined`);
+//         }
+//         return p as Content;
+//     }
+
+//     public async send(res: WrappedResponse, user?: SessionUser) {
+//         const { status, body, contentType } = this;
+//         const { headers } = this;
+//         if (headers) {
+//             for (const key in headers) {
+//                 if (Object.hasOwn(headers, key)) {
+//                     const element = headers[key];
+//                     res.setHeader(key, element);
+//                 }
+//             }
+//         }
+
+//         res.compress = this.compress;
+
+//         res.setHeader("content-type", contentType);
+//         res.statusCode = status;
+//         if (typeof body === "string") {
+//             if (status >= 300 && !this.suppressLog) {
+//                 const u = user ? `User: ${user.userID},${user.userName}` : "User: Anonymous";
+//                 console.error(`${res.req.method} ${res.req.url}\n${status}\n${u}\n${body}`);
+//             } else {
+//                 res.compress ||= "gzip";
+//             }
+//             res.sendReader(status, headers, Readable.from([  body ]));
+//             return;
+//         }
+//         if (body instanceof XNode) {
+//             const text = body.render();
+//             if (status >= 300 && !this.suppressLog) {
+//                 console.error(`${res.req.method} ${res.req.url}\n${status}\n${text}`);
+//             } else {
+//                 res.compress ||= "gzip";
+//             }
+//             res.send(text);
+//             return;
+//         }
+//         if (status >= 300 && !this.suppressLog) {
+//             console.error(`${res.req.method} ${res.req.url}\n${status}\nBINARY DATA`);
+//         }
+//         res.send(body);
+//         return;
+//     }
+
+// }

package/src/Page.tsx

@@ -1,12 +1,14 @@
 import busboy from "busboy";
 import HtmlDocument from "./html/HtmlDocument.js";
 import XNode from "./html/XNode.js";
-import Content, { PageResult, Redirect } from "./Content.js";
+// import Content, { PageResult, Redirect } from "./Content.js";
 import { LocalFile } from "./core/LocalFile.js";
 import { WrappedRequest, WrappedResponse } from "./core/Wrapped.js";
 import { ServiceProvider } from "@entity-access/entity-access/dist/di/di.js";
 import { IClassOf } from "@entity-access/entity-access/dist/decorators/IClassOf.js";
 import { OutgoingHttpHeaders } from "http";
+import Content, { Redirect } from "./Content.js";
+import JsonGenerator from "@entity-access/entity-access/dist/common/JsonGenerator.js";
 
 export const isPage = Symbol("isPage");
 
@@ -94,7 +96,7 @@ export default abstract class Page<TInput = any, TQuery = any> {
         this.cacheControl = "no-cache, no-store, max-age=0";
     }
 
-    abstract run(): PageResult | Promise<PageResult>;
+    abstract run(): Content | Promise<Content>;
 
     resolve<T>(c: IClassOf<T>): T {
         return ServiceProvider.resolve(this, c);
@@ -104,22 +106,27 @@ export default abstract class Page<TInput = any, TQuery = any> {
         console.error(error);
     }
 
-    protected content(h: Partial<Content>): Content;
-    protected content(body: string, status?: number, contentType?: string, headers?: OutgoingHttpHeaders): Content;
-    protected content(body: string | Partial<Content>, status?: number, contentType?: string, headers?: OutgoingHttpHeaders) {
-        if (typeof body !== "object") {
-            body = { body, status, contentType, headers};
-        }
-        body.status ??= 200;
-        body.contentType ??= "text/html";
-        return Content.create(body);
-    }
+    // protected content(h: Partial<Content>): Content;
+    // protected content(body: string, status?: number, contentType?: string, headers?: OutgoingHttpHeaders): Content;
+    // protected content(body: string | Partial<Content>, status?: number, contentType?: string, headers?: OutgoingHttpHeaders) {
+    //     if (typeof body !== "object") {
+    //         body = { body, status, contentType, headers};
+    //     }
+    //     body.status ??= 200;
+    //     body.contentType ??= "text/html";
+    //     return Content.create(body);
+    // }
 
     protected json(o: any, indent = 0, headers = void 0 as OutgoingHttpHeaders) {
-        const content = indent
-            ? JSON.stringify(o, undefined, indent)
-            : JSON.stringify(o);
-        return this.content(content, 200, "application/json", headers);
+        // const content = indent
+        //     ? JSON.stringify(o, undefined, indent)
+        //     : JSON.stringify(o);
+        const jsr = new JsonGenerator(this);
+        headers ??= {};
+        headers["content-type"] = "application/json; charset=utf8";
+        return Content.readable(jsr.reader(o), {
+            headers
+        });
     }
 
     protected redirect(location: string) {
@@ -127,7 +134,7 @@ export default abstract class Page<TInput = any, TQuery = any> {
     }
 
     protected notFound(suppressLog = true): Content | Promise<Content> {
-        const c = Content.html(<HtmlDocument>
+        return Content.text(<HtmlDocument>
                 <head>
                     <title>Not found</title>
                 </head>
@@ -136,15 +143,16 @@ export default abstract class Page<TInput = any, TQuery = any> {
                     <pre>{this.url} not found</pre>
                 </body>
             </HtmlDocument>,
-            404
+            {
+                status: 404,
+                suppressLog
+            }
         );
-        c.suppressLog = suppressLog;
-        return c;
     }
 
     protected serverError(error, status = 500): Content | Promise<Content> {
-        return Content.create({
-            body: <HtmlDocument>
+        return Content.text(
+            <HtmlDocument>
                     <head>
                         <title>Server Error</title>
                     </head>
@@ -153,7 +161,9 @@ export default abstract class Page<TInput = any, TQuery = any> {
                         <pre>{error.stack ?? error}</pre>
                     </body>
                 </HtmlDocument>,
-            status
-        });
+            {
+                status
+            }
+        );
     }
 }

package/src/ServerPages.ts

@@ -21,6 +21,7 @@ import { WebSocket } from "ws";
 import { UrlParser } from "./core/UrlParser.js";
 import { createConnection } from "node:net";
 import HttpIPCProxyReceiver from "./core/HttpIPCProxyReceiver.js";
+import JsonGenerator from "@entity-access/entity-access/dist/common/JsonGenerator.js";
 
 export const wsData = Symbol("wsData");
 
@@ -338,17 +339,25 @@ export default class ServerPages {
                     try {
 
                         if (acceptJson || error.errorModel) {
-                            await Content.json(
+
+                            const json = new JsonGenerator(this);
+                            const reader = json.reader({
+                                details: error.stack ?? error,
+                                ... error.errorModel ?? {},
+                                message: error.message ?? error,
+                            })
+
+                            await new Content(
                                     {
-                                        details: error.stack ?? error,
-                                        ... error.errorModel ?? {},
-                                        message: error.message ?? error,
+                                        reader,
+                                        status: error.errorModel?.status ?? 500
                                     }
-                            , error.errorModel?.status ?? 500).send(resp);
+                            ,).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);
+                        const content = Content.text(`<!DOCTYPE html>\n<html><body><pre>Server Error for ${req.url}\r\n${error?.stack ?? error}</pre></body></html>`,
+                            { status: 500});
                         await content.send(resp);
                     } catch (e1) {
                         e1 = e1.stack ?? e1.toString();

package/src/core/Compression.ts

@@ -1,15 +1,26 @@
-import { deflateSync, gzipSync } from "zlib";
+import { Readable } from "stream";
+import { createGzip, deflateSync, gzipSync, createDeflate } from "zlib";
 
 export default class Compression {
 
-    public static gzip(data: Buffer | string) {
+    public static gzip(readable: Readable) {
+        const stream = createGzip();
+        return readable.pipe(stream);
+    }
+
+    public static deflate(readable: Readable) {
+        const stream = createDeflate();
+        return readable.pipe(stream);
+    }
+
+    public static gzipSync(data: Buffer | string) {
         if (typeof data === "string") {
             data = Buffer.from(data, "utf-8");
         }
         return gzipSync(data);
     }
 
-    public static deflate(data: Buffer | string) {
+    public static deflateSync(data: Buffer | string) {
         if (typeof data === "string") {
             data = Buffer.from(data, "utf-8");
         }

package/src/core/RouteTree.ts

@@ -179,7 +179,7 @@ export default class RouteTree {
 
                     async run() {
                         const r = await pageClass.call(this);
-                        return Content.create(r);
+                        return r;
                     }
                 }
                 return c;

package/src/core/Utf8Readable.ts

@@ -0,0 +1,15 @@
+import { Readable } from "stream";
+
+export default class Utf8Readable {
+
+    static from(text: Iterable<string>) {
+        return Readable.from( this.toUtf8Iterable(text));
+    }
+
+    private static *toUtf8Iterable(text: Iterable<string>) {
+        for (const element of text) {
+            yield Buffer.from(element, "utf8");
+        }
+    }
+
+}