@webqit/webflo 0.8.76 → 0.9.0

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

@@ -0,0 +1,102 @@
+
+/**
+ * imports
+ */
+import Fs from 'fs';
+import Path from 'path';
+import QueryString from 'querystring';
+import Router from './Router.js';
+
+export default class RuntimeClient {
+
+    /**
+     * RuntimeClient
+     * 
+     * @param Context cx
+     */
+    constructor(cx) {
+        this.cx = cx;
+        this.renderFileCache = {};
+    }
+
+    /**
+     * Handles navigation events.
+     * 
+     * @param NavigationEvent       httpEvent
+     * @param Function              remoteFetch
+     * 
+     * @return Response
+     */
+    async handle(httpEvent, remoteFetch) {
+        // The app router
+        const router = new Router(this.cx, httpEvent.url.pathname);
+        const handle = async () => {
+            // --------
+            // ROUTE FOR DATA
+            // --------
+            let httpMethodName = httpEvent.request.method.toLowerCase();
+            let response = await router.route([httpMethodName === 'delete' ? 'del' : httpMethodName, 'default'], httpEvent, {}, async event => {
+                return router.file(event);
+            }, remoteFetch);
+            if (!(response instanceof httpEvent.Response)) {
+                response = new httpEvent.Response(response);
+            }
+
+            // --------
+            // Rendering
+            // --------
+            if (response.ok && response.bodyAttrs.inputType === 'object' && httpEvent.request.headers.accept.match('text/html')) {
+                let rendering = await this.render(httpEvent, router, response);
+                if (typeof rendering !== 'string') {
+                    throw new Error('render() must return a window object or a string response.');
+                }
+                response = new httpEvent.Response(rendering, {
+                    status: response.status,
+                    headers: { ...response.headers.json(), contentType: 'text/html' },
+                });
+            }
+
+            return response;
+        };
+
+        // --------
+        // PIPE THROUGH MIDDLEWARES
+        // --------
+        return (this.cx.middlewares || []).concat(handle).reverse().reduce((next, fn) => {
+            return () => fn.call(this.cx, httpEvent, router, next);
+        }, null)();
+    }
+
+    // Renderer
+    async render(httpEvent, router, response) {
+        let data = await response.json();
+        return router.route('render', httpEvent, data, async (httpEvent, data) => {
+            var renderFile, pathnameSplit = httpEvent.url.pathname.split('/');
+            while ((renderFile = Path.join(this.cx.CWD, this.cx.layout.PUBLIC_DIR, './' + pathnameSplit.join('/'), 'index.html')) 
+            && (this.renderFileCache[renderFile] === false/* false on previous runs */ || !Fs.existsSync(renderFile))) {
+                this.renderFileCache[renderFile] = false;
+                pathnameSplit.pop();
+            }
+            const instanceParams = QueryString.stringify({
+                SOURCE: renderFile,
+                URL: httpEvent.url.href,
+                ROOT: this.cx.CWD,
+            });
+            const { window } = await import('@webqit/oohtml-ssr/instance.js?' + instanceParams);
+            // --------
+            // OOHTML would waiting for DOM-ready in order to be initialized
+            await new Promise(res => window.WebQit.DOM.ready(res));
+            await new Promise(res => (window.document.templatesReadyState === 'complete' && res(), window.document.addEventListener('templatesreadystatechange', res)));
+            if (!window.document.state.env) {
+                window.document.setState({
+                    env: 'server',
+                }, { update: true });
+            }
+            window.document.setState({ page: data, url: httpEvent.url }, { update: 'merge' });
+            window.document.body.setAttribute('template', 'page/' + httpEvent.url.pathname.split('/').filter(a => a).map(a => a + '+-').join('/'));
+            await new Promise(res => setTimeout(res, 10));
+            return window.print();
+        });
+    }
+
+}

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

@@ -0,0 +1,41 @@
+
+/**
+ * @imports
+ */
+import Context from './Context.js';
+import RuntimeClient from './RuntimeClient.js';
+import Runtime from './Runtime.js';
+
+/**
+ * @desc
+ */
+export const desc = {
+    config: {
+        headers: 'Configure automatic http headers.',
+        prerendering: 'Configure prerendering.',
+        redirects: 'Configure automatic redirects.',
+        server: 'Configure server settings.',
+        vhosts: 'Configure virtual hosts.',
+    },
+    start: 'Starts the Webflo server.',
+};
+
+/**
+ * @start
+ */
+export async function start(clientCallback = null) {
+    const cx = this || {};
+    const defaultClientCallback = _cx => new RuntimeClient(_cx);
+    return new Runtime(Context.create(cx), ( ...args ) => {
+        return clientCallback ? clientCallback( ...args.concat( defaultClientCallback ) ) : defaultClientCallback( ...args );
+    });
+}
+
+/**
+ * @exports
+ */
+export {
+    Context,
+    RuntimeClient,
+    Runtime,
+}

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

@@ -0,0 +1,35 @@
+
+/**
+ * @imports
+ */
+import { URL } from 'url';
+import { FormData, File, Blob } from 'formdata-node';
+import fetch, { Request, Response, Headers } from 'node-fetch';
+import { FormDataEncoder } from 'form-data-encoder';
+import { Readable } from "stream";
+
+/**
+ * The NavigationEvent class
+ */
+if (!Request.prototype.formData) {
+    Request.prototype.formData = async function() { return null }
+}
+if (!Response.prototype.formData) {
+    Response.prototype.formData = async function() { return null }
+}
+FormData.encode = formData => {
+    const encoder = new FormDataEncoder(formData);
+    return [ Readable.from(encoder.encode()), encoder.headers ];
+};
+
+export {
+    URL,
+    fetch,
+    Headers,
+    Request,
+    Response,
+    FormData,
+    Readable as ReadableStream,
+    File,
+    Blob,
+}

package/src/{runtime/_FormData.js → runtime-pi/xFormData.js}

@@ -9,7 +9,7 @@ import { wwwFormSet, wwwFormPathSerializeCallback } from './util.js';
  /**
   * The _Headers Mixin
   */
-const _FormData = NativeFormData => class extends NativeFormData {
+const xFormData = whatwagFormData => class extends whatwagFormData {
 
     tee(callback = null) {
         const formData1 = new this.constructor, formData2 = new this.constructor;
@@ -47,7 +47,7 @@ const _FormData = NativeFormData => class extends NativeFormData {
 
 }
 
-export default _FormData;
+export default xFormData;
 
 export const formDataType = (value, list = null) => {
     if (!_isTypeObject(value)) {

package/src/{runtime/_Headers.js → runtime-pi/xHeaders.js}

@@ -7,13 +7,13 @@ import { _isString, _getType, _isObject, _isFunction } from "@webqit/util/js/ind
 import { _isTypeObject } from '@webqit/util/js/index.js';
 
 /**
- * The _Headers Mixin
+ * The xHeaders Mixin
  */
-const _Headers = NativeHeaders => class extends NativeHeaders {
+const xHeaders = whatwagHeaders => class extends whatwagHeaders {
 
     // construct
     constructor(definition = {}) {
-        if (definition instanceof NativeHeaders) {
+        if (definition instanceof whatwagHeaders) {
             // It's another Headers instance
             super(definition);
         } else {
@@ -73,7 +73,7 @@ const _Headers = NativeHeaders => class extends NativeHeaders {
 
 }
 
-export default _Headers;
+export default xHeaders;
 
 function getAllPropertyDescriptors(obj) {
     if (!obj) {

package/src/runtime-pi/xHttpEvent.js

@@ -0,0 +1,93 @@
+
+/**
+ * @imports
+ */
+import { _isEmpty } from '@webqit/util/js/index.js';
+
+/**
+ * The xHttpEvent Mixin
+ */
+const xHttpEvent = (Request, Response, URL) => {
+
+    const HttpEvent = class {
+
+        /**
+         * Initializes a new HttpEvent instance.
+         * 
+         * @param Request       _request 
+         * @param Object        _detail
+         * @param Object        _sessionFactory
+         */
+        constructor(_request, _detail, _sessionFactory) {
+            this._request = _request;
+            this._detail = _detail || {};
+            this._sessionFactory = _sessionFactory;
+            // -------
+            this.Request = Request;
+            this.Response = Response;
+            this.URL = URL;
+            // -------
+            this.port = {
+                listeners: [],
+                post(message) { 
+                    const promises = this.listeners.map(listener => listener(message))
+                        .filter(returnValue => returnValue instanceof Promise);
+                    if (process.length) return Promise.all(promises);
+                },
+                listen(listener) { this.listeners.push(listener); },
+            }
+        }
+
+        // url
+        get url() {
+            if (!this._url) {
+                this._url = new this.URL(this._request.url);
+            }
+            return this._url;
+        }
+
+        // request
+        get request() {
+            return this._request;
+        }
+
+        // detail
+        get detail() {
+            return this._detail;
+        }
+
+        // Session
+        get session() {
+            if (!this._session) {
+                this._session = this.sessionFactory().get();
+            }
+            return this._session;
+        }
+
+        // Session factory
+        sessionFactory(...args) {
+            return this._sessionFactory(...args);
+        }
+
+        // RDR
+        retarget(url, init = {}) {
+            var request;
+            if (url instanceof Request) {
+                if (!_isEmpty(init)) {
+                    request = new Request(url, init);
+                } else {
+                    request = url;
+                }
+            } else {
+                request = new Request(this._request, init);
+                request.attrs.url = `${this.url.origin}${url}`;
+                request.attrs.referrer = this.request.url;
+            }            
+            return new HttpEvent(request, this.detail);
+        }
+
+    }
+    return HttpEvent;
+}
+
+export default xHttpEvent;

package/src/runtime-pi/xHttpMessage.js

@@ -0,0 +1,179 @@
+
+/**
+ * @imports
+ */
+import { _isArray, _isEmpty, _isNumber, _isObject, _isPlainArray, _isPlainObject, _isString } from '@webqit/util/js/index.js';
+import { formDataType } from './xFormData.js';
+
+/**
+ * The _Request Mixin
+ */
+const xHttpMessage = (whatwagHttpMessage, Headers, FormData) => {
+    const HttpMessage = class extends whatwagHttpMessage {
+        
+        constructor(input, init, bodyAttrs) {
+            if (('headers' in init) && !(init.headers instanceof Headers)) {
+                init = { ...init };
+                init.headers = new Headers(init.headers);
+                arguments[1] = init;
+            }
+            if (_isEmpty(init)) {
+                super(input);
+            } else {
+                super(input, init);
+            }
+            this._headers = init.headers;
+            if (bodyAttrs.headers) {
+                this.headers.json(bodyAttrs.headers);
+            }
+            let attrs = {};
+            Object.defineProperty(this, 'attrs', { get: () => attrs });
+            Object.defineProperty(this, 'bodyAttrs', { get: () => bodyAttrs });
+        }
+
+        clone() {
+            return new this.constructor(super.clone());
+        }
+
+        get headers() {
+            if (!this._headers) {
+                this._headers = new Headers(super.headers);
+            }
+            return this._headers;
+        }
+
+        get attrs() {
+            return this.attrs;
+        }
+
+        get url() {
+            return 'url' in this.attrs ? this.attrs.url : super.url;
+        }
+
+        async arrayBuffer() {
+            if (this.bodyAttrs.arrayBuffer) {
+                return this.bodyAttrs.arrayBuffer;
+            }
+            return super.arrayBuffer();
+        }
+
+        async blob() {
+            if (this.bodyAttrs.blob) {
+                return this.bodyAttrs.blob;
+            }
+            return super.blob();
+        }
+
+        async formData() {
+            if (this.bodyAttrs.formData) {
+                return this.bodyAttrs.formData;
+            }
+            const formData = await super.formData();
+            formData.tee = FormData.prototype.tee.bind(formData);
+            formData.json = FormData.prototype.json.bind(formData);
+            return formData;
+        }
+
+        async json() {
+            if (this.bodyAttrs.json) {
+                return this.bodyAttrs.json;
+            }
+            return super.json();
+        }
+
+        async text() {
+            if (this.bodyAttrs.text) {
+                return this.bodyAttrs.text;
+            }
+            return super.text();
+        }
+                
+        // Resolve
+        resolve(force = false) {
+            if (!this.bodyAttrs.resolved || force) {
+                this.bodyAttrs.resolved = new Promise(async (resolve, reject) => {
+                    var messageInstance = this, resolved, contentType = messageInstance.headers.get('content-type') || '';
+                    var type = contentType === 'application/json' || this.bodyAttrs.json ? 'json' : (
+                        contentType === 'application/x-www-form-urlencoded' || contentType.startsWith('multipart/') || this.bodyAttrs.formData ? 'formData' : (
+                            contentType === 'text/plain' ? 'plain' : 'other'
+                        )
+                    );
+                    try {
+                        if (type === 'formData') {
+                            resolved = (await messageInstance.formData()).json();
+                        } else {
+                            resolved = type === 'json' ? await messageInstance.json() : (
+                                type === 'plain' ? await messageInstance.text() : messageInstance.body
+                            );
+                        }
+                        resolve(resolved);
+                    } catch(e) {
+                        reject(e);
+                    }
+                });
+            }
+            return this.bodyAttrs.resolved;
+        }
+
+    };
+    // ----------
+    HttpMessage.Headers = Headers;
+    // ----------
+    return HttpMessage;
+}
+
+export default xHttpMessage;
+export function encodeBody(body, FormData) {
+    const detailsObj = { body, input: body };
+    const encodeFormData = (detailsObj, formData) => {
+        if (!FormData.encode) return;
+        let [ body, headers ] = FormData.encode(formData);
+        detailsObj.body = body;
+        detailsObj.headers = headers;
+    }
+    if (_isString(body) || _isNumber(body)) {
+        detailsObj.inputType = 'text';
+        detailsObj.text = body;
+        detailsObj.headers = {
+            contentLength: (body + '').length,
+        };
+        return detailsObj;
+    }
+    detailsObj.inputType = formDataType(body);
+    if ([ 'Blob', 'File' ].includes(detailsObj.inputType)) {
+        detailsObj.blob = body;
+        detailsObj.headers = {
+            contentType: body.type,
+            contentLength: body.size,
+        };
+    } else if ([ 'Uint8Array', 'Uint16Array', 'Uint32Array', 'ArrayBuffer' ].includes(detailsObj.inputType)) {
+        detailsObj.arrayBuffer = body;
+        detailsObj.headers = {
+            contentLength: body.byteLength,
+        };
+    } else if (detailsObj.inputType === 'FormData') {
+        detailsObj.formData = body;
+        encodeFormData(detailsObj, body);
+    } else if ((_isObject(body) && _isPlainObject(body)) || (_isArray(body) && _isPlainArray(body))) {
+        detailsObj.inputType = 'object';
+        // Deserialize object while detecting if multipart
+        var hasBlobs, formData = new FormData;
+        formData.json(body, (path, value, objectType) => {
+            hasBlobs = hasBlobs || objectType;
+            return true;
+        });
+        if (hasBlobs) {
+            detailsObj.formData = formData;
+            encodeFormData(detailsObj, formData);
+        } else {
+            detailsObj.json = body;
+            detailsObj.body = JSON.stringify(body);
+            detailsObj.headers = {
+                contentType: 'application/json',
+                contentLength: Buffer.byteLength(detailsObj.body, 'utf8'), // Buffer.from(string).length
+            };
+        }
+        detailsObj.resolved = body;
+    }
+    return detailsObj;
+}

package/src/runtime-pi/xRequest.js

@@ -0,0 +1,67 @@
+
+/**
+ * @imports
+ */
+import xHttpMessage, { encodeBody } from './xHttpMessage.js';
+
+/**
+ * The xRequest Mixin
+ */
+const xRequest = (whatwagRequest, Headers, FormData) => class extends xHttpMessage(whatwagRequest, Headers, FormData) {
+        
+    constructor(input, init = {}) {
+        init = { ...init };
+        let bodyAttrs = {};
+        if ((input instanceof whatwagRequest)) {
+            // On method change...
+            if (init.method && input.method !== init.method.toUpperCase() && [ 'GET', 'HEAD' ].includes(init.method.toUpperCase())) {
+                // Body must not be inherited.
+                input = input.url;
+                // We should now simply copy attributes
+                [ 'headers', 'mode', 'credentials', 'cache', 'redirect', 'referrer', 'integrity' ].forEach(attr => {
+                    if (!(attr in init)) {
+                        init[attr] = input[attr];
+                    }
+                });
+            } else {
+                // Inherit bodyAttrs
+                bodyAttrs = input.bodyAttrs || {};
+            }
+        }
+        // Init can contain "already-parsed request content"
+        if (('body' in init)) {
+            bodyAttrs = encodeBody(init.body, FormData);
+            init.body = bodyAttrs.body;
+        }
+        let isNavigateMode;
+        if (init.mode === 'navigate') {
+            isNavigateMode = true;
+            init = { ...init };
+            delete init.mode;
+        }
+        super(input, init, bodyAttrs);
+        if (isNavigateMode) {
+            // Through the backdoor
+            this.attrs.mode = 'navigate';
+        }
+    }
+
+    get mode() {
+        return 'mode' in this.attrs ? this.attrs.mode : super.mode;
+    }
+
+    get cache() {
+        return 'cache' in this.attrs ? this.attrs.cache : super.cache;
+    }
+
+    get destination() {
+        return 'destination' in this.attrs ? this.attrs.destination : super.destination;
+    }
+
+    get referrer() {
+        return 'referrer' in this.attrs ? this.attrs.referrer : super.referrer;
+    }
+
+};
+
+export default xRequest;

package/src/runtime-pi/xRequestHeaders.js

@@ -0,0 +1,95 @@
+
+/**
+ * @imports
+ */
+import { _after } from "@webqit/util/str/index.js";
+import { _from as _arrFrom } from "@webqit/util/arr/index.js";
+import { _getType, _isObject } from "@webqit/util/js/index.js";
+import { wwwFormUnserialize, wwwFormSerialize } from './util.js';
+import xHeaders from './xHeaders.js';
+
+/**
+ * The xHeaders Mixin
+ */
+const xRequestHeaders = NativeHeaders => class extends xHeaders(NativeHeaders) {
+
+    set accept(value) {
+        return this.set('Accept', value);
+    }
+
+    get accept() {
+        const accept = this.get('Accept');
+        const list = accept && accept.split(',').map(a => (a = a.trim().split(';').map(a => a.trim()), [a.shift(), parseFloat((a.pop() || '1').replace('q=', ''))]))
+            .sort((a, b) => a[1] > b[1] ? -1 : 1) || [];
+        return {
+            match(mime) {
+                mime = (mime + '').split('/');
+                return list.reduce((prev, entry) => prev || (
+                    (entry = entry[0].split('/')) && [0, 1].every(i => ((mime[i] === entry[i]) || mime[i] === '*' || entry[i] === '*'))
+                ), false);
+            },
+            toString() {
+                return accept;
+            }
+        };
+    }
+
+    set cookies(cookieJar) {
+        if (!_isObject(cookieJar)) {
+            throw new Error(`Cookies must be of type object. Received type: ${_getType(cookieJar)}.`);
+        }
+        this.set('Cookie', wwwFormSerialize(cookieJar, ';'));
+        this._cookies = null;
+        return true;
+    }
+
+    get cookies() {
+        if (!this._cookies) {
+            this._cookies = wwwFormUnserialize(this.get('cookie'), {}, ';');
+        }
+        return this._cookies;
+    }
+
+    set range(value) {
+        let rangeArr = [];
+        _arrFrom(value).forEach((range, i) => {
+            let rangeStr = Array.isArray(range) ? range.join('-') : range + '';
+            if (i === 0 && !rangeStr.includes('bytes=')) {
+                rangeStr = `bytes=${rangeStr}`;
+            }
+            rangeArr.push(rangeStr);
+        });
+        return this.set('Range', rangeArr.join(', '));
+    }
+
+    get range() {
+        const value = this.get('Range');
+        if (!value) return;
+        const rangeArr = _after(value, 'bytes=').split(',').map(rangeStr => {
+            let range = rangeStr.trim().split('-');
+            range[0] = range[0] ? parseInt(range[0], 10) : undefined;
+            if (range[1]) {
+                range[1] = parseInt(range[1], 10);
+            }
+            range.clamp = max => {
+                if (range[1] > max - 1 || range[1] === undefined) {
+                    range[1] = max - 1;
+                }
+                if (range[0] === undefined) range[0] = range[1] ? max - range[1] - 1 : 0;
+            };
+            return range;
+        });
+        return rangeArr;
+    }
+
+    set cors(value) {
+        return this.set('Access-Control-Allow-Origin', value === true ? '*' : (value === false ? '' : value));
+    }
+
+    get cors() {
+        return this.get('Access-Control-Allow-Origin');
+    }
+
+}
+
+export default xRequestHeaders;