@webqit/webflo 0.11.39 → 0.11.41

package/README.md

@@ -186,7 +186,7 @@ cd my-app
 
 With [npm available on your terminal](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm), run the following command to install Webflo to your project:
 
-> System Requirements: Node.js 14.0 or later
+> System Requirements: Node.js 18.0 (having stable Fetch API support) or later
 
 ```shell
 npm i @webqit/webflo

package/docker/Dockerfile

@@ -0,0 +1,43 @@
+# Base installations
+# (Node 18 is the minimum required version: stable Fetch API, etc)
+FROM node:18-alpine
+RUN apk add git
+RUN apk add certbot
+
+# Refer to https://www.digitalocean.com/community/tutorials/how-to-build-a-node-js-application-with-docker
+# By default, the Docker Node image includes a non-root node user that we can use to avoid running the application container as root.
+USER node
+
+# Create the working directory with node-user permissions
+RUN mkdir -p /home/node/www/app && chown -R node:node /home/node/www
+WORKDIR /home/node/www
+
+# Adding this COPY instruction before running npm install or copying the application code allows you to take advantage of Docker’s caching mechanism.
+COPY -chown=node:node package*.json ./
+
+# Install
+RUN npm install
+# If you are building your code for production
+# RUN npm ci --only=production
+
+# Copy application code with node-user permissions
+COPY --chown=node:node . .
+
+# Install Webflo and friends globally
+RUN npm install @webqit/webflo -g
+RUN npm install @webqit/oohtml-cli -g
+RUN npm install pm2 -g
+
+# The deployment directory
+WORKDIR /home/node/www/app
+
+# To auto-start app (flags optional), we would add...
+# CMD ["webflo", "start"]
+
+# To build the image locally...
+# docker build --no-cache -t webflo ./docker
+
+# To publish to docker hub...
+# docker login -u webqit
+# docker tag webflo webqit/webflo
+# docker push webqit/webflo

package/docker/README.md

@@ -0,0 +1,91 @@
+# Webflo Container
+
+This is simply a node.js container with the `@webqit/webflo` framework installed. Once started, any webflo app can be deployed into the container from any git repository.
+
+## Usage
+
+This container image lives on Docker Hub and can be pulled to a local machine or a remote Virtual Machine (VM) on any cloud platform.
+
++ [To Use Locally](#to-use-locally)
++ [To Use In the Cloud](#to-use-in-the-cloud)
+* [To Deploy An App From Any Repo](#to-deploy-an-app-from-any-repo)
+
+### To Use Locally
+
+Ensure you have docker installed on your computer and run the following command from any location on your terminal:
+
+```shell
+docker pull webqit/webflo:latest
+```
+
+The above command pulls the `webqit/webflo` image to your local machine. (But this can be automatically done by docker on running any docker commands that reference the `webqit/webflo` image.)
+
+Next is to use the following commands to start the container and the Webflo runtime. In each case, the first part of the command starts the container, while the second part (from `webflo start`) starts the application.
+
+#### To Start
+
+Start the container using `docker run`; map a port (e.g `80`) of your host machine to `3000` of the container; optionally, give your container a name; reference `webqit/webflo` as the image to use; and lastly, start webflo using `webflo start`.
+
+```shell
+docker run -d -p 80:3000 --name my-app webqit/webflo webflo start
+```
+
+> Unless a port has been explicitly set via `webflo config server`, webflo *HTTP* port defaults to `3000` or the value specified in an environmental variable named `PORT`. If a `PORT` variable has been defined, then port mapping above would now need to use that variable: `-p 80:${PORT}`.
+
+Visit [localhost](http://localhost) to view your app. 
+
+#### To Run In HTTPS Mode
+
+To run Webflo apps in HTTPS inside a container, you basically need to map the appropriate SSL port from the host machine to a custom port in the container.
+
+Below, we're now mapping port `443` to an application-level port defined as `${SSL_PORT}`.
+
+```shell
+docker run -d -p 80:${PORT} 443:${SSL_PORT} --name my-app webqit/webflo webflo start
+```
+
+> Unless an SSL port has been explicitly set via `webflo config server`, webflo *HTTPS* port defaults to `0` (no HTTPS) or the value specified in an environmental variable named `SSL_PORT`.
+
+If you will be managing your SSL certificates in the host machine, you would also need to *bind-mount* the appropriate certificate volume from the host to the container.
+
+Below, we're now mapping the directory `/etc/letsencrypt/` - the default location for `letsencrypt` certificates - to an equivalent directory in the container.
+
+```shell
+docker run -d -p 80:${PORT} 443:${SSL_PORT} -v /etc/letsencrypt/:/etc/letsencrypt/ --name my-app webqit/webflo webflo start
+```
+
+> Webflo lets you generate `letsencrypt` certificates with the `webflo generate:cert <domain1,domain2,etc>` command. Just be sure to have your app running in HTTP mode to enable the process handle certbot's `http` challenge.
+
+#### To Start In Dev Mode
+
+Webflo's *dev* mode is the perfect mode for developing locally. All you do is append the `--env=dev --watch` flags to your webflo commands. [(Learn more)](#)
+
+```shell
+docker run -d -p 80:3000 --name my-app webqit/webflo webflo start --env=dev --watch
+```
+
+In *dev* mode, webflo automatically restarts as you make changes to your codebase. But since webflo now lives inside a container, you'll need to *bind* the directory of your source code on your host machine to the `/home/node/www/app` directory of the container.
+
+```shell
+docker run -d -v /Users/me/my-app:/home/node/www/app -p 80:3000 --name my-app webqit/webflo webflo start --env=dev --watch
+```
+
+### To Use In the Cloud
+
+TODO
+
+### To Deploy An App From Any Repo
+
+Whether running locally or in the cloud, webflo can easily take your application from any git repo. This follows webflo's normal `deploy` command.
+
+Simply point docker at your container (using `docker exec [container-name]`) and execute the `webflo deploy` command.
+
+```shell
+docker exec my-app webflo deploy https://github.com/me/my-app.git
+```
+
+If you will need to install any npm dependencies, you would run `npm install` from within your container.
+
+```shell
+docker exec my-app npm install
+```

package/docker/package.json

@@ -0,0 +1,3 @@
+{
+    "name": "webqit/webflo-docker"
+}

package/package.json

@@ -12,7 +12,7 @@
     "vanila-javascript"
   ],
   "homepage": "https://webqit.io/tooling/webflo",
-  "version": "0.11.39",
+  "version": "0.11.41",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -37,7 +37,7 @@
   "dependencies": {
     "@octokit/webhooks": "^7.15.1",
     "@webqit/backpack": "^0.1.6",
-    "@webqit/oohtml-ssr": "^1.1.0",
+    "@webqit/oohtml-ssr": "^1.1.5",
     "@webqit/util": "^0.8.9",
     "client-sessions": "^0.8.0",
     "esbuild": "^0.14.38",
@@ -45,7 +45,6 @@
     "formdata-node": "^4.3.0",
     "formidable": "^2.0.1",
     "mime-types": "^2.1.33",
-    "node-fetch": "^2.6.1",
     "simple-git": "^2.20.1",
     "stream-slice": "^0.1.2",
     "urlpattern-polyfill": "^4.0.3"

package/src/Context.js

@@ -56,7 +56,7 @@ export default class Context {
     }
 
     set flags(value) {
-        this.dict.flags = value;
+        Object.defineProperty(this.dict, 'flags', { value } );
     }
 
     // layout
@@ -65,7 +65,7 @@ export default class Context {
     }
 
     set layout(value) {
-        this.dict.layout = value;
+        Object.defineProperty(this.dict, 'layout', { value } );
     }
 
     // logger
@@ -74,7 +74,7 @@ export default class Context {
     }
 
     set logger(value) {
-        this.dict.logger = value;
+        Object.defineProperty(this.dict, 'logger', { value } );
     }
 
 }

package/src/config-pi/deployment/Layout.js

@@ -19,7 +19,6 @@ export default class Layout extends Dotfile {
     // Defaults merger
     withDefaults(config) {
         return this.merge({
-            ROOT: process.cwd(),
             PUBLIC_DIR: './public',
             SERVER_DIR: './server',
             CLIENT_DIR: './client',

package/src/config-pi/deployment/Origins.js

@@ -31,6 +31,7 @@ export default class Origins extends Dotfile {
         return this.merge({
             entries: [{
                 host: hostname,
+                access_token: '',
                 repo: origin,
                 branch: 'master',
                 tag: 'root',
@@ -74,6 +75,12 @@ export default class Origins extends Dotfile {
                         choices: CHOICES.host,
                         validation: ['input', 'important'],
                     },
+                    {
+                        name: 'access_token',
+                        type: 'text',
+                        message: 'Enter your Personal Acess Token at host (if exists)',
+                        validation: ['input', 'important'],
+                    },
                     {
                         name: 'repo',
                         type: 'text',

package/src/config-pi/deployment/{Virtualization.js → Proxy.js}

@@ -4,16 +4,16 @@
  */
 import { Dotfile } from '@webqit/backpack';
 
-export default class Virtualization extends Dotfile {
+export default class Proxy extends Dotfile {
 
     // Base name
     get name() {
-        return 'virtualization';
+        return 'proxy';
     }
 
     // @desc
     static get ['@desc']() {
-        return 'Layout virtualization config.';
+        return 'Layout proxy config.';
     }
 
     // Defaults merger

package/src/config-pi/deployment/index.js

@@ -5,7 +5,7 @@
 import Env from './Env.js';
 import Layout from  './Layout.js';
 import Origins from  './Origins.js';
-import Virtualization from  './Virtualization.js';
+import Proxy from  './Proxy.js';
 
 /**
  * @exports
@@ -14,5 +14,5 @@ export {
     Env,
     Layout,
     Origins,
-    Virtualization,
+    Proxy,
 }

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

@@ -19,10 +19,10 @@ export default class Server extends Dotfile {
     // Defaults merger
     withDefaults(config) {
         return this.merge({
-            port: process.env.port || 3000,
+            port: process.env.PORT || 3000,
             domains: [],
             https: {
-                port: 0,
+                port: process.env.SSL_PORT || 0,
                 domains: [],
                 keyfile: '/etc/letsencrypt/live/[domain]/privkey.pem',
                 certfile: '/etc/letsencrypt/live/[domain]/fullchain.pem',

package/src/deployment-pi/origins/index.js

@@ -55,6 +55,7 @@ export async function deploy(origin) {
         }
     }
     // ---------------
+    const accessToken = origin.access_token;
     const isDeployPathSet = origin.deploy_path;
     origin.deploy_path = Path.join(cx.CWD || '', origin.deploy_path || '.');
     // ---------------
@@ -72,8 +73,8 @@ export async function deploy(origin) {
     await git.init();
 
     const hosts = {
-        github: 'https://github.com',
-        bitbucket: 'https://bitbucket.org',
+        github: `https://${ accessToken ? accessToken + '@' : '' }github.com`,
+        bitbucket: `https://${ accessToken ? accessToken + '@' : '' }bitbucket.org`,
     };
     const url = origin.url || hosts[origin.host] + '/' + origin.repo + '.git';
 

package/src/runtime-pi/{RuntimeClient.js → Application.js}

@@ -1,11 +1,11 @@
 
 /**
  * ---------------------------
- * The base RuntimeClient class
+ * The base Application class
  * ---------------------------
  */
             
-export default class RuntimeClient {
+export default class Application {
 
     constructor(cx) {
         this.cx = cx;

package/src/runtime-pi/HttpEvent.js

@@ -0,0 +1,106 @@
+
+/**
+ * @imports
+ */
+import { _isEmpty } from '@webqit/util/js/index.js';
+import xRequest from "./xRequest.js";
+import xResponse from "./xResponse.js";
+import xURL from "./xURL.js";
+
+/**
+ * The xHttpEvent Mixin
+ */
+export default class HttpEvent {
+
+    /**
+     * Initializes a new HttpEvent instance.
+     * 
+     * @param Request       _request 
+     * @param Object        _detail
+     * @param Function      _sessionFactory
+     * @param Function      _storageFactory
+     */
+    constructor(_request, _detail, _sessionFactory, _storageFactory) {
+        this._request = _request;
+        this._detail = _detail || {};
+        this._sessionFactory = _sessionFactory;
+        this._storageFactory = _storageFactory;
+        // -------
+        this.Request = xRequest;
+        this.Response = xResponse;
+        this.URL = xURL;
+        // -------
+        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();
+        }
+        return this._session;
+    }
+
+    // Storage
+    get storage() {
+        if (!this._storage) {
+            this._storage = this.storageFactory();
+        }
+        return this._storage;
+    }
+
+    // Session factory
+    sessionFactory(...args) {
+        return this._sessionFactory(...args);
+    }
+    
+    // storage factory
+    storageFactory(...args) {
+        return this._storageFactory(...args);
+    }
+
+    // Redirect Response
+    redirect(url, code = 302) {
+        return new this.Response(null, { status: code, headers: { Location: url } });
+    }
+
+    // "with()"
+    with(url, init = {}) {
+        let request;
+        if (url instanceof Request) {
+            request = !_isEmpty(init) ? new xRequest(url, init) : url;
+        } else {
+            url = new this.URL(url, this.url.origin);
+            request = new xRequest(url, this._request);
+            request = new xRequest(request, { ...init, referrer: this.request.url });
+        }            
+        return new HttpEvent(request, this.detail, this._sessionFactory, this.storageFactory);
+    }
+
+}

package/src/runtime-pi/Router.js

@@ -58,7 +58,7 @@ export default class Router {
                 if (thisTick.exports) {
                     // Broadcast any hints exported by handler
                     if (thisTick.exports.hints) { await event.port.post({ ...thisTick.exports.hints, $type: 'handler:hints' }); }
-                    const methods = _arrFrom(thisTick.method);
+                    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) {
                         // -------------
@@ -74,7 +74,7 @@ export default class Router {
                                 } else if (!_isString(_url)) {
                                     throw new Error('Router redirect url must be a string!');
                                 }
-                                var newDestination = _url.startsWith('/') ? _url : $this.pathJoin(`/${thisTick.trail.join('/')}`, _url);
+                                let newDestination = _url.startsWith('/') ? _url : $this.pathJoin(`/${thisTick.trail.join('/')}`, _url);
                                 if (newDestination.startsWith('../')) {
                                     throw new Error('Router redirect cannot traverse beyond the routing directory! (' + _url + ' >> ' + newDestination + ')');
                                 }
@@ -89,7 +89,6 @@ export default class Router {
                                 } else {
                                     nextTick.event = thisTick.event.with(newDestination, requestInit);
                                 }
-                                
                                 nextTick.source = thisTick.destination.join('/');
                                 nextTick.destination = newDestination.split('?').shift().split('/').map(a => a.trim()).filter(a => a);
                                 nextTick.trail = _args[1].startsWith('/') ? [] : thisTick.trail.reduce((_commonRoot, _seg, i) => _commonRoot.length === i && _seg === nextTick.destination[i] ? _commonRoot.concat(_seg) : _commonRoot, []);

package/src/runtime-pi/Runtime.js

@@ -12,10 +12,10 @@ import { _isFunction } from "@webqit/util/js/index.js";
  */
             
 export default class Runtime {
-    constructor(cx, client) {
+    constructor(cx, applicationInstance) {
         this.cx = cx;
         this.cx.runtime = this;
-        this.client = _isFunction(client) ? client(this.cx) : client;
-        if (!this.client || !this.client.handle) throw new Error(`Application instance must define a ".handle()" method.`);
+        this.app = _isFunction(applicationInstance) ? applicationInstance(this.cx) : applicationInstance;
+        if (!this.app || !this.app.handle) throw new Error(`Application instance must define a ".handle()" method.`);
     }
 }

package/src/runtime-pi/client/{RuntimeClient.js → Application.js}

@@ -3,9 +3,9 @@
  * @imports
  */
 import Router from './Router.js';
-import _RuntimeClient from '../RuntimeClient.js';
+import _Application from '../Application.js';
 
-export default class RuntimeClient extends _RuntimeClient {
+export default class Application extends _Application {
 
 	// Returns router class
 	get Router() {
@@ -27,8 +27,16 @@ export default class RuntimeClient extends _RuntimeClient {
 			// --------
 			// ROUTE FOR DATA
 			// --------
-			const httpMethodName = httpEvent.request.method.toUpperCase();
-			return router.route([httpMethodName, 'default'], httpEvent, {}, async event => {
+			return router.route([httpEvent.request.method, 'default'], httpEvent, { ...( document.state?.data || {} ) }, async event => {
+				if (event !== httpEvent) {
+					// This was nexted()
+					if (!event.request.headers.has('Accept')) {
+						event.request.headers.set('Accept', 'application/json');
+					}
+					if (event.request.body && !event.request.headers.has('Content-Type')) {
+						event.request.headers.set('Content-Type', 'application/json');
+					}
+				}
 				return remoteFetch(event.request);
 			}, remoteFetch);
 		};

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

@@ -2,7 +2,7 @@
 /**
  * @imports
  */
-import { path as Path } from '../util.js';
+import { path as Path } from '../util-url.js';
 import _Router from '../Router.js';
 
 /**
@@ -14,6 +14,7 @@ import _Router from '../Router.js';
 export default class Router extends _Router {
 
     async readTick(thisTick) {
+        thisTick = { ...thisTick };
         var routeTree = this.cx.layout;
         var routePaths = Object.keys(this.cx.layout);
         if (thisTick.trail) {
@@ -25,8 +26,8 @@ export default class Router extends _Router {
                     routePaths.filter(p => p.startsWith(`${_currentPath}/`)).length ? { seg: _seg, dirExists: true } : _segmentOnFile
                 );
             }, { seg: null });
-            thisTick.trail.push(thisTick.currentSegment);
-            thisTick.trailOnFile.push(thisTick.currentSegmentOnFile.seg);
+            thisTick.trail = thisTick.trail.concat(thisTick.currentSegment);
+            thisTick.trailOnFile = thisTick.trailOnFile.concat(thisTick.currentSegmentOnFile.seg);
             thisTick.exports = routeTree[thisTick.currentSegmentOnFile.index];
         } else {
             thisTick.trail = [];