@webqit/webflo 0.20.23 → 0.20.25

package/package.json

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

package/src/runtime-pi/WebfloRuntime.js

@@ -156,6 +156,17 @@ export class WebfloRuntime {
         for (const storage of [httpEvent.user, httpEvent.session, httpEvent.cookies]) {
             await storage?.commit?.(response, FLAGS['dev']);
         }
+
+        // End-of-life cleanup
+        const cleanup = async () => {
+            for (const storage of [httpEvent.user, httpEvent.session, httpEvent.cookies]) {
+                storage.cleanup();
+            }
+            if (!httpEvent.thread.extended) {
+                await httpEvent.thread.clear();
+            }
+        };
+
         // Wait for any whileLive promises to resolve
         if (LiveResponse.test(response) === 'LiveResponse' && response.whileLive()) {
             httpEvent.waitUntil(response.whileLive(true));
@@ -194,11 +205,9 @@ export class WebfloRuntime {
             // Close httpEvent.client
             httpEvent.lifeCycleComplete(true).then(async () => {
                 httpEvent.client.close();
-                if (!httpEvent.thread.extended) {
-                    await httpEvent.thread.clear();
-                }
+                cleanup();
             });
-        }
+        } else cleanup();
 
         if (!this.isClientSide && LiveResponse.test(response) === 'LiveResponse') {
             // Must convert to Response on the server-side before returning

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

@@ -69,25 +69,42 @@ export class HttpState {
     }
 
     #listeners = new Set;
-    observe(attr, handler) {
-        const args = { attr, handler };
-        this.#listeners.add(args);
-        return () => {
-            this.#listeners.delete(args);
-        }
-    }
-
     async emit(attr, value) {
         const returnValues = [];
-        for (const { attr: $attr, handler } of this.#listeners) {
+        for (const subscription of this.#listeners) {
+            const { attr: $attr, handler, options } = subscription;
             if (arguments.length && $attr !== attr) continue;
             if (arguments.length > 1) {
                 returnValues.push(handler(value));
             } else {
                 returnValues.push(handler());
             }
+            if (options.once) this.#listeners.delete(subscription);
+        }
+        await Promise.all(returnValues);
+    }
+
+    observe(attr, handler, options = {}) {
+        if (typeof this.#store.observe === 'function') {
+            return this.#store.observe(attr, handler, options);
+        }
+        const subscription = { attr, handler, options };
+        this.#listeners.add(subscription);
+        if (options.signal) {
+            options.signal.addEventListener('abort', () => {
+                this.#listeners.delete(subscription);
+            });
+        }
+        return () => {
+            this.#listeners.delete(subscription);
+        }
+    }
+
+    cleanup() {
+        if (typeof this.#store.cleanup === 'function') {
+            this.#store.cleanup();
         }
-        return Promise.all(returnValues);
+        this.#listeners.clear();
     }
 
     #handlers = new Map;

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

@@ -20,6 +20,10 @@ export class HttpThread {
         this.#realm = realm;
     }
 
+    get extended() { return this.#extended; }
+
+    extend(set = true) { this.#extended = !!set; }
+
     spawn(_threadID = null) {
         return this.constructor.create({
             store: this.#store,
@@ -48,6 +52,20 @@ export class HttpThread {
         return this;
     }
 
+    async get(key, filter = null) {
+        const thread = await this.#store.get(this.#threadID) || {};
+        const values = [].concat(thread[key] ?? []);
+
+        let value;
+        if (filter === true) {
+            value = values;
+        } else if (filter) {
+            value = values.find(filter);
+        } else { value = values[values.length - 1]; }
+
+        return value;
+    }
+
     async consume(key, filter = null) {
         const thread = await this.#store.get(this.#threadID) || {};
         const values = [].concat(thread[key] ?? []);
@@ -79,8 +97,4 @@ export class HttpThread {
         await this.#store.delete(this.#threadID);
         return this;
     }
-
-    get extended() { return this.#extended; }
-
-    extend(set = true) { this.#extended = !!set; }
 }

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

@@ -17,8 +17,15 @@ export class HttpUser extends HttpState {
         this.#client = client;
     }
 
-    async isSignedIn() {
-        return await this.has('id');
+    async isSignedIn(callback = null, options = {}) {
+        const isSignedIn = await this.get('id');
+        if (callback) {
+            await callback(isSignedIn);
+            return options.once
+                ? undefined
+                : this.observe('id', callback, options);
+        }
+        return !!isSignedIn;
     }
 
     async signIn(...args) {

package/src/runtime-pi/webflo-server/WebfloServer.js

@@ -152,28 +152,165 @@ export class WebfloServer extends WebfloRuntime {
             || !this.bootstrap.init.redis) {
             return super.initCreateStorage();
         }
+
+        // ns -> field -> { value, subscriptions: Set<fn> }
+        const local = new Map();
+        const fire = (state, value, key, namespace, scopeReference = false) => {
+            const returnValues = [];
+            for (const subscription of state.subscriptions) {
+                const { callback, options } = subscription;
+                
+                const scope = subscription.scopeReference === scopeReference ? 0 : scopeReference ? 1 : 2;
+                // For options.scope === 0, only include same-request cycle mutations
+                // For options.scope === 1, only include local mutations
+                // For options.scope === 2, include remote mutations
+                if ((options.scope || 0) !== scope) continue;
+                
+                returnValues.push(callback(value, scope));
+                if (options.once) state.subscriptions.delete(subscription);
+                const ns = local.get(namespace);
+                if (!state.subscriptions.size) ns.delete(key);
+                if (!ns.size) local.delete(namespace);
+            }
+            return Promise.all(returnValues);
+        };
+
+        // Initialize storage
         const redis = this.bootstrap.init.redis;
-        this.bootstrap.init.createStorage = (namespace, ttl = null) => ({
-            async has(key) { return await redis.hexists(namespace, key); },
-            async get(key) {
-                const value = await redis.hget(namespace, key);
-                return typeof value === 'undefined' ? value : JSON.parse(value);
-            },
-            async set(key, value) {
-                const returnValue = await redis.hset(namespace, key, JSON.stringify(value));
-                if (!this.ttlApplied && ttl) {
-                    await redis.expire(namespace, ttl);
-                    this.ttlApplied = true;
+        this.bootstrap.init.createStorage = (namespace, ttl = null, scopeReference = {}) => {
+            const cleanups = [];
+            return {
+                async has(key) { return await redis.hexists(namespace, key); },
+                async get(key) {
+                    const jsonValue = await redis.hget(namespace, key);
+                    return jsonValue === null ? undefined : JSON.parse(jsonValue);
+                },
+                async set(key, value) {
+                    const jsonValue = JSON.stringify(value);
+                    const returnValue = await redis.hset(namespace, key, jsonValue);
+                    if (!this.ttlApplied && ttl) {
+                        await redis.expire(namespace, ttl);
+                        this.ttlApplied = true;
+                    }
+                    const state = local.get(namespace)?.get(key);
+                    if (state) {
+                        state.jsonValue = jsonValue;
+                        state.initialized = true;
+                        await fire(state, value, key, namespace, scopeReference);
+                    }
+                    return returnValue;
+                },
+                async delete(key) {
+                    const returnValue = await redis.hdel(namespace, key);
+                    const state = local.get(namespace)?.get(key);
+                    if (state) {
+                        state.jsonValue = null;
+                        state.initialized = true;
+                        await fire(state, undefined, key, namespace, scopeReference);
+                    }
+                    return returnValue;
+                },
+                async clear() {
+                    const returnValue = await redis.del(namespace);
+                    const nsLocal = local.get(namespace);
+                    if (nsLocal) {
+                        for (const [key, state] of nsLocal.entries()) {
+                            state.jsonValue = null;
+                            state.initialized = true;
+                            await fire(state, undefined, key, namespace, scopeReference);
+                        }
+                    }
+                    return returnValue;
+                },
+                async keys() { return await redis.hkeys(namespace); },
+                async values() { return (await redis.hvals(namespace) || []).map((value) => value === null ? undefined : JSON.parse(value)); },
+                async entries() { return Object.entries(await redis.hgetall(namespace) || {}).map(([key, value]) => [key, value === null ? undefined : JSON.parse(value)]); },
+                get size() { return redis.hlen(namespace); },
+                observe(key, callback, options = {}) {
+                    // Prepare local data structure
+                    let ns = local.get(namespace);
+                    if (!ns) {
+                        ns = new Map();
+                        local.set(namespace, ns);
+                    }
+
+                    let state = ns.get(key);
+                    if (!state) {
+                        state = { jsonValue: null, initialized: false, subscriptions: new Set() };
+                        ns.set(key, state);
+                        // Prime initial value only once
+                        redis.hget(namespace, key).then((jsonValue) => {
+                            if (state.initialized) return;
+                            state.jsonValue = jsonValue;
+                            state.initialized = true;
+                        });
+                    }
+
+                    const subscription = { callback, options, scopeReference };
+                    state.subscriptions.add(subscription);
+                    if (options.signal) {
+                        options.signal.addEventListener('abort', () => {
+                            state.subscriptions.delete(subscription);
+                            if (state.subscriptions.size === 0) ns.delete(key);
+                            if (ns.size === 0) local.delete(namespace);
+                        });
+                    }
+
+                    // Unsubscribe logic
+                    const cleanup = () => {
+                        state.subscriptions.delete(subscription);
+                        if (state.subscriptions.size === 0) ns.delete(key);
+                        if (ns.size === 0) local.delete(namespace);
+                    };
+                    cleanups.push(cleanup);
+                    return cleanup;
+                },
+                cleanup() {
+                    for (const cleanup of cleanups) cleanup();
+                    cleanups.length = 0;
+                },
+            };
+        };
+
+        // Watch for changes
+        const redisWatch = this.bootstrap.init.redisWatch;
+        if (redisWatch) {
+            // Subscribe to all events
+            redisWatch.psubscribe('__keyevent@0__:*');
+            redisWatch.on('pmessage', async (pattern, channel, redisKey) => {
+                const [, , event] = channel.split(':'); // -> "hset", "hdel", "expire", "del"
+                const namespace = redisKey;
+
+                const nsLocal = local.get(namespace);
+                if (!nsLocal) return;
+
+                const emitDiff = async () => {
+                    for (const [field, state] of nsLocal) {
+                        const jsonValue = await redis.hget(namespace, field);
+                        if (jsonValue !== state.jsonValue) {
+                            state.jsonValue = jsonValue;
+                            const value = jsonValue === null ? undefined : JSON.parse(jsonValue);
+                            fire(state, value, field, namespace);
+                        }
+                    }
                 }
-                return returnValue;
-            },
-            async delete(key) { return await redis.hdel(namespace, key); },
-            async clear() { return await redis.del(namespace); },
-            async keys() { return await redis.hkeys(namespace); },
-            async values() { return (await redis.hvals(namespace) || []).map((value) => typeof value === 'undefined' ? value : JSON.parse(value)); },
-            async entries() { return Object.entries(await redis.hgetall(namespace) || {}).map(([key, value]) => [key, typeof value === 'undefined' ? value : JSON.parse(value)]); },
-            get size() { return redis.hlen(namespace); },
-        });
+
+                // Field updates
+                if (event === 'hset') await emitDiff();
+                if (event === 'hdel') await emitDiff();
+
+                // Namespace removal (expire or del)
+                if (event === 'expire' || event === 'del') {
+                    for (const [key, state] of nsLocal) {
+                        if (state.jsonValue !== null) {
+                            state.jsonValue = null;
+                            fire(state, undefined, key, namespace);
+                        }
+                    }
+                    local.delete(namespace);
+                }
+            });
+        }
     }
 
     control() {

package/src/runtime-pi/webflo-server/messaging/Client.js

@@ -17,11 +17,11 @@ export class Client extends WQStarPort {
 
     createRequestRealtime(portID, url = null) {
         const requestPort = new ClientRequestRealtime(portID, url);
-        const cleanup = this.addPort(requestPort);
+        this.addPort(requestPort);
         setTimeout(() => {
             if (requestPort.length || !this.findPort((port) => port === requestPort)) return;
-            cleanup();
-        }, 30000/*30sec*/);
+            requestPort.close(true);
+        }, 15000/*15sec*/);
         return requestPort;
     }
 }