@entity-access/server-pages 1.1.348 → 1.1.350

package/src/core/Wrapped.ts

@@ -58,6 +58,8 @@ export interface IWrappedRequest {
 
     accepts(): string[];
     accepts(... types: string[]): boolean;
+
+    get acceptEncodings(): string[];
 }
 
 
@@ -69,16 +71,14 @@ export interface IWrappedResponse {
 
     asyncEnd();
 
-    asyncWrite(buffer: Buffer): Promise<void>;
-
-    // setHeader(name: string, value: string);
 
+    sendReader(status: number, headers: OutgoingHttpHeaders, readable: Readable): Promise<void>;
 
-    asyncPipe(status: number, headers: OutgoingHttpHeaders, readable: Readable): Promise<void>;
+    // sendGenerator(data: Iterable<Buffer> | AsyncIterable<Buffer>, status: number, headers?: OutgoingHttpHeaders): Promise<void>;
 
-    send(data: Buffer | string | Blob, status?: number): Promise<void>;
+    // send(data: Buffer | string | Blob, status?: number): Promise<void>;
 
-    sendStatus(status?: number, headers?: OutgoingHttpHeaders): Promise<void>;
+    // sendStatus(status?: number, headers?: OutgoingHttpHeaders): Promise<void>;
 
     sendRedirect(url: string, status?: number, headers?: OutgoingHttpHeaders): void;
 
@@ -119,6 +119,13 @@ const extendRequest = (A: typeof IncomingMessage | typeof Http2ServerRequest) =>
                 return CacheProperty.value(this, "hostName", host);
             }
 
+            get acceptEncodings(): string[] {
+                const r = this as any as (Http2ServerRequest  | IncomingMessage);
+                const acceptEncoding = ((r as Http2ServerRequest).authority || r.headers["accept-encoding"] || null).toString();
+                const encodings = acceptEncoding.split(/[\,\;]/);
+                return encodings;
+            }
+
             get host(): string {
                 const r = this as any as (Http2ServerRequest  | IncomingMessage);
                 const host = (r as Http2ServerRequest).authority || r.headers[":authority"] || r.headers.host || null;
@@ -221,16 +228,19 @@ const extendResponse = (A: typeof ServerResponse | typeof Http2ServerResponse) =
             asyncEnd(this: UnwrappedResponse) {
                 return new Promise<void>((resolve) => this.end(resolve));
             }
-        
-            asyncWrite(this: UnwrappedResponse, buffer: Buffer, start?: number, length?: number) {
-                return new Promise<void>((resolve, reject) => 
-                    this.write(buffer, (error) => error ? reject(error) : resolve())
-                );        
-            }
 
-            asyncPipe(this: UnwrappedResponse, status: number, headers: OutgoingHttpHeaders, readable: Readable, signal?: AbortSignal) {
+            sendReader(this: UnwrappedResponse, status: number, headers: OutgoingHttpHeaders, readable: Readable, signal?: AbortSignal) {
+                let input = readable as any;
+                const encodings = (this.req as WrappedRequest).acceptEncodings;
+                if (encodings.includes("gzip")) {
+                    headers["accept-encoding"] = "gzip";
+                    input = Compression.gzip(readable);
+                } else if (encodings.includes("deflate")) {
+                    headers["accept-encoding"] = "deflate";
+                    input = Compression.deflate(readable);
+                }
                 this.writeHead(status, headers);
-                return pipeline(readable, this, { signal, end: true });
+                return pipeline(input, this, { signal, end: true });
             }
         
             cookie(this: UnwrappedResponse, name: string, value: string, options: SerializeOptions = {}) {
@@ -250,105 +260,105 @@ const extendResponse = (A: typeof ServerResponse | typeof Http2ServerResponse) =
             //     headers[name] = value;
             // }
 
-            async sendStatus(this: UnwrappedResponse, status?: number, headers?: OutgoingHttpHeaders): Promise<void> {
-                const wrapped = (this as any as WrappedResponse);
-                this.statusCode = status;
-                let sent = false;
-                try {
-                    this.writeHead(this.statusCode, headers);
-                    sent = true;
-                    return (wrapped as any).asyncEnd();
-                } catch (error) {
-                    console.error(error);
-                    if (sent) {
-                        return (this as any).asyncEnd();
-                    }
-                    return (this as any).send(error.stack ?? error.toString(), 500);
-                }
-            }
+            // async sendStatus(this: UnwrappedResponse, status?: number, headers?: OutgoingHttpHeaders): Promise<void> {
+            //     const wrapped = (this as any as WrappedResponse);
+            //     this.statusCode = status;
+            //     let sent = false;
+            //     try {
+            //         this.writeHead(this.statusCode, headers);
+            //         sent = true;
+            //         return (wrapped as any).asyncEnd();
+            //     } catch (error) {
+            //         console.error(error);
+            //         if (sent) {
+            //             return (this as any).asyncEnd();
+            //         }
+            //         return (this as any).send(error.stack ?? error.toString(), 500);
+            //     }
+            // }
         
-            async send(this: UnwrappedResponse, data: Buffer | string, status: number = this.statusCode || 200) {
-                let sent = false;
-                const wrapped = (this as any as WrappedResponse);
-                try {
-                    wrapped.statusCode = status;
-                    const headers = this.getHeaders();
-                    headers["content-type"] ??= "text/html";
-                    if (typeof data === "string") {
-                        data = Buffer.from(data, "utf-8");
-                        let ct = headers["content-type"];
-                        if (Array.isArray(ct)) {
-                            ct = ct.join(";");
-                        } else {
-                            ct = ct.toString();
-                        }
-                        const index = ct.indexOf(";");
-                        if (index !== -1) {
-                            ct = ct.substring(0, index);
-                        }
-                        ct += "; charset=utf-8";
-                    }
-                    // compress if required...
-                    if (data === null || data === void 0) {
-                        throw new Error("Data cannot be null or undefined.");
-                    }
-                    data = wrapped.compressData(data, headers);
-                    headers["content-length"] = data.length.toString();
-                    this.writeHead(status, headers);
-                    sent = true;
-                    await StreamHelper.write(this, data);
-                    return (this as any).asyncEnd();
-                } catch (error) {
-                    console.error(error);
-                    if (sent) {
-                        return (this as any).asyncEnd();
-                    }
-                    if (this.statusCode === 500) {
-                        // recursive...
-                        try {
-                            await StreamHelper.write(this, Buffer.from("", "utf-8"))
-                            return (this as any).asyncEnd();
-                        } catch (er) {
-                            console.error(er);
-                            return (this as any).asyncEnd();
-                        }
-                    }
-                    return (this as any).send(error.stack ?? error.toString(), 500);
-                }
-            }
+            // async send(this: UnwrappedResponse, data: Buffer | string, status: number = this.statusCode || 200) {
+            //     let sent = false;
+            //     const wrapped = (this as any as WrappedResponse);
+            //     try {
+            //         wrapped.statusCode = status;
+            //         const headers = this.getHeaders();
+            //         headers["content-type"] ??= "text/html";
+            //         if (typeof data === "string") {
+            //             data = Buffer.from(data, "utf-8");
+            //             let ct = headers["content-type"];
+            //             if (Array.isArray(ct)) {
+            //                 ct = ct.join(";");
+            //             } else {
+            //                 ct = ct.toString();
+            //             }
+            //             const index = ct.indexOf(";");
+            //             if (index !== -1) {
+            //                 ct = ct.substring(0, index);
+            //             }
+            //             ct += "; charset=utf-8";
+            //         }
+            //         // compress if required...
+            //         if (data === null || data === void 0) {
+            //             throw new Error("Data cannot be null or undefined.");
+            //         }
+            //         data = wrapped.compressData(data, headers);
+            //         headers["content-length"] = data.length.toString();
+            //         this.writeHead(status, headers);
+            //         sent = true;
+            //         await StreamHelper.write(this, data);
+            //         return (this as any).asyncEnd();
+            //     } catch (error) {
+            //         console.error(error);
+            //         if (sent) {
+            //             return (this as any).asyncEnd();
+            //         }
+            //         if (this.statusCode === 500) {
+            //             // recursive...
+            //             try {
+            //                 await StreamHelper.write(this, Buffer.from("", "utf-8"))
+            //                 return (this as any).asyncEnd();
+            //             } catch (er) {
+            //                 console.error(er);
+            //                 return (this as any).asyncEnd();
+            //             }
+            //         }
+            //         return (this as any).send(error.stack ?? error.toString(), 500);
+            //     }
+            // }
 
-            private compressData(data: string | Buffer, headers: OutgoingHttpHeaders) {
-                const { compress } = this;
-                if (!compress) {
-                    return data;
-                }
-                let { "accept-encoding": accept } = (this as IWrappedResponse).request?.headers;
-                if (!accept) {
-                    return data;
-                }
-                if (typeof accept === "string") {
-                    accept = accept.split(",");
-                } else {
-                    if (!Array.isArray(accept)) {
-                        return data;
-                    }
-                    accept = accept.flatMap((x) => x.split(","));
-                }
-                if (!accept.includes(compress)) {
-                    return data;
-                }
-                switch (compress) {
-                    case "deflate":
-                        data = Compression.deflate(data);
-                        headers["content-encoding"] = compress;
-                        break;
-                    case "gzip":
-                        data = Compression.gzip(data);
-                        headers["content-encoding"] = compress;
-                        break;
-                }                
-                return data;
-            }
+            // private compressData(data: string | Buffer, headers: OutgoingHttpHeaders) {
+            //     const { compress } = this;
+            //     if (!compress) {
+            //         return data;
+            //     }
+            //     let { "accept-encoding": accept } = (this as IWrappedResponse).request?.headers;
+            //     if (!accept) {
+            //         return data;
+            //     }
+            //     if (typeof accept === "string") {
+            //         accept = accept.split(",");
+            //     } else {
+            //         if (!Array.isArray(accept)) {
+            //             return data;
+            //         }
+            //         accept = accept.flatMap((x) => x.split(","));
+            //     }
+            //     if (!accept.includes(compress)) {
+            //         return data;
+            //     }
+            //     switch (compress) {
+            //         case "deflate":
+            //             data = Compression.deflateSync(data);
+            //             headers["content-encoding"] = compress;
+            //             break;
+            //         case "gzip":
+            //             data = Compression.gzipSync(data);
+            //             headers["content-encoding"] = compress;
+            //             break;
+            //     }                
+            //     return data;
+            // }
 
             async sendRedirect(this: UnwrappedResponse, location: string, status = 301, headers: OutgoingHttpHeaders = {}) {
                 this.statusCode = status;

package/src/html/HtmlComment.ts

@@ -15,6 +15,16 @@ class Comment extends XNode {
         return `<!--${comments}-->`
     }
 
+    public *readable(nest?: string) {
+        nest ??= "";
+        yield "<!--";
+        for (const element of this.nodes) {
+            yield nest;
+            yield element;
+            yield "\n";
+        }
+    }
+
 }
 
 export default function HtmlComment({}, ... nodes: string[]) {

package/src/html/HtmlDocument.tsx

@@ -9,6 +9,11 @@ class DocumentNode extends XNode {
     public render(nest?: string): string {
         return `<!DOCTYPE html>\n${super.render(nest)}`;
     }
+
+    public * readable(nest?: string) {
+        yield `<!DOCTYPE html>\n`;
+        yield * super.readable(nest);
+    }
 }
 
 export default function HtmlDocument({ lang = "en"}, ... nodes: (XNode | string)[]): XNode {

package/src/html/XNode.ts

@@ -1,6 +1,14 @@
 // use parse5 to serialize html correctly
 import { escapeText, escapeAttribute } from "entities";
 
+type INodeToken = {
+    target: XNode;
+    token?: never;
+} | {
+    token: string;
+    target?: never;
+}
+
 export default class XNode {
 
     public static create(
@@ -55,4 +63,54 @@ export default class XNode {
         return `${nest}<${name}${a}>\n${nest}\t${children.join("\n\t")}\n${nest}</${name}>`;
     }
 
+    public *readable(nest = "") {
+
+        const { name, attributes, children } = this;
+
+        if (nest) {
+            yield nest;
+        }
+
+        yield `<${name}`;
+
+        if (attributes) {
+            for (const key in attributes) {
+                if (Object.hasOwn(attributes, key)) {
+                    const element = attributes[key];
+
+                    if (nest) {
+                        yield nest + "\t";
+                    }
+                    yield `${escapeAttribute(key)}="${escapeAttribute(element)}"\n`;
+                }
+            }
+        }
+
+        if (nest) {
+            yield nest;
+        }
+
+        yield ">\n";
+
+        if (children) {
+            for (const child of children) {
+                if (typeof child === "string") {
+                    yield escapeText(child);
+                    continue;
+                }
+                if (!child) {
+                    continue;
+                }
+                yield * child.readable(nest + "\t");
+            }
+        }
+
+        if (nest) {
+            yield nest;
+        }
+
+        yield `</${name}>`;
+
+    }
+
 }

package/src/routes/api/entity/expand/[entity]/[property]/[keys]/get.ts

@@ -42,13 +42,13 @@ export default class extends Page {
             this.cacheControl = `public, max-age=${cache}`;
         }
 
-        return this.json(await EntityAccessServer.query(this.db, {
+        return await EntityAccessServer.query(this.db, {
             entity,
             expand,
             expandKeys,
             ... this.query,
             ... this.body
-        }, this.sessionUser));
+        });
     }
 
 }

package/src/routes/api/entity/invoke/[entityName]/[methodName]/post.tsx

@@ -6,7 +6,8 @@ import SchemaRegistry from "@entity-access/entity-access/dist/decorators/SchemaR
 import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
 import ExternalInvoke from "../../../../../../decorators/ExternalInvoke.js";
 import { Route } from "../../../../../../core/Route.js";
-import Content, { PageResult } from "../../../../../../Content.js";
+import Content from "../../../../../../Content.js";
+import DbJsonReadable from "../../../../../../services/DbJsonService.js";
 
 export default class extends Page {
 
@@ -62,7 +63,7 @@ export default class extends Page {
         // now execute external method
         const result = await events[methodName](e, ... args);
 
-        if (result instanceof PageResult) {
+        if (result instanceof Content) {
             return result;
         }
 
@@ -71,9 +72,14 @@ export default class extends Page {
         //         ? GraphService.prepareGraph(result, this.sessionUser)
         //         : {});
         if (!result) {
-            return this.content({ body:"{}", contentType: "application/json"});
+            return Content.text("{}", {
+                headers: {
+                    "content-type": "application/json; charset=utf8"
+                }
+            });
         }
 
+        return DbJsonReadable.toJson(this.db, result);
         
     }
 }

package/src/routes/api/entity/model.ts/get.tsx

@@ -2,6 +2,7 @@ import Inject from "@entity-access/entity-access/dist/di/di.js";
 import EntityContext from "@entity-access/entity-access/dist/model/EntityContext.js";
 import Page from "../../../../Page.js";
 import ModelService from "../../../../services/ModelService.js";
+import Content from "../../../../Content.js";
 
 export default class extends Page {
 
@@ -10,7 +11,12 @@ export default class extends Page {
 
     run() {
 
-        return this.content(ModelService.getModelDeclaration(this.db), 200, "text/typescript");
+        return Content.text(
+            ModelService.getModelDeclaration(this.db), {
+                headers: {
+                    "content-type": "text/typescript; charset=utf8"
+                }
+            });
     }
 
 }

package/src/routes/api/entity/query/[entity]/get.ts

@@ -25,11 +25,11 @@ export default class extends Page {
             this.cacheControl = `public, max-age=${cache}`;
         }
 
-        return this.json(await EntityAccessServer.query(this.db, {
+        return await EntityAccessServer.query(this.db, {
             entity,
             ... this.query,
             ... this.body
-        }, this.sessionUser));
+        });
     }
 
 }

package/src/routes/api/entity/run/[entity]/[methodName]/index.ts

@@ -3,14 +3,12 @@ import EntityContext from "@entity-access/entity-access/dist/model/EntityContext
 import Page from "../../../../../../Page.js";
 import { Route } from "../../../../../../core/Route.js";
 import { Prepare } from "../../../../../../decorators/Prepare.js";
-import EntityAccessServer from "../../../../../../services/EntityAccessServer.js";
-import SessionEncryption from "../../../../../../services/SessionEncryption.js";
 import EntityAccessError from "@entity-access/entity-access/dist/common/EntityAccessError.js";
 import SchemaRegistry from "@entity-access/entity-access/dist/decorators/SchemaRegistry.js";
-import { PageResult } from "../../../../../../Content.js";
 import ExternalInvoke from "../../../../../../decorators/ExternalInvoke.js";
 import JsonService from "../../../../../../services/DbJsonService.js";
 import SessionSecurity from "../../../../../../services/SessionSecurity.js";
+import Content from "../../../../../../Content.js";
 
 @Prepare.authorize
 @Prepare.parseJsonBody
@@ -63,12 +61,16 @@ export default class extends Page {
         // now execute external method
         const result = await events[methodName](entity, ... args);
 
-        if (result instanceof PageResult) {
+        if (result instanceof Content) {
             return result;
         }
 
         if (!result) {
-            return this.content({ body: "{}", contentType: "application/json"});
+            return Content.text("{}", {
+                headers: {
+                    "content-type": "application/json; charset=utf8"
+                }
+            });
         }
 
         return JsonService.toJson(this.db, result);

package/src/services/DbJsonService.ts

@@ -1,18 +1,23 @@
-import JsonReadable from "@entity-access/entity-access/dist/common/JsonReadable.js";
-import { JsonReaderResult } from "../Content.js";
+import JsonGenerator from "@entity-access/entity-access/dist/common/JsonGenerator.js";
 import EntityContext from "@entity-access/entity-access/dist/model/EntityContext.js";
+import Content from "../Content.js";
 
-export default class DbJsonReadable extends JsonReadable {
+export default class DbJsonReadable extends JsonGenerator {
 
     static toJson(db: EntityContext, item: any) {
-        const js = new DbJsonReadable(db, item);
-        return  new JsonReaderResult(js);
+        const js = new DbJsonReadable(db);
+        const reader = js.reader(item);
+        return  new Content({
+            reader,
+            headers: {
+                "content-type": "application/json; charset=utf8"
+            }
+        });
     }
 
     constructor(
-        private readonly db: EntityContext,
-        model: any) {
-        super(model, db)
+        private readonly db: EntityContext) {
+        super(db)
     }
 
     preJSON(item: any) {

package/src/services/EntityAccessServer.ts

@@ -43,8 +43,7 @@ export default class EntityAccessServer {
 
     public static async query(
         db: EntityContext,
-        options: IEntityQueryOptions,
-        user: SessionUser) {
+        options: IEntityQueryOptions) {
 
         db.verifyFilters = true;
         db.raiseEvents = true;
@@ -133,8 +132,6 @@ export default class EntityAccessServer {
 
         let items;
 
-        const beforeSerialize = (events as any).beforeSerialize as Function;
-
 
         if (count) {
             const total = await oq.count();
@@ -142,9 +139,6 @@ export default class EntityAccessServer {
                 q = q.trace(console.log);
             }
             items = await q.toArray();
-            if (beforeSerialize) {
-                await beforeSerialize.call(events, items);
-            }
             return DbJsonService.toJson(db, {
                 total,
                 items
@@ -155,9 +149,6 @@ export default class EntityAccessServer {
             q = q.trace(console.log);
         }
         items = await q.toArray();
-        if (beforeSerialize) {
-            await beforeSerialize.call(events, items);
-        }
         return DbJsonService.toJson(db, {
             total: 0,
             items

package/src/tests/logger/index.tsx

@@ -12,7 +12,7 @@ export default function(this: Page) {
         }
     }
 
-    return Content.html(<HtmlDocument>
+    return Content.text(<HtmlDocument>
         <body>
             Test 1
         </body>