@webqit/webflo 0.8.75 → 0.9.0-0

package/package.json

@@ -12,7 +12,7 @@
     "vanila-javascript"
   ],
   "homepage": "https://webqit.io/tooling/webflo",
-  "version": "0.8.75",
+  "version": "0.9.0-0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,6 +24,8 @@
   "type": "module",
   "main": "./src/index.js",
   "scripts": {
+    "test": "mocha --extension .test.js --exit",
+    "test:coverage": "c8 --reporter=text-lcov npm run test | coveralls",
     "postversion": "npm publish",
     "postpublish": "git push && git push --tags"
   },
@@ -33,16 +35,11 @@
     "webflo-certbot-http-cleanup-hook": "src/services/certbot/http-cleanup-hook.js"
   },
   "dependencies": {
-    "@octokit/auth-basic": "^1.4.6",
-    "@octokit/rest": "^17.11.2",
     "@octokit/webhooks": "^7.15.1",
     "@webqit/backpack": "^0.0.37",
-    "@webqit/browser-pie": "^0.0.16",
-    "@webqit/observer": "^1.7.5",
-    "@webqit/pseudo-browser": "^1.0.0",
-    "@webqit/util": "^0.8.7",
+    "@webqit/oohtml-ssr": "^1.0.2",
+    "@webqit/util": "^0.8.9",
     "client-sessions": "^0.8.0",
-    "cookie": "^0.4.1",
     "form-data-encoder": "^1.6.0",
     "formdata-node": "^4.3.0",
     "formidable": "^2.0.0-dev.20200131.2",
@@ -51,12 +48,8 @@
     "mime-types": "^2.1.33",
     "minimatch": "^3.0.4",
     "node-fetch": "^2.6.1",
-    "pm2": "^5.2.0",
     "simple-git": "^2.20.1",
     "stream-slice": "^0.1.2",
-    "touch": "^3.1.0",
-    "undici": "^4.3.1",
-    "uuid": "^8.3.2",
     "webpack": "^5.50.0"
   },
   "author": "Oxford Harrison <oxharris.dev@gmail.com>",

package/src/Cli.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+/**
+ * @imports
+ */
+import { _toTitle } from '@webqit/util/str/index.js';
+import { _merge, _set, _get } from '@webqit/util/obj/index.js';
+import { _isClass, _isFunction, _isObject, _isEmpty, _isString } from '@webqit/util/js/index.js';
+import { Promptx } from '@webqit/backpack/src/cli/Promptx.js';
+import parseArgs from '@webqit/backpack/src/cli/parseArgs.js';
+
+export default class Cli {
+
+    /**
+     * @constructor
+     * 
+     * @param Object api 
+     */
+    constructor(api) {
+        this.api = api;
+        this.nsSeparator = '::';
+        // Generate available options
+        this.availableConfigs = {};
+        this.availableCommands = {};
+        const discoverConfigs = (namespace, piObj) => Object.keys(piObj).forEach(name => {
+            let pathname = `${name}${this.nsSeparator}${namespace}`.toLowerCase();
+            if (_isClass(piObj[name])) {
+                if (piObj[name]['@desc']) this.availableConfigs[pathname] = piObj[name]['@desc'];
+            } else if (_isObject(piObj[name])) discoverConfigs(pathname, piObj[name]);
+        });
+        const discoverCommands = (namespace, piObj) => Object.keys(piObj).forEach(name => {
+            let pathname = `${name}${this.nsSeparator}${namespace}`.toLowerCase();
+            if (!_isClass(piObj[name]) && _isFunction(piObj[name])) {
+                if (!piObj[name]['@desc']) this.availableCommands[pathname] = piObj[name]['@desc'];
+            } else if (_isObject(piObj[name])) discoverCommands(pathname, piObj[name]);
+        });
+        Object.keys(this.api).forEach(name => {
+            if (name === 'config') discoverConfigs(name, this.api[name]);
+            else discoverCommands(name, this.api[name]);
+        });
+    }
+
+    /**
+     * @exec
+     */
+    async exec(cx) {
+        const { command, keywords, flags, options, ellipsis } = parseArgs(process.argv);
+        cx.flags = flags;
+        // ------------
+        if (cx.webflo.version) {
+            cx.logger.log('');
+            cx.logger.banner(cx.webflo.title, cx.webflo.version || '');
+            cx.logger.log('');
+        }
+        // ------------
+        if (command === 'help') {
+            cx.logger.title(`> COMMAND LINE HELP`);
+            cx.logger.log('');
+            // ------------
+            cx.logger.log(cx.logger.f`Say "webflo <${'command'}>"`);
+            cx.logger.log(cx.logger.f`Where <${'command'}> is one of:`);
+            cx.logger.log(cx.logger.f`${this.availableCommands}`);
+            cx.logger.log('');
+            // ------------
+            cx.logger.log(cx.logger.f`Or say "webflo config", or "webflo config <${'path'}>"`);
+            cx.logger.log(cx.logger.f`Where <${'path'}> is one of:`);
+            cx.logger.log(cx.logger.f`${this.availableConfigs}`);
+            cx.logger.log('');
+            // ------------
+            cx.logger.log(cx.logger.f`You may also refer to the Webflo DOCS as ${'https://webqit.io/tooling/webflo'}`);
+            return;
+        }
+        // ------------
+        const keywordList = Object.keys(keywords);
+        const fcn = keywordList[0];
+        const resolveIdentifier = (fcn, isConfig) => {
+            let namespaceObj = isConfig ? this.availableConfigs : this.availableCommands;
+            let matches = Object.keys(namespaceObj).filter(path => `${path}${this.nsSeparator}`.startsWith(`${fcn}${this.nsSeparator}`));
+            if (matches.length === 1) {
+                return matches[0];
+            }
+            return matches;
+        };
+        const pathNisplayName = path => path.split(this.nsSeparator).slice(0, -1).join(this.nsSeparator);
+        const promptIdentifier = async (preselection, isConfig) => {
+            let namespaceObj = isConfig ? this.availableConfigs : this.availableCommands;
+            let selection = await Promptx({
+                name: 'fcn',
+                type: 'select',
+                choices: (!_isEmpty(preselection) ? preselection : Object.keys(namespaceObj)).map(path => ({ value: path, title: pathNisplayName(path) })).concat({ value: '<' }),
+                message: 'Please select a function to continue, or "<" to exit',
+            }).then(d => d.fcn);
+            if (selection === '<') process.exit();
+            return selection;
+        };
+        // ------------
+        let isConfig = command === 'config', _fcn = isConfig ? fcn : command, resolvedFcn;
+        if (!(_fcn && _isString(resolvedFcn = resolveIdentifier(_fcn, isConfig))) || ellipsis) {
+            cx.logger.title(`> webflo ${isConfig ? 'config ' : ''}${_fcn || ''}...`);
+            cx.logger.log('');
+            resolvedFcn = await promptIdentifier(resolvedFcn, isConfig);
+        }
+        cx.logger.title(`> webflo ${isConfig ? 'config ' : ''}${pathNisplayName(resolvedFcn)}`);
+        cx.logger.log('');
+        // ------------
+        // Process command
+        if (isConfig) {
+            const configClass = _get(this.api, _toTitle(resolvedFcn).split(this.nsSeparator).reverse());
+            const configurator = new configClass(cx);
+            const config = await configurator.read();
+            const givenOptionsList = Object.keys(options);
+            if (givenOptionsList.length) {
+                const optionsStructured = {};
+                givenOptionsList.forEach(path => {
+                    _set(optionsStructured, path.split('.'), options[path]);
+                });
+                await configurator.write(_merge(true, config, optionsStructured));
+            } else {
+                await Promptx(configurator.questions(config)).then(async _config => {
+                    await configurator.write(_merge(true, config, _config));
+                });
+            }
+        } else {
+            const func = _get(this.api, resolvedFcn.split(this.nsSeparator).reverse());
+            await func.call(cx, ...keywordList);
+        }
+
+        cx.logger.log('');
+    }
+
+}

package/src/Configurator.js

@@ -0,0 +1,97 @@
+
+/**
+ * @imports
+ */
+import Path from 'path';
+import { _merge } from '@webqit/util/obj/index.js';
+import { initialGetIndex } from '@webqit/backpack/src/cli/Promptx.js';
+import { DotJson, DotEnv, anyExists } from '@webqit/backpack/src/dotfiles/index.js';
+
+/**
+ * @exports
+ */
+export default class Configurator {
+
+    /**
+     * The default initializer.
+     * 
+     * @param Context cx
+     */
+    constructor(cx) {
+        this.cx = cx;
+        this.givenExt = this.cx.flags.mode ? `.${this.cx.flags.mode}` : '';
+        this.availableExt = anyExists([ this.givenExt, '', '.example' ], ext => this.resolveFileName(ext));
+        if (this.isEnv) {
+            this.availableEnvExt = anyExists([ this.givenExt, '', '.example' ], ext => this.resolveEnvFileName(ext));
+        }
+    }
+
+    // ------------
+
+    get configDir() {
+        return Path.join(this.cx.CWD || ``, `./.webqit/webflo/config/`);
+    }
+
+    get envDir() {
+        return Path.resolve(this.cx.CWD || '');
+    }
+
+    // ------------
+
+    static read(...args) {
+        let instance = new this(...args);
+        return instance.read();
+    }
+
+
+    static write(config, ...args) {
+        let instance = new this(...args);
+        return instance.write(config);
+    }
+
+    // ------------
+
+    async read() {
+        let config = DotJson.read(this.resolveFileName(this.availableExt));
+        if (this.isEnv) {
+            let config2 = { entries: DotEnv.read(this.resolveEnvFileName(this.availableEnvExt)) || {}, };
+            // The rewrite below is because entries should not also appear in json
+            //config.entries = _merge(config.entries || {}, config2.entries);
+            config = _merge(config, config2);
+        }
+        return this.withDefaults(config);
+    }
+
+    async write(config) {
+        if (this.isEnv) {
+            config = { ...config };
+            DotEnv.write(config.entries, this.resolveEnvFileName(this.givenExt));
+            // The delete below is because entries should not also appear in json
+            delete config.entries;
+        }
+        DotJson.write(config, this.resolveFileName(this.givenExt));
+    }
+
+    questions() {
+        return [];
+    }
+
+    // ------------
+
+    resolveFileName(ext) {
+        return `${this.configDir}/${this.name}${ext}.json`;
+    }
+
+    resolveEnvFileName(ext) {
+        return `${this.envDir}/.${this.name}${ext}`;
+    }
+
+    withDefaults(config) {
+        return config;
+    }
+
+    indexOfInitial(options, initial) {
+        return initialGetIndex(options, initial);
+    }
+
+}

package/src/Context.js

@@ -0,0 +1,76 @@
+
+export default class Context {
+
+    /**
+     * Initializes a context.
+     * 
+     * @param Object  dict 
+     * @param String  CD 
+     */
+    constructor(dict, CD = null) {
+        // dict can be plain object or some Context instance itself
+        // Using it as only a prototype protects it from being mutated down here
+        Object.defineProperty(this, 'dict', { value: Object.create(dict), });
+        // Now, for enumerable props thet need to be enumerable, where no getter/setter on both instances
+        for (let prop in this.dict) {
+            if (prop in this) continue;
+            this[prop] = this.dict[prop];
+        }
+        if (arguments.length > 1) {
+            this.dict.CWD = CD;
+        }
+    }
+
+    // create
+    static create(...args) {
+        return new this(...args);
+    }
+
+    // CWD
+    get CWD() {
+        return this.dict.CWD || '';
+    }
+
+    // webflo
+    get webflo() {
+        return this.dict.webflo || {};
+    }
+
+    // app
+    get app() {
+        return this.dict.app || {};
+    }
+
+    // config
+    get config() {
+        return this.dict.config || {};
+    }
+
+    // flags
+    get flags() {
+        return this.dict.flags || {};
+    }
+
+    set flags(value) {
+        this.dict.flags = value;
+    }
+
+    // layout
+    get layout() {
+        return this.dict.layout || {};
+    }
+
+    set layout(value) {
+        this.dict.layout = value;
+    }
+
+    // logger
+    get logger() {
+        return this.dict.logger;
+    }
+
+    set logger(value) {
+        this.dict.logger = value;
+    }
+
+}

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

@@ -0,0 +1,69 @@
+
+/**
+ * imports
+ */
+import { _merge } from '@webqit/util/obj/index.js';
+import Configurator from '../../Configurator.js';
+
+export default class Env extends Configurator {
+
+    // Base name
+    get name() {
+        return 'env';
+    }
+
+    // @desc
+    static get ['@desc']() {
+        return 'Environmental variables config.';
+    }
+
+    // isEnv
+    get isEnv() {
+        return true;
+    }
+
+    // Defaults merger
+    withDefaults(config) {
+        return _merge({
+            autoload: true,
+        }, config);
+    }
+
+    // Questions generator
+    questions(config, choices = {}) {
+        // Questions
+        return [
+            {
+                name: 'entries',
+                type: 'recursive',
+                controls: {
+                    name: 'variable',
+                    combomode: true,
+                },
+                initial: config.entries,
+                questions: [
+                    {
+                        name: 'name',
+                        type: 'text',
+                        message: 'Name',
+                        validation: ['important'],
+                    },
+                    {
+                        name: 'value',
+                        type: 'text',
+                        message: 'Value',
+                        validation: ['important'],
+                    },
+                ],
+            },
+            {
+                name: 'autoload',
+                type: 'toggle',
+                message: 'Choose whether to autoload variables into "process.env"',
+                active: 'YES',
+                inactive: 'NO',
+                initial: config.autoload,
+            },
+        ];
+    }
+}

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

@@ -0,0 +1,65 @@
+
+/**
+ * imports
+ */
+import { _merge } from '@webqit/util/obj/index.js';
+import Configurator from '../../Configurator.js';
+
+export default class Layout extends Configurator {
+
+    // Base name
+    get name() {
+        return 'layout';
+    }
+
+    // @desc
+    static get ['@desc']() {
+        return 'Project layout config.';
+    }
+
+    // Defaults merger
+    withDefaults(config) {
+        return _merge({
+            ROOT: process.cwd(),
+            PUBLIC_DIR: './public',
+            SERVER_DIR: './server',
+            CLIENT_DIR: './client',
+            WORKER_DIR: './worker',
+        }, config);
+    }
+
+    // Questions generator
+    questions(config, choices = {}) {
+        // Questions
+        return [
+            {
+                name: 'PUBLIC_DIR',
+                type: 'text',
+                message: 'Enter the application\'s public directory',
+                initial: config.PUBLIC_DIR,
+                validation: ['important'],
+            },
+            {
+                name: 'SERVER_DIR',
+                type: 'text',
+                message: 'Enter the directory for the application\'s server-side route handlers',
+                initial: config.SERVER_DIR,
+                validation: ['important'],
+            },
+            {
+                name: 'CLIENT_DIR',
+                type: 'text',
+                message: 'Enter the directory for the application\'s client-side route handlers',
+                initial: config.CLIENT_DIR,
+                validation: ['important'],
+            },
+            {
+                name: 'WORKER_DIR',
+                type: 'text',
+                message: 'Enter the directory for the application\'s offline route handlers',
+                initial: config.WORKER_DIR,
+                validation: ['important'],
+            },
+        ];
+    }
+}

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

@@ -0,0 +1,133 @@
+
+/**
+ * imports
+ */
+import Url from 'url';
+import { _merge } from '@webqit/util/obj/index.js';
+import { _before } from '@webqit/util/str/index.js';
+import { _isObject, _isTypeObject } from '@webqit/util/js/index.js';
+import Configurator from '../../Configurator.js';
+
+export default class Origins extends Configurator {
+
+    // Base name
+    get name() {
+        return 'origins';
+    }
+
+    // @desc
+    static get ['@desc']() {
+        return 'Remote origins config.';
+    }
+
+    // Defaults merger
+    withDefaults(config) {
+        let hostname = '', origin = '';
+        if (this.cx.PKG && this.cx.PKG.repository) {
+            var inferredRepo = Url.parse(_isTypeObject(this.cx.PKG.repository) ? this.cx.PKG.repository.url : this.cx.PKG.repository);
+            hostname = _before(inferredRepo.hostname, '.');
+            origin = _before(inferredRepo.pathname, '.');
+        }
+        // Params
+        return _merge({
+            entries: [{
+                host: hostname,
+                repo: origin,
+                branch: 'master',
+                tag: 'root',
+                deploy_path: '.',
+                autodeploy: true,
+                autodeploy_secret: '',
+                ondeploy: 'npm install',
+                ondeploy_autoexit: true,
+            }],
+        }, config);
+    }
+
+    // Match
+    async match(url) {
+        return ((await this.read()).entries || []).filter(_origin => _origin.tag.toLowerCase() === url.toLowerCase() || _origin.repo.toLowerCase() === url.toLowerCase());
+    }
+
+    // Questions generator
+    questions(config, choices = {}) {
+        // Choices
+        const CHOICES = _merge({
+            host: [
+                {value: 'github',},
+                {value: 'bitbucket',},
+            ],
+        }, choices);
+        // Questions
+        return [
+            {
+                name: 'entries',
+                type: 'recursive',
+                controls: {
+                    name: 'repository',
+                },
+                initial: config.entries,
+                questions: [
+                    {
+                        name: 'host',
+                        type: 'select',
+                        message: 'Host name',
+                        choices: CHOICES.host,
+                        validation: ['input', 'important'],
+                    },
+                    {
+                        name: 'repo',
+                        type: 'text',
+                        message: 'Enter a repository name (in the format: user-or-org/origin)',
+                        validation: ['input', 'important'],
+                    },
+                    {
+                        name: 'branch',
+                        type: 'text',
+                        message: 'Specifiy the git branch within the given repository',
+                        validation: ['input', 'important'],
+                    },
+                    {
+                        name: 'tag',
+                        type: 'text',
+                        message: 'Enter a local name for this origin',
+                        validation: ['input', 'important'],
+                    },
+                    {
+                        name: 'deploy_path',
+                        type: 'text',
+                        message: 'Enter the relative local path that this origin deploys to',
+                        validation: ['important'],
+                    },
+                    {
+                        name: 'autodeploy',
+                        type: 'toggle',
+                        message: 'Auto-deploy this origin on every push to branch?',
+                        active: 'YES',
+                        inactive: 'NO',
+                    },
+                    {
+                        name: 'autodeploy_secret',
+                        type: (prev, ans) => ans.autodeploy ? 'text' : null,
+                        message: 'Enter the "secret" for validating the auto-deploy webhook event',
+                        validation: ['input', 'important'],
+                    },
+                    {
+                        name: 'ondeploy',
+                        type: 'text',
+                        message: 'Enter an optional "command" to run on deploy',
+                        validation: ['input', 'important'],
+                    },
+                    {
+                        name: 'ondeploy_autoexit',
+                        type: (prev, ans) => ans.autodeploy ? 'toggle' : null,
+                        message: 'Auto exit process on deploy?',
+                        active: 'YES',
+                        inactive: 'NO',
+                    },
+                ],
+            },
+
+        ];
+    }
+}

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

@@ -0,0 +1,65 @@
+
+/**
+ * imports
+ */
+import { _merge } from '@webqit/util/obj/index.js';
+import { _isObject } from '@webqit/util/js/index.js';
+import Configurator from '../../Configurator.js';
+
+export default class Virtualization extends Configurator {
+
+    // Base name
+    get name() {
+        return 'virtualization';
+    }
+
+    // @desc
+    static get ['@desc']() {
+        return 'Layout virtualization config.';
+    }
+
+    // Defaults merger
+    withDefaults(config) {
+        return _merge(true, {
+            entries: [],
+        }, config);
+    }
+
+    // Match
+    async match(hostname) {
+        if (_isObject(hostname)) {
+            hostname = hostname.hostname;
+        }
+        return ((await this.read()).entries || []).filter(vh => vh.host === hostname);
+    }
+
+    // Questions generator
+    questions(config, choices = {}) {
+        // Questions
+        return [
+            {
+                name: 'entries',
+                type: 'recursive',
+                controls: {
+                    name: 'vhost',
+                },
+                initial: config.entries,
+                questions: [
+                    {
+                        name: 'host',
+                        type: 'text',
+                        message: 'Enter Host name',
+                        validation: ['important'],
+                    },
+                    {
+                        name: 'path',
+                        type: 'text',
+                        message: 'Enter local path',
+                        validation: ['important'],
+                    },
+                ],
+            },
+    
+        ];
+    }
+}