@webqit/webflo 0.20.25 → 0.20.27

package/src/runtime-pi/webflo-client/WebfloSubClient.js

@@ -1,8 +1,8 @@
-import { Observer } from '@webqit/use-live';
+import { Observer } from '@webqit/observer';
+import { LiveResponse } from '@webqit/fetch-plus';
 import { WebfloClient } from './WebfloClient.js';
 import { defineElement } from './webflo-embedded.js';
-import { Url } from '../webflo-url/Url.js';
-import { _wq } from '../../util.js';
+import { _meta } from '../../util.js';
 
 export class WebfloSubClient extends WebfloClient {
 
@@ -40,21 +40,26 @@ export class WebfloSubClient extends WebfloClient {
 		if (this.host.location.origin !== window.location.origin) {
 			throw new Error(`Webflo embeddable origin violation in "${window.location}"`);
 		}
+
 		const instanceController = await super.initialize();
-		_wq(this.background, 'meta').set('parentNode', this.#superRuntime.background);
+
+		_meta(this.background).set('parentNode', this.#superRuntime.background);
 		instanceController.signal.addEventListener('abort', () => {
-			if (_wq(this.background, 'meta').get('parentNode') === this.#superRuntime.background) {
-				_wq(this.background, 'meta').set('parentNode', null);
+			if (_meta(this.background).get('parentNode') === this.#superRuntime.background) {
+				_meta(this.background).set('parentNode', null);
 			}
 		}, { once: true });
+
 		return instanceController;
 	}
 
 	async hydrate() {
 		const instanceController = await super.hydrate();
+
 		if (this.host.hasAttribute('location')) {
 			await this.navigate(this.location.href);
 		}
+
 		return instanceController;
 	}
 
@@ -62,6 +67,7 @@ export class WebfloSubClient extends WebfloClient {
 		const locationCallback = (newHref) => {
 			this.host.reflectLocation(newHref);
 		};
+		
 		return super.controlClassic/*IMPORTANT*/(locationCallback);
 	}
 
@@ -87,36 +93,43 @@ export class WebfloSubClient extends WebfloClient {
 		if (httpEvent.url.hash) {
 			this.host.querySelector(httpEvent.url.hash)?.scrollIntoView();
 		} else await super.applyPostRenderState(httpEvent);
+
 		(this.host.querySelector('[autofocus]') || this.host).focus();
 	}
 
-	redirect(location, response = null) {
+	async redirect(location, response = null) {
 		location = typeof location === 'string' ? new URL(location, this.location.origin) : location;
+		
 		const width = Math.min(800, window.innerWidth);
 		const height = Math.min(600, window.innerHeight);
 		const left = (window.outerWidth - width) / 2;
 		const top = (window.outerHeight - height) / 2;
 		const popup = window.open(location, '_blank', `popup=true,width=${width},height=${height},left=${left},top=${top}`);
-		if (response && LiveResponse.hasBackground(response)) {
-			Observer.set(this.navigator, 'redirecting', new Url/*NOT URL*/(location), { diff: true });
-			const backgroundPort = LiveResponse.getBackground(response);
-			backgroundPort.postMessage(true, { wqEventOptions: { type: 'keep-alive' } });
- 			backgroundPort.addEventListener('close', (e) => {
+		
+		const backgroundPort = response instanceof LiveResponse 
+			? response.port
+			: LiveResponse.getPort(response);
+		if (backgroundPort) {
+			Observer.set(this.navigator, 'redirecting', new URL(location), { diff: true });
+			
+ 			backgroundPort.readyStateChange('close').then((e) => {
 				window.removeEventListener('message', windowMessageHandler);
+
 				Observer.set(this.navigator, 'redirecting', null);
 				popup.postMessage('timeout:5');
+
 				setTimeout(() => {
 					popup.close();
 				}, 5000);
-			}, { once: true });
+			});
+			
 			const windowMessageHandler = (e) => {
 				if (e.source === popup && e.data === 'close') {
 					backgroundPort.close();
 				}
 			};
+
 			window.addEventListener('message', windowMessageHandler);
 		}
-		
-		return 3; // keep-alive
 	}
 }

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

@@ -1,9 +1,9 @@
-import { WebfloRootClient1 } from './WebfloRootClient1.js';
-import { WebfloRootClient2 } from './WebfloRootClient2.js';
+import { WebfloRootClientA } from './WebfloRootClientA.js';
+import { WebfloRootClientB } from './WebfloRootClientB.js';
 import { WebfloSubClient } from './WebfloSubClient.js';
 
 export async function start(bootstrap) {
-    const WebfloRootClient = window.navigation ? WebfloRootClient2 : WebfloRootClient1;
+    const WebfloRootClient = window.navigation ? WebfloRootClientB : WebfloRootClientA;
     const instance = WebfloRootClient.create(bootstrap, document);
     await instance.initialize();
     WebfloSubClient.defineElement();

package/src/runtime-pi/webflo-messaging/ClientPortMixin.js

@@ -0,0 +1,13 @@
+export const ClientPortMixin = (superClass) => class extends superClass {
+
+    async query(query, callback, options = {}) {
+        return await new Promise((resolve) => {
+            this.postRequest(
+                { query },
+                (event) => resolve(callback ? callback(event) : event),
+                { ...options, type: 'query' }
+            );
+        });
+    }
+
+};

package/src/runtime-pi/{webflo-server/messaging/ClientRequestRealtime.js → webflo-messaging/ClientRequestPort001.js}

@@ -1,7 +1,8 @@
-import { WQStarPort } from '../../webflo-messaging/WQStarPort.js';
-import { _wq } from '../../../util.js';
+import { ClientPortMixin } from './ClientPortMixin.js';
+import { StarPort } from '@webqit/port-plus';
+import { _meta } from '../../util.js';
 
-export class ClientRequestRealtime extends WQStarPort {
+export class ClientRequestPort001 extends ClientPortMixin(StarPort) {
 
     #portID;
     get portID() { return this.#portID; }
@@ -15,8 +16,8 @@ export class ClientRequestRealtime extends WQStarPort {
     #navigatedAway = false;
     navigatedAway() { return this.#navigatedAway; }
 
-    constructor(portID, url) {
-        super();
+    constructor(portID, url, options = {}) {
+        super(options);
         this.#portID = portID;
         this.#url = url;
         const $url = new URL(url);
@@ -38,13 +39,16 @@ export class ClientRequestRealtime extends WQStarPort {
     }
 
     enterChannel(channelID, { resolveData = null } = {}) {
-        const client = _wq(this, 'meta').get('parentNode');
-        const clients = client && _wq(client, 'meta').get('parentNode');
+        const webfloTenant = _meta(this).get('parentNode');
+        const clients = webfloTenant && _meta(webfloTenant).get('parentNode');
+
         if (!clients) {
             throw new Error('Instance seem not connected to the messaging system.');
         }
+
         const channel = clients.getChannel(channelID, true);
-        const leave = channel.addPort(client, { resolveData });
+        const leave = channel.addPort(webfloTenant, { resolveData });
+        
         return { channel, leave };
     }
-}
+}

package/src/runtime-pi/webflo-messaging/ClientRequestPort010.js

@@ -0,0 +1,4 @@
+import { ClientPortMixin } from './ClientPortMixin.js';
+import { BroadcastChannelPlus } from '@webqit/port-plus';
+
+export class ClientRequestPort010 extends ClientPortMixin(BroadcastChannelPlus) {}

package/src/runtime-pi/webflo-messaging/ClientRequestPort100.js

@@ -0,0 +1,17 @@
+import { ClientPortMixin } from './ClientPortMixin.js';
+import { MessageChannelPlus } from '@webqit/port-plus';
+
+export class ClientRequestPort100 extends MessageChannelPlus {
+
+    constructor(options = {}) {
+        super(options);
+
+        const superInstance = new (ClientPortMixin(class { }));
+        Object.defineProperty(this.port1, 'query', {
+            value: function (...args) {
+                return superInstance.query.apply(this, args);
+            }
+        });
+
+    }
+}

package/src/runtime-pi/webflo-messaging/WebfloTenancy001.js

@@ -0,0 +1,27 @@
+import { RelayPort, StarPort } from '@webqit/port-plus';
+import { WebfloTenant001 } from './WebfloTenant001.js';
+
+export class WebfloTenancy001 extends StarPort {
+
+    #channels = new Map;
+
+    getTenant(tenantID, autoCreate = false) {
+        if (autoCreate && !this.findPort((tenant) => tenant.tenantID === tenantID)) {
+            const tenant = new WebfloTenant001(tenantID, { handshake: 1, postAwaitsOpen: true, autoClose: false });
+            const cleanup = this.addPort(tenant);
+            tenant.readyStateChange('close').then(cleanup);
+        }
+        return this.findPort((tenant) => tenant.tenantID === tenantID);
+    }
+
+    getChannel(channelName, autoCreate = false) {
+        if (!this.#channels.has(channelName) && autoCreate) {
+            const channel = new RelayPort(channelName, { handshake: 1, postAwaitsOpen: true, autoClose: true });
+
+            this.#channels.set(channelName, channel);
+            channel.readyStateChange('close').then(() => this.#channels.delete(channelName));
+        }
+        
+        return this.#channels.get(channelName);
+    }
+}

package/src/runtime-pi/webflo-messaging/WebfloTenant001.js

@@ -0,0 +1,27 @@
+import { StarPort } from '@webqit/port-plus';
+import { ClientRequestPort001 } from './ClientRequestPort001.js';
+
+export class WebfloTenant001 extends StarPort {
+
+    #tenantID;
+    get tenantID() { return this.#tenantID; }
+
+    constructor(tenantID, options = {}) {
+        super(options);
+        this.#tenantID = tenantID;
+    }
+
+    getRequestPort(portID) {
+        return this.findPort((port) => port.portID === portID);
+    }
+
+    createRequestPort(portID, url = null) {
+        const requestPort = new ClientRequestPort001(portID, url, { handshake: 1, postAwaitsOpen: true, autoClose: true });
+        this.addPort(requestPort);
+        setTimeout(() => {
+            if (requestPort.length || !this.findPort((port) => port === requestPort)) return;
+            requestPort.close(true);
+        }, 15000/*15sec*/);
+        return requestPort;
+    }
+}

package/src/runtime-pi/webflo-routing/HttpCookies101.js

@@ -0,0 +1,53 @@
+import { HttpKeyvalInterface } from './HttpKeyvalInterface.js';
+
+export class HttpCookies101 extends HttpKeyvalInterface {
+
+    #initial;
+
+    constructor({ context = {}, store, initial = {}, realm = 0 }) {
+        super({ context, store, initial, realm });
+        this.#initial = initial;
+    }
+
+    // ------ lifecycle
+
+    async _commit(response, devMode = false) {
+        // Mutate in-place - to reflect across clones
+        Object.keys(this.#initial).forEach((k) => delete this.#initial[k]);
+        Object.assign(this.#initial, await this.json());
+    }
+
+    // ------ extras
+
+    async render() {
+        const json = await this.json(true);
+
+        const entries = Object.keys(json).concat(Object.keys(this.#initial)).map((key) => {
+            const a = this.#initial[key];
+            const b = json[key];
+            if (a === b.value) {
+                // Same
+                return;
+            }
+            if ([undefined, null].includes(b)) {
+                // Deleted
+                return { name: key, value: '', maxAge: 0 };
+            }
+            // Added or modified
+            return { name: key, ...b };
+        }).filter((e) => e);
+
+        return entries.map((e) => renderCookieObjToString(e));
+    }
+}
+
+export function renderCookieObjToString(cookieObj) {
+    const attrsArr = [`${cookieObj.name}=${/*encodeURIComponent*/(cookieObj.value)}`];
+    for (const attrName in cookieObj) {
+        if (['name', 'value'].includes(attrName)) continue;
+        let _attrName = attrName[0].toUpperCase() + attrName.substring(1);
+        if (_attrName === 'MaxAge') { _attrName = 'Max-Age' };
+        attrsArr.push(cookieObj[attrName] === true ? _attrName : `${_attrName}=${cookieObj[attrName]}`);
+    }
+    return attrsArr.join('; ');
+}

package/src/runtime-pi/webflo-routing/HttpCookies110.js

@@ -0,0 +1,3 @@
+import { HttpKeyvalInterface } from './HttpKeyvalInterface.js';
+
+export class HttpCookies110 extends HttpKeyvalInterface {}

package/src/runtime-pi/webflo-routing/{HttpEvent.js → HttpEvent111.js}

@@ -1,106 +1,140 @@
 import { _isObject } from '@webqit/util/js/index.js';
-import { _difference } from '@webqit/util/arr/index.js';
-import { LiveResponse } from '../webflo-fetch/LiveResponse.js';
-import { xURL } from '../webflo-url/xURL.js';
-import { _wq } from '../../util.js';
+import { LiveResponse } from '@webqit/fetch-plus';
+import { URLPlus } from '@webqit/url-plus';
 
-export class HttpEvent {
+export class HttpEvent111 {
 
-    static create(parentEvent, init = {}) {
-        return new this(parentEvent, init);
+    static create(init = {}) {
+        return new this(init);
     }
 
-    #parentEvent;
-    #url;
+    #context = {};
     #init;
-    #abortController = new AbortController;
-
-    constructor(parentEvent, { request, cookies, session, user, client, detail, signal, state, ...rest }) {
-        this.#parentEvent = parentEvent;
-        this.#init = { request, cookies, session, user, client, detail, signal, state, ...rest };
-        this.#url = new xURL(this.#init.request.url);
-        this.#parentEvent?.signal.addEventListener('abort', () => this.#abortController.abort(), { once: true });
-        this.#init.request.signal?.addEventListener('abort', () => this.#abortController.abort(), { once: true });
-        this.#lifeCycleResolutionPromise.finally(() => {
-            this.#abortController.abort();
-        });
-    }
+    #url;
 
-    get signal() { return this.#abortController.signal; }
+    #readyStates;
+    #abortController = new AbortController;
 
-    get url() { return this.#url; }
+    #internalLiveResponse = new LiveResponse(null, { done: false });
+    get internalLiveResponse() { return this.#internalLiveResponse; }
 
-    get request() { return this.#init.request; }
+    get _context() { return this.#context; }
+    get _parentEvent() { return this.#context?.parentEvent; }
 
-    get thread() { return this.#init.thread; }
+    constructor({ context = {}, request, thread, cookies, session, user, client, detail, signal, state, ...rest }) {
+        if (context) Object.assign(this.#context, context);
 
-    get client() { return this.#init.client; }
+        this.#init = { context, request, thread, cookies, session, user, client, detail, signal, state, ...rest };
+        [thread, cookies, session, user].forEach((node) => {
+            if (!node) return;
+            node._context.parentEvent = this;
+        });
 
-    get cookies() { return this.#init.cookies; }
+        this.#url = new URLPlus(this.#init.request.url);
 
-    get session() { return this.#init.session; }
+        this._parentEvent?.signal.addEventListener('abort', () => this.#abortController.abort(), { once: true });
+        this.#init.request.signal?.addEventListener('abort', () => this.#abortController.abort(), { once: true });
 
-    get user() { return this.#init.user; }
+        const $ref = (o) => {
+            o.promise = new Promise((res, rej) => (o.resolve = res, o.reject = rej));
+            return o;
+        };
+        this.#readyStates = {
+            live: $ref({}),
+            done: $ref({}),
+        };
 
-    get detail() { return this.#init.detail; }
+        this.#readyStates.done.promise.finally(() => {
+            this.#abortController.abort();
+        });
+    }
 
-    get state() { return { ...(this.#init.state || {}) }; }
+    // ------ lifecycle
 
     #lifecyclePromises = new Set;
-    get lifecyclePromises() { return this.#lifecyclePromises; }
-
-    #lifeCycleResolve;
-    #lifeCycleReject;
-    #lifeCycleResolutionPromise = new Promise((resolve, reject) => {
-        this.#lifeCycleResolve = resolve;
-        this.#lifeCycleReject = reject;
-    });
-
     #extendLifecycle(promise) {
-        if (this.#lifecyclePromises.dirty && !this.#lifecyclePromises.size) {
+        if (this.#readyStates.done.state) {
             throw new Error('Event lifecycle already complete.');
         }
-        if (this.#parentEvent) {
-            this.#parentEvent.waitUntil(promise);
+
+        if (this._parentEvent) {
+            this._parentEvent.waitUntil(promise);
         }
+
         promise = Promise.resolve(promise);
         this.#lifecyclePromises.add(promise);
-        this.#lifecyclePromises.dirty = true;
+
+        if (!this.#readyStates.live.state) {
+            this.#readyStates.live.state = true;
+            this.#readyStates.live.resolve();
+        }
+
         return promise.then((value) => {
             this.#lifecyclePromises.delete(promise);
             if (!this.#lifecyclePromises.size) {
-                this.#lifeCycleResolve(value);
+                this.#readyStates.done.state = true;
+                this.#readyStates.done.resolve(value);
             }
-        }).catch(() => {
+        }).catch((e) => {
             this.#lifecyclePromises.delete(promise);
             if (!this.#lifecyclePromises.size) {
-                this.#lifeCycleReject();
+                this.#readyStates.done.state = true;
+                this.#readyStates.done.reject(e);
             }
         });
     }
 
-    lifeCycleComplete(returningThePromise = false) {
-        if (returningThePromise) {
-            return this.#lifeCycleResolutionPromise;
-        }
-        if (this.#lifecyclePromises.dirty === undefined) {
-            // Hasn't been initialized yet
-            return null;
+    get readyState() {
+        return this.#readyStates.done.state ? 'done'
+            : (this.#readyStates.live.state ? 'live' : 'waiting');
+    }
+
+    readyStateChange(query) {
+        if (!['live', 'done'].includes(query)) {
+            throw new Error(`Invalid readyState query "${query}"`);
         }
-        return !this.#lifecyclePromises.size;
+        return this.#readyStates[query].promise;
+    }
+
+    spawn(init = {}) {
+        const clone = this.clone(init);
+        clone._context.parentEvent = this;
+        return clone;
     }
 
+    abort() { this.#abortController.abort(); }
+
+    clone(init = {}) {
+        const $init = { ...this.#init, ...init };
+        ['thread', 'cookies', 'session', 'user'].forEach((nodeName) => {
+            if (!init[nodeName]) $init[nodeName] = $init[nodeName].clone();
+        });
+        return this.constructor.create($init);
+    }
+
+    // ------
+
+    get signal() { return this.#abortController.signal; }
+    get url() { return this.#url; }
+    get request() { return this.#init.request; }
+    get thread() { return this.#init.thread; }
+    get cookies() { return this.#init.cookies; }
+    get session() { return this.#init.session; }
+    get user() { return this.#init.user; }
+    get client() { return this.#init.client; }
+    get detail() { return this.#init.detail; }
+    get state() { return { ...(this.#init.state || {}) }; }
+
+    // ------
+
     async waitUntil(promise) {
         return await this.#extendLifecycle(promise);
     }
 
-    waitUntilNavigate() {
-        this.waitUntil(new Promise(() => { }));
+    async waitUntilNavigate() {
+        /* DO NOT AWAIT */this.waitUntil(new Promise(() => { }));
     }
 
-    #internalLiveResponse = new LiveResponse(null, { done: false });
-    get internalLiveResponse() { return this.#internalLiveResponse; }
-
     async respondWith(data, ...args) {
         await this.#internalLiveResponse.replaceWith(data, ...args);
     }
@@ -141,16 +175,4 @@ export class HttpEvent {
         //-----
         return await this.respondWith(null, { status, ...options, headers: { Location: urlRewrite.href } });
     }
-
-    clone(init = {}) {
-        return this.constructor.create(this.#parentEvent, { ...this.#init, ...init });
-    }
-
-    spawn(init = {}) {
-        return this.constructor.create(this/*Main difference from clone*/, { ...this.#init, ...(init || {}) });
-    }
-
-    abort() {
-        this.#abortController.abort();
-    }
-}
+}

package/src/runtime-pi/webflo-routing/HttpKeyvalInterface.js

@@ -0,0 +1,120 @@
+import { LiveResponse } from '@webqit/fetch-plus';
+import { KV } from '@webqit/keyval/inmemory';
+
+export class HttpKeyvalInterface {
+
+    static create(init = {}) {
+        return new this(init);
+    }
+
+    #context = {};
+    #store;
+    #realm;
+    #rest;
+
+    #cleanups = new Set
+
+    get _context() { return this.#context; }
+    get _parentEvent() { return this.#context?.parentEvent; }
+
+    constructor({ context = {}, store, realm = 0, ...rest }) {
+        if (!(store instanceof KV)) {
+            throw new Error('HttpKeyval expects a valid store instance!');
+        }
+        if (context) Object.assign(this.#context, context);
+        this.#store = store;
+        this.#realm = realm;
+        this.#rest = rest;
+    }
+
+    // ------ lifecycle
+
+    clone() {
+        return new this.constructor({
+            context: this.#context,
+            store: this.#store,
+            realm: this.#realm,
+            ...this.#rest,
+        });
+    }
+
+    async _cleanup() { this.#cleanups.forEach((fn) => fn()); }
+
+    // ------ standard methods
+
+    async count() { return await this.#store.count(); }
+    async keys() { return [...await this.#store.keys()]; }
+    async values() { return [...await this.#store.values()]; }
+    async entries() { return [...await this.#store.entries()]; }
+    async has(key) { return await this.#store.has(key); }
+    async get(key) { return await this.#store.get(key); }
+    async set(key, value) { await this.#store.set(key, value); }
+    async delete(key) { await this.#store.delete(key); }
+    async clear() { await this.#store.clear(); }
+    async json(...args) { return await this.#store.json(...args); }
+
+    // ------ extras
+
+    subscribe(...args) {
+        const cleanup = this.#store.subscribe(...args);
+        this.#cleanups.add(cleanup);
+        return cleanup;
+    }
+
+    async require(attrs, callback = null, options = {}) {
+        const handlersRegistry = this.#context?.handlersRegistry;
+        if (!handlersRegistry) throw new Error(`No handlers registry in context`);
+
+        if (typeof callback === 'object' && callback && arguments.length === 2) {
+            options = callback;
+            callback = null;
+        }
+
+        if (callback && typeof callback !== 'function') {
+            throw new Error('Callback must be a valid function when provided');
+        }
+
+        const entries = [];
+        main: for await (const attr of [].concat(attrs)) {
+            const value = await this.get(attr);
+            if (value === undefined && !await this.has(attr)
+                || options.noNulls && [undefined, null].includes(value)) {
+
+                const handlers = handlersRegistry.get(attr);
+                if (!handlers) {
+                    throw new Error(`No handler defined for the user attribute: ${attr}`);
+                }
+
+                for (let i = 0; i < handlers.length; i++) {
+                    const handler = handlers[i];
+
+                    if (handler.callback) {
+                        const returnValue = await handler.callback(this._parentEvent, attr);
+                        if (returnValue instanceof Response || returnValue instanceof LiveResponse) {
+                            await this._parentEvent.respondWith(returnValue);
+                            return new Promise(() => { });
+                        }
+
+                        if ((typeof returnValue === 'undefined' || (options.noNulls && returnValue === null)) && i < handlers.length - 1) {
+                            continue;
+                        }
+
+                        entries.push(returnValue);
+                        continue main;
+                    }
+
+                    await this._parentEvent.redirectWith(handler.url, handler.with || {});
+                    return new Promise(() => { });
+                }
+            }
+
+            entries.push(value);
+        }
+
+        if (callback) {
+            return await callback(...entries);
+        }
+
+        return entries;
+    }
+}

package/src/runtime-pi/webflo-routing/HttpSession001.js

@@ -0,0 +1,24 @@
+import { HttpKeyvalInterface } from './HttpKeyvalInterface.js';
+
+export class HttpSession001 extends HttpKeyvalInterface {
+
+    #sessionID;
+    get sessionID() { return this.#sessionID; }
+    #ttl;
+    
+    constructor({ context = {}, store, request, thread, sessionID, ttl }) {
+        if (!sessionID) {
+            throw new Error(`sessionID is required`);
+        }
+        super({
+            context,
+            store,
+            request,
+            thread,
+            sessionID,
+            ttl
+        });
+        this.#sessionID = sessionID;
+        this.#ttl = ttl;
+    }
+}