@webqit/webflo 0.11.61 → 1.0.1

package/src/runtime-pi/client/worker/Workport.js

@@ -1,78 +1,18 @@
+export class Workport {
 
-export default class Workport {
-
-    constructor() {
-        // --------
-        // Post messaging
-        // --------
-        this.messaging = {
-            post: (message, client = this.client) => {
-                if (!client) throw new Error(`No client for this operation.`);
-                client.postMessage(message);
-                return this;
-            },
-            listen: (callback, client = this.client) => {
-                (client || self).addEventListener('message', evt => {
-                    this.client = evt.source;
-                    const response = callback(evt);
-                    let responsePort = evt.ports[0];
-                    if (responsePort) {
-                        if (response instanceof Promise) {
-                            response.then(data => {
-                                responsePort.postMessage(data);
-                            });
-                        } else {
-                            responsePort.postMessage(response);
-                        }
-                    }
-                });
-                return this;
-            },
-            request: (message, client = this.client) => {
-                if (!client) throw new Error(`No client for this operation.`);
-                return new Promise(res => {
-                    let messageChannel = new MessageChannel();
-                    client.postMessage(message, [ messageChannel.port2 ]);
-                    messageChannel.port1.onmessage = e => res(e.data);
-                });
-            },
-            channel(channelId) {
-                if (!this.channels.has(channelId)) { this.channels.set(channelId, new BroadcastChannel(channel)); }
-                let channel = this.channels.get(channelId);
-                return {
-                    broadcast: message => channel.postMessage(message),
-                    listen: callback => channel.addEventListener('message', callback),
-                };
-            },
-            channels: new Map,
-        };
-
-        // --------
-        // Notifications
-        // --------
-        this.notifications = {
-            handle: callback => {
-                self.addEventListener('notificationclick', e => e.waitUntil(callback(e)));
-                return this;
-            },
-            fire: (title, params = {}) => {
-                return self.registration.showNotification(title, params);
-            },
-        };
-
-        // --------
-        // Push Notifications
-        // --------
-        this.push = {
-            listen: callback => {
-                self.addEventListener('push', e => e.waitUntil(callback(e)));
-                return this;
-            },
-        };
+    showNotification(title, params = {}) {
+        return self.registration.showNotification(title, params);
     }
 
-    setCurrentClient(client) {
-        this.client = client;
+    handleNotificationClick(callback) {
+        const handler = (e) => e.waitUntil(callback(e));
+        self.addEventListener('notificationclick', handler);
+        return () => self.removeEventListener('notificationclick', handler);
+    }
+    
+    handlePush(callback) {
+        const handler = (e) => e.waitUntil(callback(e));
+        self.addEventListener('push', handler);
+        return () => self.removeEventListener('notificationclick', handler);
     }
-
 }

package/src/runtime-pi/client/worker/index.js

@@ -1,21 +1,10 @@
+import { WebfloWorker } from './WebfloWorker.js';
 
-/**
- * @imports
- */
-import Context from './Context.js';
-import Application from './Application.js';
-import Runtime from './Runtime.js';
-
-/**
- * @start
- */
-export async function start(applicationInstance = null) {
-    const cx = this || {};
-    const defaultApplicationInstance = _cx => new Application(_cx);
-    return new Runtime(Context.create(cx), applicationInstance || defaultApplicationInstance);
+export function start() {
+    const instance = WebfloWorker.create(this || {});
+    instance.initialize();
 }
 
-/**
- * @APIS
- */
-export * as APIS from './Runtime.js';
+export {
+    WebfloWorker
+}

package/src/runtime-pi/index.js

@@ -1,14 +1,7 @@
-
-/**
- * @imports
- */
 import * as server from './server/index.js';
 import * as client from './client/generate.js';
 
-/**
- * @exports
- */
 export {
     server,
-    client,
+    client
 }

package/src/runtime-pi/server/ClientMessaging.js

@@ -0,0 +1,18 @@
+import { MultiportMessagingAPI } from '../MultiportMessagingAPI.js';
+
+export class ClientMessaging extends MultiportMessagingAPI {
+
+    get runtime() { return this.parentNode.parentNode; }
+
+    #portID;
+    get portID() { return this.#portID; }
+
+    constructor(parentNode/*ClientMessagingRegistry*/, portID, params = {}) {
+        super(parentNode, params);
+        this.#portID = portID;
+    }
+
+    createBroadcastChannel(name) {
+        return this.parentNode.createBroadcastChannel(name);
+    }
+}

package/src/runtime-pi/server/ClientMessagingRegistry.js

@@ -0,0 +1,57 @@
+import { ClientMessaging } from './ClientMessaging.js';
+import crypto from 'crypto';
+
+export class ClientMessagingRegistry extends Map {
+
+    #parentNode;
+    get parentNode() { return this.#parentNode; }
+
+    #sessionID;
+    get sessionID() { return this.#sessionID; }
+
+    #params;
+    get params() { return this.#params; }
+
+    #channels = new Map;
+
+    constructor(parentNode/*WebfloServer*/, sessionID, params = {}) {
+        super();
+        this.#parentNode = parentNode;
+        this.#sessionID = sessionID;
+        this.#params = params;
+    }
+
+    createPort() {
+        const portID = crypto.randomUUID();
+        const portInstance = new ClientMessaging(this, portID, this.#params);
+        this.set(portID, portInstance);
+        portInstance.on('empty', () => {
+            this.delete(portID);
+        });
+        setTimeout(() => {
+            if (portInstance.ports.size || !this.has(portID)) return;
+            this.delete(portID);
+        }, 30000/*30sec*/);
+        return portInstance;
+    }
+
+    createBroadcastChannel(name) {
+        if (!this.#channels.has(name)) {
+            this.#channels.set(name, new BroadcastChannel(this, name));
+        }
+        return this.#channels.get(name);
+    }
+}
+
+export class BroadcastChannel extends EventTarget {
+    #manager;
+    #name;
+    constructor(manager, name) {
+        super();
+        this.#manager = manager;
+        this.#name = name;
+    }
+
+    postMessage() {
+    }
+}

package/src/runtime-pi/server/Context.js

@@ -1,10 +1,6 @@
+import { AbstractContext } from '../../AbstractContext.js';
 
-/**
- * @imports
- */
-import _Context from '../../Context.js';
-
-export default class Context extends _Context {
+export class Context extends AbstractContext {
     // env
     get env() {
         return this.dict.env || {};

package/src/runtime-pi/server/CookieStorage.js

@@ -0,0 +1,17 @@
+import { WebfloCookieStorage } from '../WebfloCookieStorage.js';
+
+export class CookieStorage extends WebfloCookieStorage {
+    static create(request) {
+        return new this(
+            request,
+            request.headers.get('Cookie', true).map((c) => [c.name, c])
+        );
+    }
+
+    commit(response) {
+        for (const cookieStr of this.render()) {
+            response.headers.append('Set-Cookie', cookieStr);
+        }
+        super.commit();
+    }
+}

package/src/runtime-pi/server/Router.js

@@ -1,20 +1,9 @@
-
-/**
- * @imports
- */
 import Fs from 'fs';
 import Url from 'url';
 import Path from 'path';
-import Mime from 'mime-types';
-import _Router from '../Router.js';
-
-/**
- * ---------------------------
- * The Router class
- * ---------------------------
- */
+import { WebfloRouter } from '../WebfloRouter.js';
 			
-export default class Router extends _Router {
+export class Router extends WebfloRouter {
 
     async readTick(thisTick) {
         thisTick = { ...thisTick };
@@ -52,61 +41,6 @@ export default class Router extends _Router {
         return Path.join(...args);
     }
 
-    /**
-     * Reads a static file from the public directory.
-     * 
-     * @param ServerNavigationEvent httpEvent
-     * 
-     * @return Promise
-     */
-    file(httpEvent) {
-        let filename = Path.join(this.cx.CWD, this.cx.layout.PUBLIC_DIR, decodeURIComponent(httpEvent.url.pathname));
-        let index, ext = Path.parse(httpEvent.url.pathname).ext;
-        // if is a directory search for index file matching the extention
-        if (!ext && Fs.existsSync(filename) && Fs.lstatSync(filename).isDirectory()) {
-            ext = '.html';
-            index = `index${ext}`;
-            filename = Path.join(filename, index);
-        }
-        let enc, acceptEncs = [], supportedEncs = { gzip: '.gz', br: '.br' };
-        // based on the URL path, extract the file extention. e.g. .js, .doc, ...
-        // and process encoding
-        if ((acceptEncs = (httpEvent.request.headers.get('Accept-Encoding') || '').split(',').map(e => e.trim())).length
-        && (enc = acceptEncs.reduce((prev, _enc) => prev || (Fs.existsSync(filename + supportedEncs[_enc]) && _enc), null))) {
-            filename = filename + supportedEncs[enc];
-        } else {
-            if (!Fs.existsSync(filename)) return;
-            if (Object.values(supportedEncs).includes(ext)) {
-                enc = Object.keys(supportedEncs).reduce((prev, _enc) => prev || (supportedEncs[_enc] === ext && _enc), null);
-                ext = Path.parse(filename.substring(0, filename.length - ext.length)).ext;
-            }
-        }
-
-        // read file from file system
-        return new Promise(resolve => {
-            Fs.readFile(filename, function(err, data) {
-                let response;
-                if (err) {
-                    response = new httpEvent.Response(null, { status: 500, statusText: `Error reading static file: ${filename}` } );
-                } else {
-                    // if the file is found, set Content-type and send data
-                    let mime = Mime.lookup(ext);
-                    response = new httpEvent.Response(data, { headers: {
-                        contentType: mime === 'application/javascript' ? 'text/javascript' : mime,
-                        contentLength: Buffer.byteLength(data),
-                    } });
-                    if (enc) {
-                        response.headers.set('Content-Encoding', enc);
-                    }
-                }
-                response.attrs.filename = filename;
-                response.attrs.static = true;
-                response.attrs.index = index;
-                resolve(response);
-            });
-        });
-    }
-
     /**
      * Writes a file to the public directory.
      * 

package/src/runtime-pi/server/SessionStorage.js

@@ -0,0 +1,53 @@
+import { WebfloStorage } from '../WebfloStorage.js';
+import crypto from 'crypto';
+
+const sessionStorage = new Map;
+export class SessionStorage extends WebfloStorage {
+
+    static create(request, params = {}) {
+        let sessionID = request.headers.get('Cookie', true).find((c) => c.name === '__sessid')?.value;
+        if (sessionID?.includes('.')) {
+            const [rand, signature] = sessionID.split('.');
+            const expectedSignature = crypto.createHmac('sha256', params.secret)
+                .update(rand)
+                .digest('hex');
+            if (signature !== expectedSignature) {
+                sessionID = undefined;
+            }
+        }
+        if (!sessionID) {
+            if (params.secret) {
+                const rand = `${(0 | Math.random() * 9e6).toString(36)}`;
+                const signature = crypto.createHmac('sha256', params.secret)
+                    .update(rand)
+                    .digest('hex');
+                sessionID = `${rand}.${signature}`
+            } else {
+                sessionID = crypto.randomUUID();
+            }
+        }
+        if (sessionStorage.has(sessionID)) {
+            return sessionStorage.get(sessionID);
+        }
+        const instance = new this(request, sessionID);
+        sessionStorage.set(sessionID, instance);
+        return instance;
+    }
+
+    constructor(request, sessionID) {
+        super(request, true);
+        this.#sessionID = sessionID;
+    }
+
+    #sessionID;
+    get sessionID() {
+        return this.#sessionID;
+    }
+
+    commit(response, force = false) {
+        if (response.headers.get('Set-Cookie', true).find((c) => c.name === '__sessid')) return;
+        if (!force && !this.getAdded().length && !this.getDeleted().length) return;
+        response.headers.append('Set-Cookie', `__sessid=${this.#sessionID}; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=31536000`);
+        super.commit();
+    }
+}