@webqit/webflo 1.0.34 → 1.0.36

package/package.json

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

package/src/runtime-pi/{WebfloCookieStorage.js → HttpCookies.js}

@@ -2,15 +2,14 @@ import { _isObject } from '@webqit/util/js/index.js';
 import { renderCookieObj } from './util-http.js';
 import { WebfloStorage } from './WebfloStorage.js';
 
-export class WebfloCookieStorage extends WebfloStorage {
+export class HttpCookies extends WebfloStorage {
 
     #originals;
 
     constructor(request, iterable = []) {
         iterable = [...iterable].map(([key, value]) => [key, !_isObject(value) ? { name: key, value } : value]);
-        iterable = Object.fromEntries(iterable);
-        super(iterable, null, request);
-        this.#originals = { ...iterable };
+        super(new Map(iterable), null, request);
+        this.#originals = new Map(iterable);
     }
 
     async set(key, value) {
@@ -24,8 +23,8 @@ export class WebfloCookieStorage extends WebfloStorage {
     }
 
     async render() {
-        const entries = await Promise.all((await this.keys()).concat(Object.keys(this.#originals)).map(async (key) => {
-            const a = Reflect.get(this.#originals, key);
+        const entries = await Promise.all((await this.keys()).concat(this.#originals.keys()).map(async (key) => {
+            const a = this.#originals.get(key);
             const b = await this.get(key, true);
             if (a === b || (_isObject(a) && _isObject(b) && _even(a, b))) {
                 // Same

package/src/runtime-pi/HttpSession.js

@@ -0,0 +1,11 @@
+import { WebfloStorage } from './WebfloStorage.js';
+
+export class HttpSession extends WebfloStorage {
+    static create(store, request) {
+        return new this(
+            store,
+            request,
+            true
+        );
+    }
+}

package/src/runtime-pi/HttpUser.js

@@ -1,27 +1,27 @@
 import { WebfloStorage } from './WebfloStorage.js';
 
 export class HttpUser extends WebfloStorage {
-    
-    static create(request, session, client) {
-        return new this(request, session, client);
+
+    static create(store, request, session, client) {
+        return new this(store, request, session, client);
     }
 
-    #session;
     #client;
 
-    constructor(request, session, client) {
-        super(session, '#user', request, session);
-        this.#session = session;
+    constructor(store, request, session, client) {
+        super(
+            store,
+            request,
+            session
+        );
         this.#client = client;
     }
 
     async isSignedIn() {
-        await this.#session.refresh();
         return await this.has('id');
     }
 
     async signIn(...args) {
-        await this.#session.refresh();
         return await this.require(
             ['id'].concat(typeof args[0] === 'string' || Array.isArray(args[0]) ? args.unshift() : []),
             ...args
@@ -30,7 +30,6 @@ export class HttpUser extends WebfloStorage {
 
     async signOut() {
         await this.clear();
-        await this.#session.commit();
     }
 
     async confirm(data, callback, options = {}) {

package/src/runtime-pi/WebfloStorage.js

@@ -3,50 +3,51 @@ import { _even } from '@webqit/util/obj/index.js';
 
 export class WebfloStorage {
     
+    #store;
     #request;
     #session;
-    #registry;
-    #key;
-    #store;
     #modified = false;
 
-    constructor(registry, key, request, session = null) {
-        this.#registry = registry;
-        this.#key = key;
+    constructor(store, request, session = null) {
+        this.#store = store || new Map;
         this.#request = request;
         this.#session = session === true ? this : session;
     }
-    
-    async store() {
-        if (!this.#key) {
-            return this.#registry;
-        }
-        if (!this.#store && !(this.#store = await this.#registry.get(this.#key))) {
-            this.#store = {};
-        }
-        return this.#store;
+
+    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);
+        this.#modified = true;
+        await this.emit(key, value);
+        return this;
     }
 
-    async refresh() {
-        let $store;
-        if (!this.#store || !($store = await this.#registry.get(this.#key))) return;
-        Object.assign(this.#store, $store);
+    async delete(key) {
+        await this.#store.delete(key);
+        this.#modified = true;
+        await this.emit(key);
+        return this;
     }
 
-    async commit() {
-        if (this.#store && this.#key && this.#modified) {
-            await this.#registry.set(this.#key, this.#store);
-        }
-        this.#modified = false;
+    async clear() {
+        await this.#store.clear();
+        this.#modified = true;
+        await this.emit();
+        return this;
     }
 
-    get size() { return this.store().then((store) => Object.keys(store).length); }
+    async keys() { return [...await this.#store.keys()]; }
 
-    [ Symbol.iterator ]() { return this.entries().then((entries) => entries[ Symbol.iterator ]()); }
+    async values() { return [...await this.#store.values()]; }
+
+    async entries() { return [...await this.#store.entries()]; }
 
     async json(arg = null) {
         if (!arguments.length || typeof arg === 'boolean') {
-            return { ...(await this.store()) };
+            return Object.fromEntries(await this.#store.entries());
         }
         if (!_isObject(arg)) {
             throw new Error(`Argument must be a valid JSON object`);
@@ -56,39 +57,14 @@ export class WebfloStorage {
         }));
     }
 
-    async get(key) { return Reflect.get(await this.store(), key); }
-
-    async has(key) { return Reflect.has(await this.store(), key); }
-
-    async keys() { return Object.keys(await this.store()); }
-
-    async values() { return Object.values(await this.store()); }
-
-    async entries() { return Object.entries(await this.store()); }
-
-    async forEach(callback) { (await this.entries()).forEach(callback); }
+    async forEach(callback) { (await this.entries()).forEach(([key, value], i) => callback(value, key, i)); }
 
-    async set(key, value) {
-        Reflect.set(await this.store(), key, value);
-        this.#modified = true;
-        await this.emit(key, value);
-        return this;
-    }
+    [ Symbol.iterator ]() { return this.entries().then((entries) => entries[ Symbol.iterator ]()); }
 
-    async delete(key) {
-        Reflect.deleteProperty(await this.store(), key);
-        this.#modified = true;
-        await this.emit(key);
-        return this;
-    }
+    get size() { return this.#store.sizs; }
 
-    async clear() {
-        for (const key of await this.keys()) {
-            Reflect.deleteProperty(await this.store(), key);
-        }
-        this.#modified = true;
-        await this.emit();
-        return this;
+    async commit() {
+        this.#modified = false;
     }
 
     #listeners = new Set;

package/src/runtime-pi/client/{CookieStorage.js → ClientSideCookies.js}

@@ -1,6 +1,6 @@
-import { WebfloCookieStorage } from '../WebfloCookieStorage.js';
+import { HttpCookies } from '../HttpCookies.js';
 
-export class CookieStorage extends WebfloCookieStorage {
+export class ClientSideCookies extends HttpCookies {
     static create(request) {
         return new this(
             request,

package/src/runtime-pi/client/WebfloClient.js

@@ -6,8 +6,8 @@ import { MessagingOverBroadcast } from '../MessagingOverBroadcast.js';
 import { MessagingOverChannel } from '../MessagingOverChannel.js';
 import { MessagingOverSocket } from '../MessagingOverSocket.js';
 import { ClientMessaging } from './ClientMessaging.js';
-import { CookieStorage } from './CookieStorage.js';
-import { SessionStorage } from './SessionStorage.js';
+import { ClientSideCookies } from './ClientSideCookies.js';
+import { HttpSession } from '../HttpSession.js';
 import { HttpEvent } from '../HttpEvent.js';
 import { HttpUser } from '../HttpUser.js';
 import { Router } from './Router.js';
@@ -23,9 +23,9 @@ export class WebfloClient extends WebfloRuntime {
 
 	static get HttpEvent() { return HttpEvent; }
 
-	static get CookieStorage() { return CookieStorage; }
+	static get HttpCookies() { return ClientSideCookies; }
 
-	static get SessionStorage() { return SessionStorage; }
+	static get HttpSession() { return HttpSession; }
 
     static get HttpUser() { return HttpUser; }
 
@@ -48,11 +48,8 @@ export class WebfloClient extends WebfloRuntime {
         return document.querySelector('meta[name="webflo-viewtransitions"]')?.value;
     }
 
-    env(key) {
-        return key in this.cx.params.mappings
-        ? this.cx.params.env[this.cx.params.mappings[key]]
-        : this.cx.params.env[key];
-    }
+    #sdk = {};
+    get sdk() { return this.#sdk; }
 
     constructor(host) {
         super();
@@ -74,6 +71,12 @@ export class WebfloClient extends WebfloRuntime {
         };
     }
 
+    env(key) {
+        return key in this.cx.params.mappings
+        ? this.cx.params.env[this.cx.params.mappings[key]]
+        : this.cx.params.env[key];
+    }
+
     async initialize() {
 		this.#backgroundMessaging = new MultiportMessagingAPI(this, { runtime: this });
         // Bind response and redirect handlers
@@ -329,12 +332,16 @@ export class WebfloClient extends WebfloRuntime {
         };
         // Create and route request
         scope.request = this.createRequest(scope.url, scope.init);
-        scope.cookies = this.constructor.CookieStorage.create(scope.request);
-        scope.session = this.constructor.SessionStorage.create(scope.request);
+        scope.cookies = this.constructor.HttpCookies.create(scope.request);
+        scope.session = this.constructor.HttpSession.create(
+            this.#sdk.storage?.('session'),
+            scope.request
+        );
         const messageChannel = new MessageChannel;
         this.backgroundMessaging.add(new MessagingOverChannel(null, messageChannel.port1));
         scope.clientMessaging = new ClientMessaging(this, messageChannel.port2);
         scope.user = this.constructor.HttpUser.create(
+            this.#sdk.storage?.('user'),
             scope.request, 
             scope.session, 
             scope.clientMessaging
@@ -346,7 +353,7 @@ export class WebfloClient extends WebfloRuntime {
             session: scope.session,
             user: scope.user,
             client: scope.clientMessaging,
-            sdk: {}
+            sdk: this.#sdk
         });
         await this.setup(scope.httpEvent);
         scope.httpEvent.onRequestClone = () => this.createRequest(scope.url, scope.init);

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

@@ -3,8 +3,8 @@ import { _isObject } from '@webqit/util/js/index.js';
 import { pattern } from '../../util-url.js';
 import { WebfloRuntime } from '../../WebfloRuntime.js';
 import { ClientMessaging } from './ClientMessaging.js';
-import { CookieStorage } from './CookieStorage.js';
-import { SessionStorage } from './SessionStorage.js';
+import { WorkerSideCookies } from './WorkerSideCookies.js';
+import { HttpSession } from '../../HttpSession.js';
 import { HttpEvent } from '../../HttpEvent.js';
 import { HttpUser } from '../../HttpUser.js';
 import { Workport } from './Workport.js';
@@ -21,9 +21,9 @@ export class WebfloWorker extends WebfloRuntime {
 
 	static get HttpEvent() { return HttpEvent; }
 
-	static get CookieStorage() { return CookieStorage; }
+	static get HttpCookies() { return WorkerSideCookies; }
 
-	static get SessionStorage() { return SessionStorage; }
+	static get HttpSession() { return HttpSession; }
 
 	static get HttpUser() { return HttpUser; }
 
@@ -36,6 +36,9 @@ export class WebfloWorker extends WebfloRuntime {
 	#cx;
 	get cx() { return this.#cx; }
 
+    #sdk = {};
+    get sdk() { return this.#sdk; }
+
 	constructor(cx) {
 		super();
 		if (!(cx instanceof this.constructor.Context)) {
@@ -163,11 +166,15 @@ export class WebfloWorker extends WebfloRuntime {
 		};
 		// Create and route request
 		scope.request = this.createRequest(scope.url, scope.init);
-		scope.cookies = this.constructor.CookieStorage.create(scope.request);
-		scope.session = this.constructor.SessionStorage.create(scope.request);
+		scope.cookies = this.constructor.HttpCookies.create(scope.request);
+		scope.session = this.constructor.HttpSession.create(
+			this.#sdk.storage?.('session'),
+			scope.request
+		);
 		const portID = crypto.randomUUID();
 		scope.clientMessaging = new ClientMessaging(this, portID, { isPrimary: true });
 		scope.user = this.constructor.HttpUser.create(
+			this.#sdk.storage?.('user'),
 			scope.request,
 			scope.session,
 			scope.clientMessaging

package/src/runtime-pi/{server/CookieStorage.js → client/worker/WorkerSideCookies.js}

@@ -1,6 +1,6 @@
-import { WebfloCookieStorage } from '../WebfloCookieStorage.js';
+import { HttpCookies } from '../../HttpCookies.js';
 
-export class CookieStorage extends WebfloCookieStorage {
+export class WorkerSideCookies extends HttpCookies {
     static create(request) {
         return new this(
             request,

package/src/runtime-pi/{client/worker/CookieStorage.js → server/ServerSideCookies.js}

@@ -1,6 +1,6 @@
-import { WebfloCookieStorage } from '../../WebfloCookieStorage.js';
+import { HttpCookies } from '../HttpCookies.js';
 
-export class CookieStorage extends WebfloCookieStorage {
+export class ServerSideCookies extends HttpCookies {
     static create(request) {
         return new this(
             request,

package/src/runtime-pi/server/{SessionStorage.js → ServerSideSession.js}

@@ -1,10 +1,9 @@
-import { WebfloStorage } from '../WebfloStorage.js';
+import { HttpSession } from '../HttpSession.js';
 import crypto from 'crypto';
 
-const inmemSessionRegistry = new Map;
-export class SessionStorage extends WebfloStorage {
+export class ServerSideSession extends HttpSession {
 
-    static create(request, params = {}) {
+    static create(storageCallback, request, params = {}) {
         let sessionID = request.headers.get('Cookie', true).find((c) => c.name === '__sessid')?.value;
         if (sessionID?.includes('.')) {
             if (params.secret) {
@@ -30,28 +29,34 @@ export class SessionStorage extends WebfloStorage {
                 sessionID = crypto.randomUUID();
             }
         }
-        return new this(params.registry || inmemSessionRegistry, sessionID, request, params.ttl);
+        return new this(
+            storageCallback(sessionID),
+            request,
+            { sessionID, ...params }
+        );
     }
 
+    #params;
     #sessionID;
     get sessionID() { return this.#sessionID; }
-    #ttl;
     
-    constructor(reqistry, sessionID, request, ttl) {
+    constructor(store, request, { sessionID, ...params } = {}) {
+        if (!sessionID) {
+            throw new Error(`sessionID is required`);
+        }
         super(
-            reqistry,
-            `session/${sessionID}`,
+            store,
             request,
             true
         );
+        this.#params = params;
         this.#sessionID = sessionID;
-        this.#ttl = ttl;
     }
 
     async commit(response = null) {
         if (response && !response.headers.get('Set-Cookie', true).find((c) => c.name === '__sessid')) {
             // expires six months
-            response.headers.append('Set-Cookie', `__sessid=${this.#sessionID}; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=${this.#ttl}`);
+            response.headers.append('Set-Cookie', `__sessid=${this.#sessionID}; Path=/; Secure; HttpOnly; SameSite=Lax${this.#params.ttl ? `; Max-Age=${this.#params.ttl}` : ''}`);
         }
         await super.commit();
     }

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

@@ -15,14 +15,14 @@ import { Readable as _ReadableStream } from 'stream';
 import { WebfloRuntime } from '../WebfloRuntime.js';
 import { createWindow } from '@webqit/oohtml-ssr';
 import { Context } from './Context.js';
-import { CookieStorage } from './CookieStorage.js';
-import { SessionStorage } from './SessionStorage.js';
 import { MessagingOverSocket } from '../MessagingOverSocket.js';
 import { ClientMessagingRegistry } from './ClientMessagingRegistry.js';
+import { ServerSideCookies } from './ServerSideCookies.js';
+import { ServerSideSession } from './ServerSideSession.js';
 import { HttpEvent } from '../HttpEvent.js';
 import { HttpUser } from '../HttpUser.js';
 import { Router } from './Router.js';
-import { params, pattern } from '../util-url.js';
+import { pattern } from '../util-url.js';
 import xfetch from '../xfetch.js';
 import '../util-http.js';
 
@@ -37,9 +37,9 @@ export class WebfloServer extends WebfloRuntime {
 
     static get HttpEvent() { return HttpEvent; }
 
-    static get CookieStorage() { return CookieStorage; }
+    static get HttpCookies() { return ServerSideCookies; }
 
-    static get SessionStorage() { return SessionStorage; }
+    static get HttpSession() { return ServerSideSession; }
 
     static get HttpUser() { return HttpUser; }
 
@@ -74,10 +74,10 @@ export class WebfloServer extends WebfloRuntime {
 
     async initialize() {
         process.on('uncaughtException', (err) => {
-            console.error('Uncaught- Exception:', err);
+            console.error('Uncaught Exception:', err);
         });
         process.on('unhandledRejection', (reason, promise) => {
-            console.log('Unhandled -Rejection', reason, promise);
+            console.log('Unhandled Rejection', reason, promise);
         });
         const resolveContextObj = async (cx, force = false) => {
             if (_isEmpty(cx.layout) || force) { cx.layout = await (new cx.config.deployment.Layout(cx)).read(); }
@@ -218,9 +218,39 @@ export class WebfloServer extends WebfloRuntime {
         }
         if (this.#cx.server.capabilities?.redis) {
             const { Redis } = await import('ioredis');
-            this.#sdk.redis = this.env('REDIS_URL')
+            const redis = this.env('REDIS_URL')
                 ? new Redis(this.env('REDIS_URL'))
                 : new Redis;
+            this.#sdk.redis = redis;
+            this.#sdk.storage = (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;
+                    }
+                    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); },
+                async entries() { return Object.entries(await redis.hgetall(namespace) || {}); },
+                get size() { return redis.hlen(namespace); },
+            });
+        } else {
+            const inmemSessionRegistry = new Map;
+            this.#sdk.storage = (namespace) => {
+                if (!inmemSessionRegistry.has(namespace)) {
+                    inmemSessionRegistry.set(namespace, new Map);
+                }
+                return inmemSessionRegistry.get(namespace);
+            };
         }
         if (this.#cx.server.capabilities?.webpush) {
             const { default: webpush } = await import('web-push');
@@ -271,14 +301,15 @@ export class WebfloServer extends WebfloRuntime {
         // Level 3 validation
         // and actual processing
         scope.request = this.createRequest(scope.url.href, requestInit);
-        scope.session = this.constructor.SessionStorage.create(scope.request, {
-            secret: this.env('SESSION_KEY'),
-            registry: this.#sdk.redis && {
-                get: async (key) => { return JSON.parse(await this.#sdk.redis.get(`${scope.url.host}/${key}`) || null) },
-                set: async (key, value) => { return await this.#sdk.redis.set(`${scope.url.host}/${key}`, JSON.stringify(value), 'EX', this.env('SESSION_TTL') || 2592000/*30days*/) },
-            },
-            ttl: this.env('SESSION_TTL') || 2592000/*30days*/,
-        });
+        scope.sessionTTL = this.env('SESSION_TTL') || 2592000/*30days*/;
+        scope.session = this.constructor.HttpSession.create(
+            (sessionID) => this.#sdk.storage?.(`${scope.url.host}/session:${sessionID}`, scope.sessionTTL),
+            scope.request,
+            {
+                secret: this.env('SESSION_KEY'),
+                ttl: scope.sessionTTL,
+            }
+        );
         if (!scope.error) {
             if (!(scope.clientMessagingRegistry = this.#globalMessagingRegistry.get(scope.session.sessionID))) {
                 scope.error = `Lost or invalid clientID`;
@@ -576,15 +607,16 @@ export class WebfloServer extends WebfloRuntime {
             ? ((await (new this.#cx.config.runtime.server.Headers(this.#cx)).read()).entries || []).filter(entry => pattern(entry.url, url.origin).exec(url.href))
             : [];
         scope.request = this.createRequest(scope.url.href, scope.init, scope.autoHeaders.filter((header) => header.type === 'request'));
-        scope.cookies = this.constructor.CookieStorage.create(scope.request);
-        scope.session = this.constructor.SessionStorage.create(scope.request, {
-            secret: this.env('SESSION_KEY'),
-            registry: this.#sdk.redis && {
-                get: async (key) => { return JSON.parse(await this.#sdk.redis.get(`${scope.url.host}/${key}`) || null) },
-                set: async (key, value) => { return await this.#sdk.redis.set(`${scope.url.host}/${key}`, JSON.stringify(value), 'EX', this.env('SESSION_TTL') || 2592000/*30days*/); },
-            },
-            ttl: this.env('SESSION_TTL') || 2592000/*30days*/,
-        });
+        scope.cookies = this.constructor.HttpCookies.create(scope.request);
+        scope.sessionTTL = this.env('SESSION_TTL') || 2592000/*30days*/;
+        scope.session = this.constructor.HttpSession.create(
+            (sessionID) => this.#sdk.storage?.(`${scope.url.host}/session:${sessionID}`, scope.sessionTTL),
+            scope.request,
+            {
+                secret: this.env('SESSION_KEY'),
+                ttl: scope.sessionTTL,
+            }
+        );
         const sessionID = scope.session.sessionID;
         if (!this.#globalMessagingRegistry.has(sessionID)) {
             this.#globalMessagingRegistry.set(sessionID, new ClientMessagingRegistry(this, sessionID));
@@ -592,6 +624,7 @@ export class WebfloServer extends WebfloRuntime {
         scope.clientMessagingRegistry = this.#globalMessagingRegistry.get(sessionID);
         scope.clientMessaging = scope.clientMessagingRegistry.createPort();
         scope.user = this.constructor.HttpUser.create(
+            this.#sdk.storage?.(`${scope.url.host}/user:${scope.session.sessionID}`, scope.sessionTTL),
             scope.request, 
             scope.session, 
             scope.clientMessaging

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

@@ -1,16 +0,0 @@
-import { WebfloStorage } from '../WebfloStorage.js';
-
-export class SessionStorage extends WebfloStorage {
-    static create(request) {
-        const registry = {
-            async get(key) { return localStorage.getItem(key) },
-            async set(key, value) { return localStorage.setItem(key, value) },
-        };
-        return new this(
-            registry,
-            'session',
-            request,
-            true
-        );
-    }
-}

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

@@ -1,11 +0,0 @@
-import { WebfloStorage } from '../../WebfloStorage.js';
-
-export class SessionStorage extends WebfloStorage {
-    static create(request) {
-        return new this({}, null, request);
-    }
-
-    async commit(response = null) {
-        await super.commit();
-    }
-}