@webqit/webflo 1.0.20 → 1.0.22

package/package.json

@@ -12,7 +12,7 @@
     "vanila-javascript"
   ],
   "homepage": "https://webqit.io/tooling/webflo",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -35,15 +35,17 @@
     "webflo-certbot-http-cleanup-hook": "src/services-pi/cert/http-cleanup-hook.js"
   },
   "dependencies": {
+    "@linked-db/linked-ql": "^0.30.13",
     "@octokit/webhooks": "^7.15.1",
     "@webqit/backpack": "^0.1.8",
     "@webqit/observer": "^2.0.7",
     "@webqit/oohtml-ssr": "^2.1.1",
     "@webqit/util": "^0.8.11",
-    "client-sessions": "^0.8.0",
     "esbuild": "^0.14.38",
+    "ioredis": "^5.5.0",
     "jsdom": "^21.1.1",
     "mime-types": "^2.1.33",
+    "pg": "^8.13.3",
     "simple-git": "^2.20.1",
     "stream-slice": "^0.1.2",
     "urlpattern-polyfill": "^4.0.3",

package/src/config-pi/runtime/Client.js

@@ -28,8 +28,8 @@ export default class Client extends Dotfile {
                 webpush: false,
                 custom_install: false,
                 exposed: ['display-mode', 'notifications'],
-                app_vapid_public_key_variable: 'APP_VAPID_PUBLIC_KEY',
-                app_public_webhook_url_variable: 'APP_PUBLIC_WEBHOOK_URL',
+                vapid_public_key_variable: 'VAPID_PUBLIC_KEY',
+                generic_public_webhook_url_variable: 'GENERIC_PUBLIC_WEBHOOK_URL',
             },
         }, config, 'patch');
     }
@@ -104,14 +104,14 @@ export default class Client extends Dotfile {
                         initial: (config.exposed || []).join(', '),
                     },
                     {
-                        name: 'app_vapid_public_key_variable',
+                        name: 'vapid_public_key_variable',
                         type: (prev, answers) => !answers.webpush ? null : 'text',
                         message: 'Enter the environment variable name for APP_VAPID_PUBLIC_KEY if not as written',
                     },
                     {
-                        name: 'app_public_webhook_url_variable',
+                        name: 'generic_public_webhook_url_variable',
                         type: 'text',
-                        message: 'Enter the environment variable name for APP_PUBLIC_WEBHOOK_URL if not as written',
+                        message: 'Enter the environment variable name for GENERIC_PUBLIC_WEBHOOK_URL if not as written',
                     },
                 ]
             }

package/src/config-pi/runtime/Server.js

@@ -29,11 +29,17 @@ export default class Server extends Dotfile {
                 force: false,
             },
             force_www: '',
-            session_key_variable: 'APP_SESSION_KEY',
+            session_key_variable: 'SESSION_KEY',
             capabilities: {
+                database: false,
+                database_dialect: 'postgres',
+                database_url_variable: 'DATABASE_URL',
+                redis: false,
+                redis_url_variable: 'REDIS_URL',
                 webpush: false,
-                app_vapid_public_key_variable: 'APP_VAPID_PUBLIC_KEY',
-                app_vapid_private_key_variable: 'APP_VAPID_PRIVATE_KEY'
+                vapid_subject: 'mailto:foo@example.com',
+                vapid_public_key_variable: 'VAPID_PUBLIC_KEY',
+                vapid_private_key_variable: 'VAPID_PRIVATE_KEY',
             },
         }, config, 'patch');
     }
@@ -74,7 +80,7 @@ export default class Server extends Dotfile {
             {
                 name: 'session_key_variable',
                 type: 'text',
-                message: 'Enter the environment variable name for APP_SESSION_KEY if not as written',
+                message: 'Enter the environment variable name for SESSION_KEY if not as written',
                 initial: config.session_key_variable,
             },
             {
@@ -124,22 +130,56 @@ export default class Server extends Dotfile {
                 },
                 initial: config.capabilities,
                 schema: [
+                    {
+                        name: 'database',
+                        type: 'toggle',
+                        message: 'Add database integration?',
+                        active: 'YES',
+                        inactive: 'NO',
+                    },
+                    {
+                        name: 'database_dialect',
+                        type: (prev, answers) => !answers.database ? null : 'text',
+                        message: 'Enter the database dialect (postgres for now)',
+                    },
+                    {
+                        name: 'database_url_variable',
+                        type: (prev, answers) => !answers.database ? null : 'text',
+                        message: 'Enter the environment variable name for DATABASE_URL if not as written',
+                    },
+                    {
+                        name: 'redis',
+                        type: 'toggle',
+                        message: 'Add redis integration?',
+                        active: 'YES',
+                        inactive: 'NO',
+                    },
+                    {
+                        name: 'redis_url_variable',
+                        type: (prev, answers) => !answers.redis ? null : 'text',
+                        message: 'Enter the environment variable name for REDIS_URL if not as written',
+                    },
                     {
                         name: 'webpush',
                         type: 'toggle',
-                        message: 'Support push-notifications?',
+                        message: 'Add webpush integration?',
                         active: 'YES',
                         inactive: 'NO',
                     },
                     {
-                        name: 'app_vapid_public_key_variable',
+                        name: 'vapid_subject',
+                        type: (prev, answers) => !answers.webpush ? null : 'text',
+                        message: 'Enter the vapid_subject URL',
+                    },
+                    {
+                        name: 'vapid_public_key_variable',
                         type: (prev, answers) => !answers.webpush ? null : 'text',
-                        message: 'Enter the environment variable name for APP_VAPID_PUBLIC_KEY if not as written',
+                        message: 'Enter the environment variable name for VAPID_PUBLIC_KEY if not as written',
                     },
                     {
-                        name: 'app_vapid_private_key_variable',
+                        name: 'vapid_private_key_variable',
                         type: (prev, answers) => !answers.webpush ? null : 'text',
-                        message: 'Enter the environment variable name for APP_VAPID_PRIVATE_KEY if not as written',
+                        message: 'Enter the environment variable name for VAPID_PRIVATE_KEY if not as written',
                     },
                 ]
             },

package/src/runtime-pi/HttpUser.js

@@ -1,4 +1,3 @@
-import { _isObject } from '@webqit/util/js/index.js';
 import { WebfloStorage } from './WebfloStorage.js';
 
 export class HttpUser extends WebfloStorage {
@@ -7,89 +6,15 @@ export class HttpUser extends WebfloStorage {
         return new this(request, session, client);
     }
 
-    #session;
     #client;
 
     constructor(request, session, client) {
-        super(request, session);
-        this.#session = session;
+        super(session, '#user', request, session);
         this.#client = client;
-        // Trigger this
-        this.#dict;
     }
 
-    get #dict() {
-        return this.#session.get('user') || {};
-    }
-
-    [ Symbol.iterator ]() { return this.entries()[ Symbol.iterator ](); }
-
-    get size() { return Object.keys(this.#dict).length; }
-
-    get(key) {
-        return Reflect.get(this.#dict, key);
-    }
-
-    has(key) {
-        return Reflect.has(this.#dict, key);
-    }
-
-    keys() {
-        return Object.keys(this.#dict);
-    }
-
-    values() {
-        return Object.values(this.#dict);
-    }
-
-    entries() {
-        return Object.entries(this.#dict);
-    }
-
-    forEach(callback) {
-        this.entries().forEach(callback);
-    }
-
-    async set(key, value) {
-        if (!this.#session.has('user')) {
-            await this.#session.set('user', {});
-        }
-        Reflect.set(this.#dict, key, value);
-        await this.emit(key, value);
-        return this;
-    }
-
-    async delete(key) {
-        if (!this.#session.has('user')) {
-            await this.#session.set('user', {});
-        }
-        Reflect.deleteProperty(this.#dict, key);
-        await this.emit(key);
-        return this;
-    }
-
-    async clear() {
-        for (const key of this.keys()) {
-            Reflect.deleteProperty(this.#dict, key);
-        }
-        await this.emit();
-        return this;
-    }
-
-    async 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`);
-        }
-        return await Promise.all(Object.entries(arg).map(([key, value]) => {
-            return this.set(key, value);
-        }));
-    }
-
-    isSignedIn() {
-        return this.has('id');
+    async isSignedIn() {
+        return await this.has('id');
     }
 
     async signIn(...args) {

package/src/runtime-pi/WebfloCookieStorage.js

@@ -3,10 +3,14 @@ import { renderCookieObj } from './util-http.js';
 import { WebfloStorage } from './WebfloStorage.js';
 
 export class WebfloCookieStorage extends WebfloStorage {
+
+    #originals;
+
     constructor(request, iterable = []) {
         iterable = [...iterable].map(([key, value]) => [key, !_isObject(value) ? { name: key, value } : value]);
-        super(request, null, iterable);
-        this.saveOriginals();
+        iterable = Object.fromEntries(iterable);
+        super(iterable, null, request);
+        this.#originals = { ...iterable };
     }
 
     async set(key, value) {
@@ -14,14 +18,26 @@ export class WebfloCookieStorage extends WebfloStorage {
         return await super.set(key, value);
     }
 
-    get(key, withDetail = false) {
-        if (!withDetail) return super.get(key)?.value;
-        return super.get(key);
+    async get(key, withDetail = false) {
+        if (!withDetail) return (await super.get(key))?.value;
+        return await super.get(key);
     }
 
-    render() {
-        return this.getAdded().map((key) => renderCookieObj({ name: key, ...this.get(key, true) })).concat(
-            this.getDeleted().map((key) => renderCookieObj({ name: key, value: '', maxAge: 0 }))
-        );
+    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 b = await this.get(key, true);
+            if (a === b || (_isObject(a) && _isObject(b) && _even(a, b))) {
+                // Same
+                return;
+            }
+            if ([undefined, null].includes(b)) {
+                // Deleted
+                return { name: key, value: '', maxAge: 0 };
+            }
+            // Added or modified
+            return { name: key, ...(await this.get(key, true)) };
+        })).then((entries) => entries.filter((e) => e));
+        return entries.map((e) => renderCookieObj(e));
     }
 }

package/src/runtime-pi/WebfloRuntime.js

@@ -37,8 +37,8 @@ export class WebfloRuntime {
                 ? new Response(null, { status: 404 })
                 : Response.create(response);
         }
-        // Commit data
-        for (const storage of [httpEvent.cookies, httpEvent.session, httpEvent.storage]) {
+        // Commit data in the exact order. Reason: in how they depend on each other
+        for (const storage of [httpEvent.user, httpEvent.session, httpEvent.cookies]) {
             await storage?.commit?.(response);
         }
         return response;

package/src/runtime-pi/WebfloStorage.js

@@ -1,39 +1,83 @@
 import { _isObject } from '@webqit/util/js/index.js';
 import { _even } from '@webqit/util/obj/index.js';
 
-export class WebfloStorage extends Map {
+export class WebfloStorage {
     
     #request;
     #session;
+    #registry;
+    #key;
+    #store;
 
-    constructor(request, session, iterable = []) {
-        super();
+    constructor(registry, key, request, session = null) {
+        this.#registry = registry;
+        this.#key = key;
         this.#request = request;
         this.#session = session === true ? this : session;
-        for (const [k, v] of iterable) {
-            this.set(k, v);
-        }
     }
     
-    #originals;
-    saveOriginals() { this.#originals = new Map(this); }
-
-    getDeleted() {
-        if (!this.#originals) return [];
-        return [...this.#originals.keys()].filter((k) => {
-            return !this.has(k);
-        });
+    async store() {
+        if (!this.#key) {
+            return this.#registry;
+        }
+        if (!this.#store && !(this.#store = await this.#registry.get(this.#key))) {
+            this.#store = {};
+            await this.#registry.set(this.#key, this.#store);
+        }
+        return this.#store;
     }
 
-    getAdded() {
-        if (!this.#originals) return [...this.keys()];
-        return [...new Set([...this.keys(), ...this.#originals.keys()])].filter((k) => {
-            return !this.#originals.has(k) || (this.has(k) && ((a, b) => _isObject(a) && _isObject(b) ? !_even(a, b) : a !== b)(this.get(k, true), this.#originals.get(k)));
-        });
+    async commit() {
+        if (!this.#store || !this.#key) return;
+        await this.#registry.set(this.#key, this.#store);
     }
 
-    async commit() {
-        this.saveOriginals();
+    get size() { return this.store().then((store) => Object.keys(store).length); }
+
+    [ Symbol.iterator ]() { return this.entries().then((entries) => entries[ Symbol.iterator ]()); }
+
+    async json(arg = null) {
+        if (!arguments.length || typeof arg === 'boolean') {
+            return { ...(await this.store()) };
+        }
+        if (!_isObject(arg)) {
+            throw new Error(`Argument must be a valid JSON object`);
+        }
+        return await Promise.all(Object.entries(arg).map(([key, value]) => {
+            return this.set(key, value);
+        }));
+    }
+
+    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 set(key, value) {
+        Reflect.set(await this.store(), key, value);
+        await this.emit(key, value);
+        return this;
+    }
+
+    async delete(key) {
+        Reflect.deleteProperty(await this.store(), key);
+        await this.emit(key);
+        return this;
+    }
+
+    async clear() {
+        for (const key of await this.keys()) {
+            Reflect.deleteProperty(await this.store(), key);
+        }
+        await this.emit();
+        return this;
     }
 
     #listeners = new Set;
@@ -58,24 +102,6 @@ export class WebfloStorage extends Map {
         return Promise.all(returnValues);
     }
 
-    async set(attr, value) {
-        const returnValue = super.set(attr, value);
-        await this.emit(attr, value);
-        return returnValue;
-    }
-
-    async delete(attr) {
-        const returnValue = super.delete(attr);
-        await this.emit(attr);
-        return returnValue;
-    }
-
-    async clear() {
-        const returnValue = super.clear();
-        await this.emit();
-        return returnValue;
-    }
-
     #handlers = new Map;
     defineHandler(attr, ...handlers) {
         const $handlers = [];
@@ -97,7 +123,7 @@ export class WebfloStorage extends Map {
     async require(attrs, callback = null, noNulls = false) {
         const entries = [];
         main: for await (const attr of [].concat(attrs)) {
-            if (!this.has(attr) || (noNulls && [undefined, null].includes(this.get(attr)))) {
+            if (!(await this.has(attr)) || (noNulls && [undefined, null].includes(await this.get(attr)))) {
                 const handlers = this.#handlers.get(attr);
                 if (!handlers) {
                     throw new Error(`No handler defined for the user attribute: ${attr}`);
@@ -132,7 +158,7 @@ export class WebfloStorage extends Map {
                     }});
                 }
             }
-            entries.push(this.get(attr));
+            entries.push(await this.get(attr));
         }
         if (callback) return await callback(...entries);
         return entries;

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

@@ -12,8 +12,8 @@ export class Capabilities {
     static async initialize(params) {
         const instance = new this;
         instance.#params = params;
-        instance.#params.app_public_webhook_url = instance.#params.app_public_webhook_url_variable && instance.#params.env[instance.#params.app_public_webhook_url_variable];
-        instance.#params.app_vapid_public_key = instance.#params.app_vapid_public_key_variable && instance.#params.env[instance.#params.app_vapid_public_key_variable];
+        instance.#params.generic_public_webhook_url = instance.#params.generic_public_webhook_url_variable && instance.#params.env[instance.#params.generic_public_webhook_url_variable];
+        instance.#params.vapid_public_key = instance.#params.vapid_public_key_variable && instance.#params.env[instance.#params.vapid_public_key_variable];
         // --------
         // Custom install
         const onbeforeinstallprompt = (e) => {
@@ -26,11 +26,11 @@ export class Capabilities {
         instance.#cleanups.push(() => window.removeEventListener('beforeinstallprompt', onbeforeinstallprompt));
         // --------
         // Webhooks
-        if (instance.#params.app_public_webhook_url) {
+        if (instance.#params.generic_public_webhook_url) {
             // --------
             // app.installed
             const onappinstalled = () => {
-                fetch(instance.#params.app_public_webhook_url, {
+                fetch(instance.#params.generic_public_webhook_url, {
                     method: 'POST',
                     headers: { 'Content-Type': 'application/json' },
                     body: JSON.stringify({ type: 'app.installed', data: true })
@@ -51,7 +51,7 @@ export class Capabilities {
                         if (eventPayload.type === 'push.subscribe' && !eventPayload.data) {
                             return window.queueMicrotask(pushPermissionStatusHandler);
                         }
-                        fetch(instance.#params.app_public_webhook_url, {
+                        fetch(instance.#params.generic_public_webhook_url, {
                             method: 'POST',
                             headers: { 'Content-Type': 'application/json' },
                             body: JSON.stringify(eventPayload)
@@ -184,8 +184,8 @@ export class Capabilities {
             if (!params.userVisibleOnly) {
                 params = { ...params, userVisibleOnly: true };
             }
-            if (!params.applicationServerKey && this.#params.app_vapid_public_key) {
-                params = { ...params, applicationServerKey: urlBase64ToUint8Array(this.#params.app_vapid_public_key) };
+            if (!params.applicationServerKey && this.#params.vapid_public_key) {
+                params = { ...params, applicationServerKey: urlBase64ToUint8Array(this.#params.vapid_public_key) };
             }
         }
         return params;

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

@@ -9,7 +9,7 @@ export class CookieStorage extends WebfloCookieStorage {
     }
 
     async commit(response) {
-        for (const cookieStr of this.render()) {
+        for (const cookieStr of await this.render()) {
             document.cookie = cookieStr;
         }
         await super.commit();

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

@@ -1,33 +1,16 @@
 import { WebfloStorage } from '../WebfloStorage.js';
 
 export class SessionStorage extends WebfloStorage {
-    static get type() { return 'session'; }
-
     static create(request) {
-        const keys = [];
-        const storeType = this.type === 'user' ? 'localStorage' : 'sessionStorage';
-		for(let i = 0; i < window[storeType].length; i ++){
-			keys.push(window[storeType].key(i));
-		};
-        const instance = new this(
+        const registry = {
+            async get(key) { return localStorage.getItem(key) },
+            async set(key, value) { return localStorage.setItem(key, value) },
+        };
+        return new this(
+            registry,
+            'session',
             request,
-            keys.map((key) => [key, window[storeType].getItem(key)])
+            true
         );
-        return instance;
-    }
-
-    constructor(request, iterable) {
-        super(request, true, iterable);
-    }
-
-    async commit() {
-        const storeType = this.constructor.type === 'user' ? 'localStorage' : 'sessionStorage';
-        for (const key of this.getAdded()) {
-            window[storeType].setItem(key, this.get(key));
-        }
-        for (const key of this.getDeleted()) {
-            window[storeType].removeItem(key);
-        }
-        await super.commit();
     }
 }

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

@@ -8,9 +8,11 @@ export class CookieStorage extends WebfloCookieStorage {
         );
     }
 
-    async commit(response) {
-        for (const cookieStr of this.render()) {
-            response.headers.append('Set-Cookie', cookieStr);
+    async commit(response = null) {
+        if (response) {
+            for (const cookieStr of await this.render()) {
+                response.headers.append('Set-Cookie', cookieStr);
+            }
         }
         await super.commit();
     }

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

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

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

@@ -184,7 +184,7 @@ export class WebfloWorker extends WebfloRuntime {
 		// Restore session before dispatching
 		if (scope.request.method === 'GET'
 			&& (scope.redirectMessageID = scope.httpEvent.url.query['redirect-message'])
-			&& (scope.redirectMessage = scope.session.get(`redirect-message:${scope.redirectMessageID}`))) {
+			&& (scope.redirectMessage = await scope.session.get(`redirect-message:${scope.redirectMessageID}`))) {
 			await scope.session.delete(`redirect-message:${scope.redirectMessageID}`);
 		}
 		// Dispatch for response

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

@@ -8,9 +8,11 @@ export class CookieStorage extends WebfloCookieStorage {
         );
     }
 
-    async commit(response) {
-        for (const cookieStr of this.render()) {
-            response.headers.append('Set-Cookie', cookieStr);
+    async commit(response = null) {
+        if (response) {
+            for (const cookieStr of await this.render()) {
+                response.headers.append('Set-Cookie', cookieStr);
+            }
         }
         await super.commit();
     }

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

@@ -1,7 +1,7 @@
 import { WebfloStorage } from '../WebfloStorage.js';
 import crypto from 'crypto';
 
-const sessionStorage = new Map;
+const inmemSessionRegistry = new Map;
 export class SessionStorage extends WebfloStorage {
 
     static create(request, params = {}) {
@@ -26,28 +26,26 @@ export class SessionStorage extends WebfloStorage {
                 sessionID = crypto.randomUUID();
             }
         }
-        if (sessionStorage.has(sessionID)) {
-            return sessionStorage.get(sessionID);
-        }
-        const instance = new this(request, sessionID);
-        sessionStorage.set(sessionID, instance);
-        return instance;
-    }
-
-    constructor(request, sessionID) {
-        super(request, true);
-        this.#sessionID = sessionID;
+        return new this(params.registry || inmemSessionRegistry, sessionID, request);
     }
 
     #sessionID;
-    get sessionID() {
-        return this.#sessionID;
+    get sessionID() { return this.#sessionID; }
+    
+    constructor(reqistry, sessionID, request) {
+        super(
+            reqistry,
+            `session:${sessionID}`,
+            request,
+            true
+        );
+        this.#sessionID = sessionID;
     }
 
-    async commit(response, force = false) {
-        if (response.headers.get('Set-Cookie', true).find((c) => c.name === '__sessid')) return;
-        //if (!force && !this.getAdded().length && !this.getDeleted().length) return;
-        response.headers.append('Set-Cookie', `__sessid=${this.#sessionID}; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=31536000`);
+    async commit(response = null) {
+        if (response && !response.headers.get('Set-Cookie', true).find((c) => c.name === '__sessid')) {
+            response.headers.append('Set-Cookie', `__sessid=${this.#sessionID}; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=31536000`);
+        }
         await super.commit();
     }
 }

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

@@ -4,7 +4,6 @@ import Path from 'path';
 import Http from 'http';
 import Https from 'https';
 import WebSocket from 'ws';
-import webpush from 'web-push';
 import Mime from 'mime-types';
 import QueryString from 'querystring';
 import { _from as _arrFrom, _any } from '@webqit/util/arr/index.js';
@@ -50,11 +49,14 @@ export class WebfloServer extends WebfloRuntime {
     #cx;
     #servers = new Map;
     #proxies = new Map;
-    #sockets = new Map;
+    #capabilitiesPromise;
 
     // Typically for access by Router
     get cx() { return this.#cx; }
 
+    #sdk = {};
+    get sdk() { return this.#sdk; }
+
     constructor(cx) {
         super();
         if (!(cx instanceof this.constructor.Context)) {
@@ -100,6 +102,53 @@ export class WebfloServer extends WebfloRuntime {
             }));
         }
         // ---------------
+        const setupCapabilities = async () => {
+            if (this.#cx.server.capabilities?.database) {
+                if (this.#cx.server.capabilities.database_dialect !== 'postgres') {
+                    throw new Error(`Only postgres supported for now for database dialect`);
+                }
+                if (this.#cx.env.entries[this.#cx.server.capabilities.database_url_variable]) {
+                    console.log('Database capabilities');
+                    const { SQLClient } = await import('@linked-db/linked-ql/sql');
+                    const { default: pg } = await import('pg');
+                    // Obtain pg client
+                    const pgClient = new pg.Pool({
+                        connectionString: this.#cx.env.entries[this.#cx.server.capabilities.database_url_variable],
+                        database: 'postgres',
+                    });
+                    // Connect
+                    await pgClient.connect();
+                    this.#sdk.db = new SQLClient(pgClient, { dialect: 'postgres' });
+                } else {
+                    console.log('No database capabilities');
+                    //const { ODBClient } = await import('@linked-db/linked-ql/odb');
+                    //this.#sdk.db = new ODBClient({ dialect: 'postgres' });
+                }
+            }
+            if (this.#cx.server.capabilities?.redis && this.#cx.env.entries[this.#cx.server.capabilities.redis_url_variable]) {
+                const { Redis } = await import('ioredis');
+                this.#sdk.redis = !this.#cx.env.entries[this.#cx.server.capabilities.redis_url_variable]
+                    ? new Redis : new Redis(this.#cx.env.entries[this.#cx.server.capabilities.redis_url_variable], {
+                        tls: { rejectUnauthorized: false }, // Required for Upstash
+                    });
+                console.log('Redis capabilities');
+            }
+            if (this.#cx.server.capabilities?.webpush) {
+                const { default: webpush } = await import('web-push');
+                console.log('Webpuah capabilities');
+                this.#sdk.webpush = webpush;
+                if (this.#cx.env.entries[this.#cx.server.capabilities.vapid_public_key_variable]
+                && this.#cx.env.entries[this.#cx.server.capabilities.vapid_private_key_variable]) {
+                    webpush.setVapidDetails(
+                        this.#cx.server.capabilities.vapid_subject,
+                        this.#cx.env.entries[this.#cx.server.capabilities.vapid_public_key_variable],
+                        this.#cx.env.entries[this.#cx.server.capabilities.vapid_private_key_variable]
+                    );
+                }
+            }
+        };
+        this.#capabilitiesPromise = setupCapabilities();
+        // ---------------
         this.control();
         if (this.#cx.logger) {
             if (this.#servers.size) {
@@ -179,6 +228,7 @@ export class WebfloServer extends WebfloRuntime {
 
     #globalMessagingRegistry = new Map;
     async handleNodeWsRequest(wss, nodeRequest, socket, head) {
+        await this.#capabilitiesPromise;
         const proto = this.getRequestProto(nodeRequest).replace('http', 'ws');
         const [fullUrl, requestInit] = this.parseNodeRequest(proto, nodeRequest, false);
         const scope = {};
@@ -239,6 +289,7 @@ export class WebfloServer extends WebfloRuntime {
     }
 
     async handleNodeHttpRequest(nodeRequest, nodeResponse) {
+        await this.#capabilitiesPromise;
         const proto = this.getRequestProto(nodeRequest);
         const [fullUrl, requestInit] = this.parseNodeRequest(proto, nodeRequest);
         const scope = {};
@@ -507,7 +558,13 @@ export class WebfloServer extends WebfloRuntime {
             : [];
         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.#cx.env.entries[this.#cx.server.session_key_variable] });
+        scope.session = this.constructor.SessionStorage.create(scope.request, {
+            secret: this.#cx.env.entries[this.#cx.server.session_key_variable],
+            registry: this.#sdk.redis && {
+                get: async (key) => { return await this.#sdk.redis.hgetall(key) },
+                set: async (key, value) => { return await this.#sdk.redis.hset(key, value) },
+            },
+        });
         const sessionID = scope.session.sessionID;
         if (!this.#globalMessagingRegistry.has(sessionID)) {
             this.#globalMessagingRegistry.set(sessionID, new ClientMessagingRegistry(this, sessionID));
@@ -526,22 +583,13 @@ export class WebfloServer extends WebfloRuntime {
             session: scope.session,
             user: scope.user,
             client: scope.clientMessaging,
-            sdk: { ...(this.#cx.server.capabilities?.webpush ? { webpush } : {}) }
+            sdk: this.#sdk
         });
-        if (this.#cx.server.capabilities?.webpush
-        && this.#cx.env.entries[this.#cx.server.capabilities.app_vapid_public_key_variable]
-        && this.#cx.env.entries[this.#cx.server.capabilities.app_vapid_private_key_variable]) {
-            webpush.setVapidDetails(
-                scope.url.origin.replace(/^http:/i, 'https:'),
-                this.#cx.env.entries[this.#cx.server.capabilities.app_vapid_public_key_variable],
-                this.#cx.env.entries[this.#cx.server.capabilities.app_vapid_private_key_variable]
-            );
-        }
         await this.setup(scope.httpEvent);
         // Restore session before dispatching
         if (scope.request.method === 'GET' 
         && (scope.redirectMessageID = scope.httpEvent.url.query['redirect-message'])
-        && (scope.redirectMessage = scope.session.get(`redirect-message:${scope.redirectMessageID}`))) {
+        && (scope.redirectMessage = await scope.session.get(`redirect-message:${scope.redirectMessageID}`))) {
             await scope.session.delete(`redirect-message:${scope.redirectMessageID}`);
         }
         // Dispatch for response