@entity-access/server-pages 1.0.42 → 1.1.2

package/src/Page.tsx

@@ -45,20 +45,20 @@ export default class Page {
 
     response: WrappedResponse;
 
-    get query() {
+    get query(): any {
         return this.request?.query;
     }
 
-    get asyncJsonBody() {
-        return this.request?.asyncJsonBody;
+    get body(): any {
+        return this.request?.body;
     }
 
-    get asyncForm() {
-        return this.request?.asyncForm;
+    get form() {
+        return this.request?.form;
     }
 
-    get asyncParams() {
-        return this.request?.asyncParams;
+    get sessionUser() {
+        return this.request?.sessionUser;
     }
 
     get url() {
@@ -75,13 +75,6 @@ export default class Page {
 
     childPath: string[];
 
-    /**
-     * List of all paths that were tried before executing this page.
-     */
-    notFoundPath: string[];
-
-    sessionUser: SessionUser;
-
     filePath: string;
 
     cacheControl: string;
@@ -94,47 +87,14 @@ export default class Page {
         this.cacheControl = "no-cache, no-store, max-age=0";
     }
 
-    all(): IPageResult | Promise<IPageResult> {
-        return this.notFound();
+    reportError(error) {
+        console.error(error);
     }
 
-    readFormData(): Promise<IFormData> {
-
-        return this.formDataPromise ??= (async () => {
-            let tempFolder: TempFolder;
-            const result: IFormData = {
-                fields: {},
-                files: []
-            };
-            const req = this.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;
-        })();
+    run(): IPageResult | Promise<IPageResult> {
+        return this.notFound();
     }
 
-
     protected content(body: string, status = 200, contentType = "text/html") {
         return Content.create({ body, status, contentType });
     }

package/src/ServerPages.ts

@@ -13,6 +13,10 @@ import { Wrapped } from "./core/Wrapped.js";
 import { SecureContext } from "node:tls";
 import  AcmeCertificateService, { IAcmeOptions } from "./ssl/AcmeCertificateService.js";
 import ChallengeServer from "./ssl/ChallengeServer.js";
+import SessionUser from "./core/SessionUser.js";
+import CookieService from "./services/CookieService.js";
+import TokenService from "./services/TokenService.js";
+import Executor from "./core/Executor.js";
 
 RegisterSingleton
 export default class ServerPages {
@@ -145,7 +149,15 @@ export default class ServerPages {
 
             using scope = ServiceProvider.createScope(this);
             let sent = false;
-            const acceptJson = req.accepts().some((s) => /\/json$/i.test(s));
+            const user = scope.resolve(SessionUser);
+            user.resp = resp;
+            user.authorize = async () => {
+                const cookieService = scope.resolve(CookieService);
+                const tokenService = scope.resolve(TokenService);
+                await cookieService.createSessionUserFromCookie(tokenService.authCookieName, req.remoteIPAddress);
+                (user as any).isAuthorized = true;
+            };
+            const acceptJson = req.accepts("json");
 
 
             try {
@@ -165,7 +177,7 @@ export default class ServerPages {
                 page.childPath = childPath;
                 page.request = req;
                 page.response = resp;
-                const content = await page.all();
+                const content = await Executor.run(page);
                 resp.setHeader("cache-control", page.cacheControl);
                 resp.removeHeader("etag");
                 sent = true;

package/src/core/CacheProperty.ts

@@ -0,0 +1,18 @@
+export const CacheProperty = {
+    value: (target: any, name: string, value: any) => {
+        Object.defineProperty(target, name, { 
+            value,
+            enumerable: true,
+            configurable: true
+        });
+        return value;
+    },
+    get: (target: any, name: string, get: Function) => {
+        Object.defineProperty(target, name, { 
+            get: get as any,
+            enumerable: true,
+            configurable: true
+        });
+        return get.call(target);
+    }
+};

package/src/core/Executor.ts

@@ -0,0 +1,16 @@
+import Page from "../Page.js";
+import { prepareSymbol } from "../decorators/Prepare.js";
+
+export default class Executor {
+
+    public static async run(c: Page) {
+        let ps = c.constructor[prepareSymbol];
+        if (ps) {
+            for (const iterator of ps) {
+                await iterator();
+            }
+        }
+        return c.run();
+    }
+
+}

package/src/core/RouteTree.ts

@@ -1,10 +1,10 @@
 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";
+import { prepareSymbol } from "../decorators/Prepare.js";
 
 export interface IRouteHandler {
     get?: Promise<typeof Page>;
@@ -113,12 +113,16 @@ export default class RouteTree {
                 if (pageClass[isPage]) {
                     return pageClass as typeof Page;
                 }
-                return class extends Page {
-                    async all() {
+                const c = class extends Page {
+
+                    [prepareSymbol] = pageClass[prepareSymbol];
+
+                    async run() {
                         const r = await pageClass.call(this);
                         return Content.create(r);
                     }
                 }
+                return c;
             })();
 
             (this.handler ??= {})[name] = promise;

package/src/core/SessionUser.ts

@@ -14,27 +14,37 @@ export default class SessionUser {
     /**
      * SessionID saved in database for current session.
      */
-    sessionID: number;
+    get sessionID(): number | null {
+        throw new Error("Please call Authorize first");
+    }
 
     /**
      * UserID
      */
-    userID?: number;
+    get userID(): number | null {
+        throw new Error("Please call Authorize first");
+    }
 
     /**
      * Logged in user name
      */
-    userName?: string;
+    get userName(): string {
+        throw new Error("Please call Authorize first");
+    }
 
     /**
      * Application Roles, user is associated with.
      */
-    roles?: string[];
+    get roles(): string[] {
+        throw new Error("Please call Authorize first");
+    }
 
     /**
      * Expiry date, after which this session is invalid
      */
-    expiry?: Date;
+    get expiry(): Date {
+        throw new Error("Please call Authorize first");
+    }
 
     /**
      * If set to true, session is no longer valid.
@@ -49,9 +59,15 @@ export default class SessionUser {
 
     public resp: WrappedResponse;
 
+    private isAuthorized = false;
+
     @Inject
     protected tokenService: TokenService;
 
+    public async authorize() {
+        this.isAuthorized = true;
+    }
+
     isInRole(role: roles) {
         return this.roles?.includes(role) ?? false;
     }