@webqit/webflo 0.11.61 → 1.0.1

package/package.json

@@ -12,7 +12,7 @@
     "vanila-javascript"
   ],
   "homepage": "https://webqit.io/tooling/webflo",
-  "version": "0.11.61",
+  "version": "1.0.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/{Context.js → AbstractContext.js}

@@ -1,12 +1,5 @@
+export class AbstractContext {
 
-export default class Context {
-
-    /**
-     * Initializes a context.
-     * 
-     * @param Object  dict 
-     * @param String  CD 
-     */
     constructor(dict, CD = null) {
         // dict can be plain object or some Context instance itself
         // Using it as only a prototype protects it from being mutated down here
@@ -76,5 +69,4 @@ export default class Context {
     set logger(value) {
         Object.defineProperty(this.dict, 'logger', { value } );
     }
-
 }

package/src/deployment-pi/origins/index.js

@@ -198,7 +198,7 @@ export async function webhook(httpEvent, router, next) {
                     }, _isNumeric(deployParams.ondeploy_autoexit) ? parseInt(deployParams.ondeploy_autoexit) : 0);
                 }
                 resolve(
-                    new httpEvent.Response(`Deployment ${  exitCode === 0 ? 'success' : 'error: ' + exitCode }!`, { status: exitCode === 0 ? 200 : 500 })
+                    new Response(`Deployment ${  exitCode === 0 ? 'success' : 'error: ' + exitCode }!`, { status: exitCode === 0 ? 200 : 500 })
                 );
                 if (cx.logger) {
                     cx.logger.log('');

package/src/index.js

@@ -1,20 +1,12 @@
-
-/**
- * @imports
- */
 import * as config from './config-pi/index.js';
 import * as deployment from './deployment-pi/index.js';
 import * as runtime from './runtime-pi/index.js';
 import * as services from './services-pi/index.js';
-import Context from './Context.js';
 
-/**
- * @exports
- */
+export { AbstractContext as Context } from './AbstractContext.js';
 export {
     config,
     deployment,
     runtime,
     services,
-    Context,
 }

package/src/runtime-pi/HttpEvent.js

@@ -1,107 +1,127 @@
-
-/**
- * @imports
- */
-import { _isEmpty } from '@webqit/util/js/index.js';
-import xRequest from "./xRequest.js";
-import xResponse from "./xResponse.js";
+import { _isEmpty, _isObject } from '@webqit/util/js/index.js';
 import xURL from "./xURL.js";
 
-/**
- * The xHttpEvent Mixin
- */
-export default class HttpEvent {
-
-    /**
-     * Initializes a new HttpEvent instance.
-     * 
-     * @param Request       _request 
-     * @param Object        _detail
-     * @param Function      _sessionFactory
-     * @param Function      _storageFactory
-     */
-    constructor(_request, _detail, _sessionFactory, _storageFactory) {
-        this._request = _request;
-        this._detail = _detail || {};
-        this._sessionFactory = _sessionFactory;
-        this._storageFactory = _storageFactory;
-        // -------
-        this.Request = xRequest;
-        this.Response = xResponse;
-        this.URL = xURL;
-        // -------
-        this.port = {
-            listeners: [],
-            post(message) { 
-                const promises = this.listeners.map(listener => listener(message))
-                    .filter(returnValue => returnValue instanceof Promise);
-                if (process.length) return Promise.all(promises);
-            },
-            listen(listener) { this.listeners.push(listener); },
-        }
+export class HttpEvent {
+
+    static create(parentEvent, init = {}) {
+        return new this(parentEvent, init);
     }
 
-    // url
-    get url() {
-        if (!this._url) {
-            this._url = new this.URL(this._request.url);
-        }
-        return this._url;
+    #parentEvent;
+    #init;
+    #url;
+    #requestCloneCallback;
+
+    constructor(parentEvent, init = {}) {
+        this.#parentEvent = parentEvent;
+        this.#init = init;
+        this.#url = new xURL(init.url || init.request.url);
     }
 
-    // request
-    get request() {
-        return this._request;
+    get url() { return this.#url; }
+
+    get request() { return this.#init.request; }
+
+    get detail() { return this.#init.detail; }
+
+    get cookies() { return this.#init.cookies; }
+
+    get session() { return this.#init.session; }
+
+    get user() { return this.#init.user; }
+
+    get client() { return this.#init.client; }
+
+    set onRequestClone(callback) {
+        this.#requestCloneCallback = callback;
     }
 
-    // detail
-    get detail() {
-        return this._detail;
+    clone() {
+        const request = this.#requestCloneCallback?.() || this.request;
+        const init = { ...this.#init, request };
+        const instance = this.constructor.create(init);
+        instance.#requestCloneCallback = this.#requestCloneCallback;
+        return instance;
     }
 
-    // Session
-    get session() {
-        if (!this._session) {
-            this._session = this.sessionFactory();
+    #response = null;
+    get response() { return this.#response; }
+
+    #responseOrigin = null;
+
+    async #respondWith(response) {
+        /*
+        if (this.#response) {
+            throw new Error(`Event has already been responded to! (${this.#responseOrigin})`);
+        }
+        */
+        this.#response = response;
+        /*
+        if (!this.#responseOrigin) {
+            const stack = new Error().stack;
+            const stackLines = stack.split('\n');
+            this.#responseOrigin = stackLines[3].trim();
+        }
+        */
+        if (this.#parentEvent instanceof HttpEvent) {
+            /*
+            // Set responseOrigin first to prevent parent from repeating the work
+            this.#parentEvent.#responseOrigin = this.#responseOrigin;
+            */
+            // Ensure the respondWith() method is how we propagate response
+            await this.#parentEvent.respondWith(this.#response);
+        } else {
+            // The callback passed at root
+            await this.#parentEvent?.(response);
         }
-        return this._session;
     }
 
-    // Storage
-    get storage() {
-        if (!this._storage) {
-            this._storage = this.storageFactory();
-        }
-        return this._storage;
+    async respondWith(response) {
+        await this.#respondWith(response);
     }
 
-    // Session factory
-    sessionFactory(...args) {
-        return this._sessionFactory(...args);
+    async defer() {
+        await this.#respondWith(new Response(null, { status: 202/*Accepted*/ }));
     }
-    
-    // storage factory
-    storageFactory(...args) {
-        return this._storageFactory(...args);
+
+    deferred() {
+        return this.#response?.status === 202;
     }
 
-    // Redirect Response
-    redirect(url, code = 302) {
-        return new this.Response(null, { status: code, headers: { Location: url } });
+    async redirect(url, status = 302) {
+        await this.#respondWith(new Response(null, { status, headers: {
+            Location: url
+        } }));
+    }
+
+    async redirectWith(url, data, ...args) {
+        if (!_isObject(data)) {
+            throw new Error('Data must be a JSON object');
+        }
+        const messageID = (0 | Math.random() * 9e6).toString(36);
+        const $url = new URL(url, this.request.url);
+        $url.searchParams.set('redirect-message', messageID);
+        this.session.set(`redirect-message:${messageID}`, data);
+        await this.redirect($url, ...args);
+    }
+
+    redirected() {
+        return [301, 302, 303, 307, 308].includes(this.#response?.status);
     }
 
-    // "with()"
     async with(url, init = {}) {
-        let request;
+        if (!this.request) {
+            return new HttpEvent(this, { ...this.#init, url  });
+        }
+        let request, _;
         if (url instanceof Request) {
-            if (init instanceof Request) { [ /*url*/, init ] = await xRequest.rip(init); }
-            request = !_isEmpty(init) ? new xRequest(url, init) : url;
+            if (init instanceof Request) { ({ url: _, ...init } = await Request.copy(init)); }
+            request = !_isEmpty(init) ? new Request(url, init) : url;
         } else {
-            url = new this.URL(url, this.url.origin);
-            [ /*url*/, init ] = await xRequest.rip(this._request);
-            request = new xRequest(url, { ...init, referrer: this.request.url });
+            url = new xURL(url, this.#url.origin);
+            init = await Request.copy(this.request, init);
+            request = new Request(url, { ...init, referrer: this.request.url });
         }            
-        return new HttpEvent(request, this.detail, this._sessionFactory, this.storageFactory);
+        return new HttpEvent(this, { ...this.#init, request  });
     }
-
 }

package/src/runtime-pi/HttpUser.js

@@ -0,0 +1,126 @@
+import { _isObject } from '@webqit/util/js/index.js';
+import { WebfloStorage } from './WebfloStorage.js';
+
+export class HttpUser extends WebfloStorage {
+    
+    static create(request, session, client) {
+        return new this(request, session, client);
+    }
+
+    #session;
+    #client;
+
+    constructor(request, session, client) {
+        super(request, session);
+        this.#session = session;
+        this.#client = client;
+        // Trigger this
+        this.#dict;
+    }
+
+    get #dict() {
+        if (!this.#session.has('user')) {
+            this.#session.set('user', {});
+        }
+        return this.#session.get('user');
+    }
+
+    [ Symbol.iterator ]() { return this.entries()[ Symbol.iterator ](); }
+
+    get size() { return Object.keys(this.#dict).length; }
+
+    set(key, value) {
+        Reflect.set(this.#dict, key, value);
+        return this;
+    }
+
+    get(key) {
+        return Reflect.get(this.#dict, key);
+    }
+
+    has(key) {
+        return Reflect.has(this.#dict, key);
+    }
+
+    delete(key) {
+        return Reflect.deleteProperty(this.#dict, key);
+    }
+
+    keys() {
+        return Object.keys(this.#dict);
+    }
+
+    values() {
+        return Object.values(this.#dict);
+    }
+
+    entries() {
+        return Object.entries(this.#dict);
+    }
+
+    clear() {
+        for (const key of this.keys()) {
+            Reflect.deleteProperty(this.#dict, key);
+        }
+    }
+
+    forEach(callback) {
+        this.entries().forEach(callback);
+    }
+
+    json(arg = null) {
+        if (!arguments.length || typeof arg === 'boolean') {
+            return {...this.#dict};
+        }
+        if (!_isObject(arg)) {
+            throw new Error(`Argument must be a valid JSON object`);
+        }
+        Object.assign(this.#dict, arg);
+    }
+
+    isSignedIn() {
+        return this.has('id');
+    }
+
+    async signIn(...args) {
+        return await this.require(
+            ['id'].concat(typeof args[0] === 'string' || Array.isArray(args[0]) ? args.unshift() : []),
+            ...args
+        );
+    }
+
+    async signOut() {
+        const handler = this.getReverseHandlers().get('id')?.[0];
+        let response;
+        if (typeof handler === 'string') {
+            response = new Response(null, { status: 302, headers: {
+                Location: url
+            }});
+        }
+        if (typeof handler === 'function') {
+            response = await handler(this);
+        }
+        this.clear();
+        return response;
+    }
+
+    confirm(data, callback, options = {}) {
+        return new Promise((resolve) => {
+            this.#client.postRequest(
+                data,
+                (event) => resolve(callback ? callback(event) : event),
+                { ...options, messageType: 'confirm' }
+            );
+        });
+    }
+
+    prompt(data, callback, options = {}) {
+        return new Promise((resolve) => {
+            this.#client.postRequest(
+                data,
+                (event) => resolve(callback ? callback(event) : event),
+                { ...options, messageType: 'prompt' }
+            );
+        });
+    }
+}

package/src/runtime-pi/MessagingOverBroadcast.js

@@ -0,0 +1,9 @@
+import { MessagingOverChannel } from './MessagingOverChannel.js';
+
+export class MessagingOverBroadcast extends MessagingOverChannel {
+
+    constructor(parentNode, instanceOrChannelName, params = {}) {
+        const port = typeof instanceOrChannelName === 'string' ? new BroadcastChannel(instanceOrChannelName) : instanceOrChannelName;
+        super(parentNode, port, params);
+    }
+}

package/src/runtime-pi/MessagingOverChannel.js

@@ -0,0 +1,85 @@
+import { _isObject } from '@webqit/util/js/index.js';
+import { WebfloMessagingAPI } from './WebfloMessagingAPI.js';
+import { WebfloMessageEvent } from './WebfloMessageEvent.js';
+
+export class MessagingOverChannel extends WebfloMessagingAPI {
+
+    #port;
+    get port() { return this.#port; }
+
+    #isPrimary;
+    get isPrimary() { return this.#isPrimary; }
+
+    constructor(parentNode, port, { isPrimary = false, ...params } = {}) {
+        super(parentNode, params);
+        this.#port = port;
+        this.#isPrimary = isPrimary;
+        this.#port.start?.();
+        const messageHandler = async (event) => {
+            if (this.isPrimary && event.data === 'connection') {
+                this.$emit('connected');
+            }
+            if (event.data === 'close') {
+                // Endpoint 2 is closed
+                this.#port.removeEventListener('message', messageHandler);
+                this.dispatchEvent(new Event('close'));
+                this.$destroy();
+            }
+            if (!_isObject(event.data) || !['messageType', 'message'].every((k) => k in event.data)) {
+                return;
+            }
+            this.dispatchEvent(new ChannelMessageEvent(
+                this,
+                event.data.messageType,
+                event.data.message,
+                event.ports
+            ));
+        };
+        this.#port.addEventListener('message', messageHandler);
+        const nativeCloseMethod = this.#port.close;
+        Object.defineProperty(this.#port, 'close', { value: () => {
+            // This endpoint is closed
+            this.#port.removeEventListener('message', messageHandler);
+            this.dispatchEvent(new Event('close'));
+            this.$destroy();
+            // Then post to the other end
+            this.#port.postMessage('close');
+            // Then restore nativeCloseMethod and execute normally
+            Object.defineProperty(this.#port, 'close', { value: nativeCloseMethod, configurable: true });
+            this.#port.close();
+        }, configurable: true });
+        if (!this.isPrimary) {
+            // We are client
+            this.$emit('connected');
+            this.#port.postMessage('connection');
+        }
+    }
+
+    postMessage(message, transferOrOptions = []) {
+        this.on('connected', () => {
+            if (Array.isArray(transferOrOptions)) {
+                transferOrOptions = { transfer: transferOrOptions };
+            }
+            const { messageType = 'message', ...options } = transferOrOptions;
+            return this.#port.postMessage({
+                messageType,
+                message
+            }, options);
+        });
+        super.postMessage(message, transferOrOptions);
+    }
+
+    fire(messageType, message) {
+        this.dispatchEvent(new ChannelMessageEvent(
+            this,
+            messageType,
+            message
+        ));
+    }
+    
+    close() {
+        return this.#port.close();
+    }
+}
+
+export class ChannelMessageEvent extends WebfloMessageEvent {}

package/src/runtime-pi/MessagingOverSocket.js

@@ -0,0 +1,106 @@
+import { WebfloMessageEvent } from './WebfloMessageEvent.js';
+import { WebfloMessagingAPI } from './WebfloMessagingAPI.js';
+
+export class MessagingOverSocket extends WebfloMessagingAPI {
+
+    #socket;
+    get socket() { return this.#socket; }
+
+    constructor(parentNode, instanceOrConnectionID, params = {}) {
+        super(parentNode, params);
+        this.#socket = typeof instanceOrConnectionID === 'string' ? new WebSocket(`/${instanceOrConnectionID}`) : instanceOrConnectionID;
+        const messageHandler = async (event) => {
+            let json;
+            try {
+                if (!(json = JSON.parse(event.data)) 
+                || !['messageType', 'message', 'messageID'].every((k) => k in json)) {
+                    return;
+                }
+            } catch(e) {
+                // throw a better error
+            }
+            this.dispatchEvent(new SocketMessageEvent(
+                this,
+                json.messageType,
+                json.message,
+                json.messageID,
+                json.numPorts
+            ));
+        };
+        const openHandler = (e) => {
+            this.$emit('connected');
+            this.dispatchEvent(new Event('open'));
+        };
+        const errorHandler = (e) => {
+            this.dispatchEvent(new Event('error'));
+        };
+        const closeHandler = (e) => {
+            this.#socket.removeEventListener('message', messageHandler);
+            this.#socket.removeEventListener('open', openHandler);
+            this.#socket.removeEventListener('error', errorHandler);
+            this.#socket.removeEventListener('close', closeHandler);
+            this.dispatchEvent(new Event('close'));
+            this.$destroy();
+        };
+        this.#socket.addEventListener('message', messageHandler);
+        this.#socket.addEventListener('open', openHandler);
+        this.#socket.addEventListener('error', errorHandler);
+        this.#socket.addEventListener('close', closeHandler);
+        if (this.#socket.readyState === this.#socket.constructor.OPEN) {
+            this.$emit('connected');
+        }
+    }
+
+    postMessage(message, transferOrOptions = []) {
+        this.on('connected', () => {
+            if (Array.isArray(transferOrOptions)) {
+                transferOrOptions = { transfer: transferOrOptions };
+            }
+            const { transfer = [], messageType = 'message', ...options } = transferOrOptions;
+            const messagePorts = transfer.filter((t) => t instanceof MessagePort);
+            const messageID = (0 | Math.random() * 9e6).toString(36);
+            this.#socket.send(JSON.stringify({
+                messageType,
+                message,
+                messageID,
+                numPorts: messagePorts.length
+            }), options);
+            for (let i = 0; i < messagePorts.length; i ++) {
+                this.addEventListener(`${messageType}:${messageID}:${i}`, (event) => {
+                    messagePorts[i].postMessage(event.data, event.ports);
+                });
+            }
+        });
+        super.postMessage(message, transferOrOptions);
+    }
+
+    fire(messageType, message) {
+        this.dispatchEvent(new SocketMessageEvent(
+            this,
+            messageType,
+            message
+        ));
+    }
+
+    close(...args) {
+        return this.#socket.close(...args);
+    }
+}
+
+export class SocketMessageEvent extends WebfloMessageEvent {
+    constructor(originalTarget, messageType, message, messageID = null, numPorts = 0) {
+        const ports = [];
+        for (let i = 0; i < numPorts; i ++) {
+            const channel = new MessageChannel;
+            channel.port1.addEventListener('message', (event) => {
+                this.originalTarget.postMessage(event.data, {
+                    messageType: `${messageType}:${messageID}:${i}`,
+                    transfer: event.ports
+                });
+            });
+            channel.port1.start();
+            ports.push(channel.port2);
+        }
+        super(originalTarget, messageType, message, ports);
+    }
+}

package/src/runtime-pi/MultiportMessagingAPI.js

@@ -0,0 +1,81 @@
+import { WebfloMessagingAPI } from './WebfloMessagingAPI.js';
+
+export class MultiportMessagingAPI extends WebfloMessagingAPI {
+
+    get runtime() { return this.params.runtime || this.parentNode; }
+
+    #ports = new Set;
+    get ports() { return this.#ports; }
+
+    [ Symbol.iterator ]() { return this.#ports[ Symbol.iterator ](); }
+
+    add(port) {
+        if (!(port instanceof WebfloMessagingAPI)) {
+            throw new TypeError('Argument must be a Webflo messaging interface');
+        }
+        port.setParent(this);
+        this.#ports.add(port);
+        this.$emit('add', port);
+        if (!this.isConnected()) {
+            this.$emit('connected');
+        }
+        port.addEventListener('close', () => {
+            this.remove(port);
+        })
+    }
+
+    remove(port) {
+        if (port.parentNode === this) {
+            port.setParent(null);
+        }
+        this.#ports.delete(port);
+        this.$emit('remove', port);
+        if (!this.#isReplaceAction && this.#ports.size === 0) {
+            this.$emit('empty');
+        }
+    }
+
+    #isReplaceAction;
+    replace(port) {
+        this.#isReplaceAction = true;
+        for (const port of this.#ports) {
+            this.remove(port);
+        }
+        this.#isReplaceAction = false;
+        this.add(port);
+    }
+
+    get(index, callback = null) {
+        const _leadMax = this.#ports.size - 1;
+        if (index > _leadMax && callback) {
+            return this.on('add', () => this.get(index, callback), { once: true });
+        }
+        const port = [...this.#ports][index];
+        if (callback) {
+            callback(port);
+        } else return port;
+    }
+
+    /* ----------------- */
+
+    postMessage(message, transferOrOptions = []) {
+        this.on('connected', () => {
+            for (const port of this.#ports) {
+                port.postMessage(message, transferOrOptions);
+            }
+        });
+        super.postMessage(message, transferOrOptions);
+    }
+
+    close(...args) {
+        for (const port of this.#ports) {
+            port.close?.(...args);
+        }
+    }
+
+    /* ----------------- */
+
+    createBroadcastChannel(name) {
+        return new BroadcastChannel(name);
+    }
+}