@webqit/webflo 0.20.26 → 0.20.28

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;
+    }
+}

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

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

package/src/runtime-pi/webflo-routing/{HttpThread.js → HttpThread111.js}

@@ -1,43 +1,82 @@
-export class HttpThread {
+import { KV } from '@webqit/keyval/inmemory';
 
-    static create({ store, threadID, realm }) {
+export class HttpThread111 {
+
+    // ------ factory
+
+    static create({ context = {}, store, threadID, realm = 0 }) {
+        let hydrationMode = true;
         if (!threadID || !(new RegExp(`^wq\\.${realm}\\.`)).test(threadID)) {
-            threadID = `wq.${realm}.${crypto.randomUUID()}`;
+            threadID = `wq.${realm}.${(0 | Math.random() * 9e6).toString(36)}`;//`wq.${realm}.${crypto.randomUUID()}`;
+            hydrationMode = false;
         }
-        return new this({ store, threadID, realm });
+        return new this({ context, store, threadID, realm, lifecycle: { dirty: hydrationMode, extended: false } });
     }
 
+    // ------
+
+    #context = {};
     #store;
     #threadID;
     #realm;
-    #extended = false;
+    #lifecycle;
 
     get threadID() { return this.#threadID; }
+    get dirty() { return !!this.#lifecycle.dirty; }
+    get extended() { return !!this.#lifecycle.extended; }
 
-    constructor({ store, threadID, realm }) {
-        this.#store = store || new Map;
+    get _context() { return this.#context; }
+    get _parentEvent() { return this.#context?.parentEvent; }
+
+    constructor({ context = {}, store, threadID, realm = 0, lifecycle = { dirty: false, extended: false } }) {
+        if (!(store instanceof KV)) {
+            throw new Error('HttpKeyval expects a valid store instance!');
+        }
+        if (context) Object.assign(this.#context, context);
+        this.#store = store;
         this.#threadID = threadID;
         this.#realm = realm;
+        this.#lifecycle = lifecycle;
     }
 
-    get extended() { return this.#extended; }
+    // ------ lifecycle
+
+    extend(set = true) { this.#lifecycle.extended = !!set; }
 
-    extend(set = true) { this.#extended = !!set; }
+    clone() {
+        return new this.constructor({
+            context: this.#context,
+            store: this.#store,
+            threadID: this.#threadID,
+            realm: this.#realm,
+            lifecycle: this.#lifecycle,
+        });
+    }
 
-    spawn(_threadID = null) {
+    spawn(threadID = null) {
         return this.constructor.create({
+            context: this.#context,
             store: this.#store,
-            threadID: _threadID,
+            threadID: threadID,
             realm: this.#realm
         });
     }
 
+    async _cleanup() {
+        if (this.#lifecycle.extended) return;
+        await this.clear();
+    }
+
+    // ------ standard methods
+
     async keys() {
+        if (!this.#lifecycle.dirty) return [];
         const thread = await this.#store.get(this.#threadID) || {};
         return Object.keys(thread);
     }
 
     async has(key, filter = null) {
+        if (!this.#lifecycle.dirty) return false;
         if (filter === true || !filter) return (await this.keys()).includes(key);
         const thread = await this.#store.get(this.#threadID) || {};
         const values = [].concat(thread[key] ?? []);
@@ -45,14 +84,15 @@ export class HttpThread {
     }
 
     async append(key, value) {
+        this.#lifecycle.dirty = true;
         const thread = await this.#store.get(this.#threadID) || {};
         thread[key] = [].concat(thread[key] ?? []);
         thread[key].push(value);
         await this.#store.set(this.#threadID, thread);
-        return this;
     }
 
     async get(key, filter = null) {
+        if (!this.#lifecycle.dirty) return filter === true ? [] : undefined;
         const thread = await this.#store.get(this.#threadID) || {};
         const values = [].concat(thread[key] ?? []);
 
@@ -67,6 +107,7 @@ export class HttpThread {
     }
 
     async consume(key, filter = null) {
+        if (!this.#lifecycle.dirty) return filter === true ? [] : undefined;
         const thread = await this.#store.get(this.#threadID) || {};
         const values = [].concat(thread[key] ?? []);
 
@@ -94,7 +135,7 @@ export class HttpThread {
     }
 
     async clear() {
+        if (!this.#lifecycle.dirty) return;
         await this.#store.delete(this.#threadID);
-        return this;
     }
 }

package/src/runtime-pi/webflo-routing/{HttpUser.js → HttpUser111.js}

@@ -1,21 +1,8 @@
-import { HttpState } from './HttpState.js';
+import { HttpKeyvalInterface } from './HttpKeyvalInterface.js';
 
-export class HttpUser extends HttpState {
+export class HttpUser111 extends HttpKeyvalInterface {
 
-    static create({ store, request, thread, client }) {
-        return new this({ store, request, thread, client });
-    }
-
-    #client;
-
-    constructor({ store, request, thread, client }) {
-        super({
-            store,
-            request,
-            thread
-        });
-        this.#client = client;
-    }
+    get _client() { return this._parentEvent.client; }
 
     async isSignedIn(callback = null, options = {}) {
         const isSignedIn = await this.get('id');
@@ -23,7 +10,7 @@ export class HttpUser extends HttpState {
             await callback(isSignedIn);
             return options.once
                 ? undefined
-                : this.observe('id', callback, options);
+                : this.subscribe('id', callback, options);
         }
         return !!isSignedIn;
     }
@@ -41,20 +28,20 @@ export class HttpUser extends HttpState {
 
     async confirm(data, callback, options = {}) {
         return await new Promise((resolve) => {
-            this.#client.postRequest(
+            this._client.postRequest(
                 data,
-                (event) => resolve(callback ? callback(event) : event),
-                { ...options, wqEventOptions: { type: 'confirm' } }
+                (event) => resolve(callback ? callback(event.data) : event.data),
+                { ...options, type: 'confirm' }
             );
         });
     }
 
     async prompt(data, callback, options = {}) {
         return await new Promise((resolve) => {
-            this.#client.postRequest(
+            this._client.postRequest(
                 data,
-                (event) => resolve(callback ? callback(event) : event),
-                { ...options, wqEventOptions: { type: 'prompt' } }
+                (event) => resolve(callback ? callback(event.data) : event.data),
+                { ...options, type: 'prompt' }
             );
         });
     }

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

@@ -0,0 +1,53 @@
+import { KeyvalsFactoryInterface } from './KeyvalsFactoryInterface.js';
+import { RedisKV, createClient } from '@webqit/keyval/redis';
+import { InMemoryKV } from '@webqit/keyval/inmemory';
+import { FileKV } from '@webqit/keyval/file';
+
+export class KeyvalsFactory001 extends KeyvalsFactoryInterface {
+
+    #redisNamespace;
+    #redisChannel;
+    #redisUrl;
+    #localDir;
+
+    constructor({ localDir = null, redisUrl = null, redisNamespace = '*', redisChannel = null, } = {}) {
+        super();
+        this.#localDir = localDir;
+        this.#redisUrl = redisUrl;
+        this.#redisNamespace = redisNamespace;
+        this.#redisChannel = redisChannel ?? `__webflo_app__@${this.#redisNamespace}`;
+
+        // Set up Redis watch
+        if (this.#redisUrl && this.#redisChannel) {
+            const watchClient = createClient({ url: this.#redisUrl });
+            watchClient.connect().then(() => {
+                watchClient.subscribe(this.#redisChannel, async (message) => {
+                    try {
+                        const event = JSON.parse(message?.trim());
+                        if (!Array.isArray(event?.origins)
+                            || event.origins[1] === this.instanceID) return;
+                        await this.kvHandle._fire(event);
+                    } catch (e) {
+                        console.error('Failed to parse message JSON:', message);
+                        console.error(e, '\n\n');
+                    }
+                });
+            });
+        }
+    }
+
+    create({ type, ...options }) {
+        const { path, ttl = 0 } = options;
+
+        if (!Array.isArray(path) || path.length !== 2) throw new Error('Path must be an array of length 2');
+        if (options.origins && (!Array.isArray(options.origins) || options.origins.length !== 1)) throw new Error('Origins must be an array of length 1');
+        if (ttl && typeof ttl !== 'number') throw new Error('TTL must be a number');
+
+        const origins = (options.origins || this.defaultOrigins).concat(this.instanceID);
+
+        if (type === 'redis' || !type && this.#redisUrl) return RedisKV.create({ path, ttl, redisUrl: this.#redisUrl, channel: this.#redisChannel, namespace: this.#redisNamespace, registry: this.registry, origins });
+        if (type === 'file' || !type && this.#localDir) return FileKV.create({ path, ttl, dir: this.#localDir, registry: this.registry, origins });
+        if (type === 'inmemory' || !type) return InMemoryKV.create({ path, ttl, registry: this.registry, origins });
+        throw new Error(`Invalid type: ${type}`);
+    }
+}

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

@@ -0,0 +1,48 @@
+import { KeyvalsFactoryInterface } from './KeyvalsFactoryInterface.js';
+import { IndexedDBKV } from '@webqit/keyval/indexeddb';
+import { CookieStoreKV } from '@webqit/keyval/cookiestore';
+import { InMemoryKV } from '@webqit/keyval/inmemory';
+
+export class KeyvalsFactory110 extends KeyvalsFactoryInterface {
+
+    #dbName;
+    #channel;
+    #cookiePath;
+
+    constructor({ dbName = 'webflo_keyval', cookiePath = '/', channel = '__webflo_app__' } = {}) {
+        super();
+        this.#dbName = dbName;
+        this.#cookiePath = cookiePath;
+        this.#channel = channel;
+
+        // Set up Redis watch
+        if (this.#channel) {
+            const watchClient = new BroadcastChannel(this.#channel);
+            watchClient.onmessage = async (message) => {
+                try {
+                    const event = message.data;
+                    if (!Array.isArray(event?.origins)
+                        || event.origins[1] === this.instanceID) return;
+                    await this.kvHandle._fire(event);
+                } catch (e) {
+                    console.error('Failed to parse message JSON:', message);
+                }
+            };
+        }
+    }
+
+    create({ type = 'indexeddb', ...options }) {
+        const { path, ttl = 0 } = options;
+
+        if (!Array.isArray(path) || path.length !== 2) throw new Error('Path must be an array of length 2');
+        if (options.origins && (!Array.isArray(options.origins) || options.origins.length !== 1)) throw new Error('Origins must be an array of length 1');
+        if (ttl && typeof ttl !== 'number') throw new Error('TTL must be a number');
+
+        const origins = (options.origins || this.defaultOrigins).concat(this.instanceID);
+
+        if (type === 'indexeddb') return IndexedDBKV.create({ dbName: this.#dbName, path, ttl, channel: this.#channel, registry: this.registry, origins });
+        if (type === 'cookiestore') return CookieStoreKV.create({ path, ttl, cookiePath: this.#cookiePath, registry: this.registry, origins });
+        if (type === 'inmemory') return InMemoryKV.create({ path, ttl, registry: this.registry, origins });
+        throw new Error(`Invalid type: ${type}`);
+    }
+}

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

@@ -0,0 +1,56 @@
+import { KV } from '@webqit/keyval/inmemory';
+
+export class KeyvalsFactoryInterface {
+
+    #instanceID = (0 | Math.random() * 9e6).toString(36);
+    #registry = new Map;
+    #defaultOrigins = ['*'/* requestID */];
+    #kvHandle;
+
+    get instanceID() { return this.#instanceID; }
+    get registry() { return this.#registry; }
+    get defaultOrigins() { return this.#defaultOrigins; }
+    get kvHandle() { return this.#kvHandle; }
+
+    constructor() {
+        this.#kvHandle = KV.create({ path: [], registry: this.#registry, origins: this.#defaultOrigins.concat(this.#instanceID) });
+    }
+
+    subscribe(kvKey, callback, { scope = 1, ...options } = {}) {
+        if (!kvKey) throw new Error('kvKey must be specified');
+        return this.#kvHandle.subscribe(kvKey, callback, { scope, ...options });
+    }
+
+    #handlers = new Map;
+
+    defineHandler(kvKey, key, ...handlers) {
+        const $handlers = [];
+        for (let handler of handlers) {
+            if (typeof handler === 'function') {
+                handler = { callback: handler };
+            } else if (typeof handler === 'string') {
+                handler = { url: handler };
+            } else if (!(typeof handler === 'object' && handler && (handler = { ...handler }))
+                || typeof handler.callback !== 'function' && typeof handler.url !== 'string') {
+                throw new Error(`Handler must be either an URL or a function or an object specifying either an URL (handler.url) or a function (handler.callback)`);
+            }
+            if (typeof handler.with === 'object' && handler.with) {
+                handler.with = { ...handler.with };
+            } else if (handler.with) {
+                throw new Error(`The "with" parameter must be a valid JSON object`);
+            }
+            $handlers.push(handler);
+        }
+        if (!this.#handlers.has(kvKey)) {
+            this.#handlers.set(kvKey, new Map);
+        }
+        this.#handlers.get(kvKey).set(key, $handlers);
+    }
+
+    getHandlers(kvKey, autoCreate = false) {
+        if (!this.#handlers.has(kvKey) && autoCreate) {
+            this.#handlers.set(kvKey, new Map);
+        }
+        return this.#handlers.get(kvKey);
+    }
+}

package/src/runtime-pi/webflo-routing/{WebfloRouter.js → WebfloRouter111.js}

@@ -1,10 +1,9 @@
 import { _isFunction, _isArray, _isObject } from '@webqit/util/js/index.js';
 import { _from as _arrFrom } from '@webqit/util/arr/index.js';
-import { LiveResponse } from '../webflo-fetch/LiveResponse.js';
-import { request as requestShim } from '../webflo-fetch/index.js';
-import { path as Path } from '../webflo-url/util.js';
+import { LiveResponse, RequestPlus } from '@webqit/fetch-plus';
+import { Path } from '@webqit/url-plus';
 
-export class WebfloRouter {
+export class WebfloRouter111 {
 
     #runtime;
     #path;
@@ -103,7 +102,7 @@ export class WebfloRouter {
                         // Build request inheritance chain
                         const requestInheritanceChain = [url];
                         if (!isFetch && thisTick.event.request instanceof Request) {
-                            const { url: _, ...init } = await requestShim.copy.value(thisTick.event.request);
+                            const { url: _, ...init } = await RequestPlus.copy(thisTick.event.request);
                             requestInheritanceChain.push(init);
                         }
                         const noArg2 = () => {
@@ -111,7 +110,7 @@ export class WebfloRouter {
                         };
                         if (args[0] instanceof Request) {
                             if (args[1]) noArg2();
-                            const { url: _, ...init } = await requestShim.copy.value(args[0]);
+                            const { url: _, ...init } = await RequestPlus.copy(args[0]);
                             requestInheritanceChain.push(init);
                         } else if (!isFetch && _isObject(args[0])) {
                             if (args[1]) noArg2();