@webqit/webflo 0.11.61 → 0.20.2-next.0

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

@@ -0,0 +1,153 @@
+import { _isObject } from '@webqit/util/js/index.js';
+import { _even } from '@webqit/util/obj/index.js';
+
+export class HttpState {
+    
+    #store;
+    #request;
+    #session;
+    #modified = false;
+
+    constructor({ store, request, session = null }) {
+        this.#store = store || new Map;
+        this.#request = request;
+        this.#session = session === true ? this : session;
+    }
+
+    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 delete(key) {
+        await this.#store.delete(key);
+        this.#modified = true;
+        await this.emit(key);
+        return this;
+    }
+
+    async clear() {
+        await this.#store.clear();
+        this.#modified = true;
+        await this.emit();
+        return this;
+    }
+
+    async keys() { return [...await this.#store.keys()]; }
+
+    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 Object.fromEntries(await this.#store.entries());
+        }
+        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 forEach(callback) { (await this.entries()).forEach(([key, value], i) => callback(value, key, i)); }
+
+    [ Symbol.iterator ]() { return this.entries().then((entries) => entries[ Symbol.iterator ]()); }
+
+    get size() { return this.#store.sizs; }
+
+    async commit() {
+        this.#modified = false;
+    }
+
+    #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) {
+            if (arguments.length && $attr !== attr) continue;
+            if (arguments.length > 1) {
+                returnValues.push(handler(value));
+            } else {
+                returnValues.push(handler());
+            }
+        }
+        return Promise.all(returnValues);
+    }
+
+    #handlers = new Map;
+    defineHandler(attr, ...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?.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)`);
+            }
+            $handlers.push(handler);
+        }
+        this.#handlers.set(attr, $handlers);
+    }
+
+    getHandlers() { return this.#handlers; }
+
+    async require(attrs, callback = null, noNulls = false) {
+        const entries = [];
+        main: for await (const attr of [].concat(attrs)) {
+            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}`);
+                }
+                for (let i = 0; i < handlers.length; i ++) {
+                    const handler = handlers[i];
+                    if (handler.callback) {
+                        const returnValue = await handler.callback(this, attr);
+                        if (returnValue instanceof Response) {
+                            return returnValue;
+                        }
+                        if ((typeof returnValue === 'undefined' || (noNulls && returnValue === null)) && i < handlers.length - 1) {
+                            continue;
+                        }
+                        entries.push(returnValue);
+                        continue main;
+                    }
+                    const urlRewrite = new URL(handler.url, this.#request.url);
+                    if (!urlRewrite.searchParams.has('success-redirect')) {
+                        urlRewrite.searchParams.set('success-redirect', this.#request.url.replace(urlRewrite.origin, ''));
+                    }
+                    if (handler.message) {
+                        if (!this.#session) {
+                            throw new Error('Storage type does not support redirect messages');
+                        }
+                        const messageID = (0 | Math.random() * 9e6).toString(36);
+                        urlRewrite.searchParams.set('redirect-message', messageID);
+                        await this.#session.set(`redirect-message:${messageID}`, { status: { type: handler.type || 'info', message: handler.message }});
+                    }
+                    return new Response(null, { status: 302, headers: {
+                        Location: urlRewrite
+                    }});
+                }
+            }
+            entries.push(await this.get(attr));
+        }
+        if (callback) return await callback(...entries);
+        return entries;
+    }
+}

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

@@ -0,0 +1,54 @@
+import { HttpState } from './HttpState.js';
+
+export class HttpUser extends HttpState {
+
+    static create({ store, request, realtime, session }) {
+        return new this({ store, request, realtime, session });
+    }
+
+    #realtime;
+
+    constructor({ store, request, realtime, session }) {
+        super({
+            store,
+            request,
+            session
+        });
+        this.#realtime = realtime;
+    }
+
+    async isSignedIn() {
+        return await this.has('id');
+    }
+
+    async signIn(...args) {
+        return await this.require(
+            ['id'].concat(typeof args[0] === 'string' || Array.isArray(args[0]) ? args.unshift() : []),
+            ...args
+        );
+    }
+
+    async signOut() {
+        await this.clear();
+    }
+
+    async confirm(data, callback, options = {}) {
+        return await new Promise((resolve) => {
+            this.#realtime.postRequest(
+                data,
+                (event) => resolve(callback ? callback(event) : event),
+                { ...options, wqEventOptions: { type: 'confirm' } }
+            );
+        });
+    }
+
+    async prompt(data, callback, options = {}) {
+        return await new Promise((resolve) => {
+            this.#realtime.postRequest(
+                data,
+                (event) => resolve(callback ? callback(event) : event),
+                { ...options, wqEventOptions: { type: 'prompt' } }
+            );
+        });
+    }
+}

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

@@ -0,0 +1,245 @@
+import { State } from '@webqit/quantum-js';
+import { _isFunction, _isArray, _isObject } from '@webqit/util/js/index.js';
+import { _from as _arrFrom } from '@webqit/util/arr/index.js';
+import { path as Path } from '../webflo-url/util.js';
+import { isGenerator } from '../webflo-fetch/LiveResponse.js';
+
+export class WebfloRouter {
+
+    #runtime;
+    #path;
+
+    constructor(runtime, path = []) {
+        this.#runtime = runtime;
+        this.#path = _isArray(path) ? path : (path + '').split('/').filter(a => a);
+    }
+
+    async route(method, event, _default = null, remoteFetch = null) {
+        const $this = this;
+        // ----------------
+        // The loop
+        // ----------------
+        const next = async function (thisTick) {
+            const thisContext = {};
+            if (!thisTick.trail || thisTick.trail.length < thisTick.destination.length) {
+                thisTick = await $this.readTick(thisTick);
+                // -------------
+                thisContext.pathname = `/${thisTick.trail.join('/')}`;
+                thisContext.stepname = thisTick.trail[thisTick.trail.length - 1];
+                $this.finalizeHandlerContext(thisContext, thisTick);
+                // -------------
+                if (!thisTick.exports) {
+                    if ((thisTick.currentSegmentOnFile || {}).dirExists) {
+                        // Exports not found but directory found
+                        return next(thisTick);
+                    }
+                    // Exports not found and directory not found
+                    if (_default) {
+                        return await _default.call(thisContext, thisTick.event, remoteFetch);
+                    }
+                    return;
+                }
+                // -------------
+                // Broadcast any hints exported by handler
+                //@obsolete if (thisTick.exports.hints) { await event.port.post({ ...thisTick.exports.hints, $type: 'handler:hints' }); }
+                const methods = _arrFrom(thisTick.method).map(m => m === 'default' ? m : m.toUpperCase());
+                const handler = _isFunction(thisTick.exports) && methods.includes('default')
+                    ? thisTick.exports
+                    : methods.reduce((_handler, name) => _handler || thisTick.exports[name], null);
+                if (!handler) {
+                    // Handler not found but exports found
+                    return next(thisTick);
+                }
+                // -------------
+                // Handler found
+                // -------------
+                const go = async (isFetch, ...args) => {
+                    const nextTick = { ...thisTick };
+                    let asResponse = false;
+
+                    if (args.length) {
+
+                        // Obtain URL
+                        let url = args[0] instanceof Request ? args[0].url : (
+                            !isFetch && _isObject(args[0]) ? (
+                                args[0].redirect ?? thisTick.destination.slice(thisTick.trail.length).join('/')
+                            ) : args[0]
+                        );
+                        let urlStr_isRelative = false;
+                        let urlStr_resolved;
+
+                        // Normalize URL
+                        if (url instanceof URL) {
+                            urlStr_resolved = url.href;
+                        } else if (typeof url === 'string') {
+                            urlStr_resolved = url.trim();
+                            if (!/^http(s)?\:/i.test(urlStr_resolved) && !urlStr_resolved.startsWith('/')) {
+                                urlStr_resolved = $this.pathJoin(`/${thisTick.trail.join('/')}`, urlStr_resolved);
+                                if (urlStr_resolved.startsWith('../')) {
+                                    throw new Error('Router redirect cannot traverse beyond the routing directory! (' + url + ' >> ' + urlStr_resolved + ')');
+                                }
+                                urlStr_isRelative = true;
+                            }
+                            url = new URL(urlStr_resolved, thisTick.event.url.origin);
+                        } else {
+                            throw new Error('Router redirect url must be instance of URL or a string.');
+                        }
+
+                        // Handle absolute URLs
+                        if (url.origin !== thisTick.event.url.origin) {
+                            if (!isFetch) {
+                                throw new Error('The next() function cannot make outbound calls!');
+                            }
+                            const result = await remoteFetch(...args);
+                            if (asResponse) {
+                            }
+                            return result;
+                        }
+
+                        // Build request inheritance chain
+                        const requestInheritanceChain = [url];
+                        if (!isFetch && thisTick.event.request instanceof Request) {
+                            const { url: _, ...init } = await Request.copy(thisTick.event.request);
+                            requestInheritanceChain.push(init);
+                        }
+                        const noArg2 = () => {
+                            throw new Error('Invalid argument #2.');
+                        };
+                        if (args[0] instanceof Request) {
+                            if (args[1]) noArg2();
+                            const { url: _, ...init } = await Request.copy(args[0]);
+                            requestInheritanceChain.push(init);
+                        } else if (!isFetch && _isObject(args[0])) {
+                            if (args[1]) noArg2();
+                            if (_isObject(args[0].with)) {
+                                requestInheritanceChain.push(args[0].with);
+                            }
+                            asResponse = args[0].live;
+                        } else if (args[1] instanceof Request) {
+                            requestInheritanceChain.push(args[1]);
+                        } else if (_isObject(args[1])) {
+                            const { live, ...init } = args[1];
+                            requestInheritanceChain.push(init);
+                            asResponse = live;
+                        }
+
+                        // Compose new event parameters
+                        const request = requestInheritanceChain.reduce((prev, curr = {}) => new Request(prev, curr), requestInheritanceChain.shift());
+
+                        // Set context parameters
+                        nextTick.method = request.method;
+                        nextTick.event = await thisTick.event.extend({ request });
+                        nextTick.source = thisTick.destination.join('/');
+                        nextTick.destination = url.pathname.split('/').map((a) => a.trim()).filter((a) => a);
+                        nextTick.trail = !urlStr_isRelative ? [] : thisTick.trail.reduce((_commonRoot, _seg, i) => _commonRoot.length === i && _seg === nextTick.destination[i] ? _commonRoot.concat(_seg) : _commonRoot, []);
+                        nextTick.trailOnFile = thisTick.trailOnFile.slice(0, nextTick.trail.length);
+                    } else {
+                        if (isFetch) {
+                            throw new Error('fetch() cannot be called without arguments!');
+                        }
+                        nextTick.event = thisTick.event.extend();
+                    }
+                    const result = await next(nextTick);
+                    if (asResponse) {
+                    }
+                    return result;
+                };
+
+                // Prepare handler parameters
+                const nextPathname = thisTick.destination.slice(thisTick.trail.length);
+                const $next = async (...args) => await go(false, ...args);
+                $next.pathname = nextPathname.join('/');
+                $next.stepname = nextPathname[0];
+                const $fetch = async (...args) => await go(true, ...args);
+
+                // Dispatch to handler
+                return new Promise(async (resolve) => {
+                    let resolved = 0;
+
+                    // Monitor first respondWith()
+                    thisTick.event.internalLiveResponse.addEventListener('replace', () => {
+                        if (!resolved) {
+                            resolved = 1;
+                            resolve(thisTick.event.internalLiveResponse);
+                        } else if (resolved === 2) {
+                            throw new Error(`Unexpected respondWith() after handler return.`);
+                        }
+                    });
+
+                    // Call the handler
+                    const returnValue = await handler.call(thisContext, thisTick.event, $next/*next*/, $fetch/*fetch*/);
+
+                    // Handle cleanup on abort
+                    if (returnValue instanceof State) {
+                        thisTick.event.signal.addEventListener('abort', () => {
+                            returnValue.dispose();
+                        });
+                    } else if (isGenerator(returnValue)) {
+                        thisTick.event.signal.addEventListener('abort', () => {
+                            if (typeof returnValue.return === 'function') {
+                                returnValue.return();
+                            }
+                        });
+                    }
+
+                    // Handle return value
+                    if (!resolved) {
+                        resolved = 2;
+                        resolve(returnValue);
+                    } else if (typeof returnValue !== 'undefined') {
+                        await thisTick.event.internalLiveResponse.replaceWith(returnValue, { done: true });
+                    }
+                });
+            }
+            if (_default) {
+                return await _default.call(thisContext, thisTick.event, remoteFetch);
+            }
+        };
+
+        return next({
+            destination: this.#path,
+            event,
+            method
+        });
+
+    }
+
+    async readTick(thisTick) {
+        thisTick = { ...thisTick };
+        var routeTree = this.#runtime.routes;
+        var routePaths = Object.keys(this.#runtime.routes);
+        if (thisTick.trail) {
+            thisTick.currentSegment = thisTick.destination[thisTick.trail.length];
+            thisTick.currentSegmentOnFile = [thisTick.currentSegment, '-'].reduce((_segmentOnFile, _seg) => {
+                if (_segmentOnFile.handler) return _segmentOnFile;
+                var _currentPath = `/${thisTick.trailOnFile.concat(_seg).join('/')}`;
+                return routeTree[_currentPath] ? { seg: _seg, handler: _currentPath } : (
+                    routePaths.filter((p) => p.startsWith(`${_currentPath}/`)).length ? { seg: _seg, dirExists: true } : _segmentOnFile
+                );
+            }, { seg: null });
+            thisTick.trail = thisTick.trail.concat(thisTick.currentSegment);
+            thisTick.trailOnFile = thisTick.trailOnFile.concat(thisTick.currentSegmentOnFile.seg);
+            thisTick.exports = routeTree[thisTick.currentSegmentOnFile.handler];
+        } else {
+            thisTick.trail = [];
+            thisTick.trailOnFile = [];
+            thisTick.currentSegmentOnFile = { handler: '/' };
+            thisTick.exports = routeTree['/'];
+            if (!routeTree['/'] && routePaths.length) {
+                thisTick.currentSegmentOnFile.dirExists = true;
+            }
+        }
+        if (typeof thisTick.exports === 'string') {
+            thisTick.exports = await import(thisTick.exports);
+        }
+        return thisTick;
+    }
+
+    finalizeHandlerContext(context, thisTick) {
+        return context.dirname = thisTick.currentSegmentOnFile.handler;
+    }
+
+    pathJoin(...args) {
+        return Path.join(...args);
+    }
+}

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

@@ -0,0 +1,19 @@
+import { HttpCookies } from '../webflo-routing/HttpCookies.js';
+
+export class ServerSideCookies extends HttpCookies {
+    static create({ request }) {
+        return new this({
+            request,
+            entries: request.headers.get('Cookie', true).map((c) => [c.name, c])
+        });
+    }
+
+    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/webflo-server/ServerSideSession.js

@@ -0,0 +1,38 @@
+import { HttpSession } from '../webflo-routing/HttpSession.js';
+
+export class ServerSideSession extends HttpSession {
+
+    static create({ store, request, sessionID, ttl }) {
+        return new this({
+            store,
+            request,
+            sessionID,
+            ttl
+        });
+    }
+
+    #sessionID;
+    get sessionID() { return this.#sessionID; }
+    #ttl;
+    
+    constructor({ store, request, sessionID, ttl }) {
+        if (!sessionID) {
+            throw new Error(`sessionID is required`);
+        }
+        super({
+            store,
+            request,
+            session: true
+        });
+        this.#sessionID = sessionID;
+        this.#ttl = ttl;
+    }
+
+    async commit(response = null, devMode = false) {
+        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=/; ${!devMode ? 'Secure; ' : ''}HttpOnly; SameSite=Lax${this.#ttl ? `; Max-Age=${this.#ttl}` : ''}`);
+        }
+        await super.commit();
+    }
+}