@webiny/cli 0.0.0-mt-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# webiny-cli
+[![](https://img.shields.io/npm/dw/webiny-cli.svg)](https://www.npmjs.com/package/webiny-cli) 
+[![](https://img.shields.io/npm/v/webiny-cli.svg)](https://www.npmjs.com/package/webiny-cli)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+A pluggable tool to run commands within a Webiny project. 

package/bin.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+
+const chalk = require("chalk");
+const execa = require("execa");
+const semver = require("semver");
+const currentNodeVersion = process.versions.node;
+
+(async () => {
+    if (!semver.satisfies(currentNodeVersion, "^12 || ^14")) {
+        console.error(
+            chalk.red(
+                "You are running Node " +
+                    currentNodeVersion +
+                    ".\n" +
+                    "Webiny requires Node ^12 or ^14. \n" +
+                    "Please update your version of Node."
+            )
+        );
+        process.exit(1);
+    }
+
+    try {
+        const { stdout } = await execa("yarn", ["--version"]);
+        if (!semver.satisfies(stdout, "^2||^3")) {
+            console.error(chalk.red(`"@webiny/cli" requires yarn ^2 or ^3 to be installed!`));
+            process.exit(1);
+        }
+    } catch (err) {
+        console.error(chalk.red(`"@webiny/cli" requires yarn ^2 or ^3 to be installed!`));
+        console.log(`Please visit https://yarnpkg.com/ to install "yarn".`);
+        process.exit(1);
+    }
+
+    require("./cli");
+})();

package/cli.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+const path = require("path");
+const yargs = require("yargs");
+const { log, getProject } = require("./utils");
+const { boolean } = require("boolean");
+
+// Disable help processing until after plugins are imported.
+yargs.help(false);
+
+// Immediately load .env.{PASSED_ENVIRONMENT} and .env files.
+// This way we ensure all of the environment variables are not loaded too late.
+const project = getProject();
+let paths = [path.join(project.root, ".env")];
+
+if (yargs.argv.env) {
+    paths.push(path.join(project.root, `.env.${yargs.argv.env}`));
+}
+
+for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    const { error } = require("dotenv").config({ path });
+    if (boolean(yargs.argv.debug)) {
+        if (error) {
+            log.debug(`No environment file found on ${log.debug.hl(path)}.`);
+        } else {
+            log.success(`Successfully loaded environment variables from ${log.success.hl(path)}.`);
+        }
+    }
+}
+
+const { blue, red } = require("chalk");
+const context = require("./context");
+const { createCommands } = require("./commands");
+
+yargs
+    .usage("Usage: $0 <command> [options]")
+    .demandCommand(1)
+    .recommendCommands()
+    .scriptName("webiny")
+    .epilogue(
+        `To find more information, docs and tutorials, see ${blue("https://docs.webiny.com")}.`
+    )
+    .epilogue(`Want to contribute? ${blue("https://github.com/webiny/webiny-js")}.`)
+    .fail(function (msg, error, yargs) {
+        if (msg) {
+            if (msg.includes("Not enough non-option arguments")) {
+                console.log();
+                context.error(red("Command was not invoked as expected!"));
+                context.info(
+                    `Some non-optional arguments are missing. See the usage examples printed below.`
+                );
+                console.log();
+                yargs.showHelp();
+                return;
+            }
+
+            if (msg.includes("Missing required argument")) {
+                const args = msg
+                    .split(":")[1]
+                    .split(",")
+                    .map(v => v.trim());
+
+                console.log();
+                context.error(red("Command was not invoked as expected!"));
+                context.info(
+                    `Missing required argument(s): ${args
+                        .map(arg => red(arg))
+                        .join(", ")}. See the usage examples printed below.`
+                );
+                console.log();
+                yargs.showHelp();
+                return;
+            }
+            console.log();
+            context.error(red("Command execution was aborted!"));
+            context.error(msg);
+            console.log();
+
+            process.exit(1);
+        }
+
+        if (error) {
+            context.error(error.message);
+            // Unfortunately, yargs doesn't provide passed args here, so we had to do it via process.argv.
+            if (process.argv.includes("--debug")) {
+                context.debug(error);
+            }
+
+            console.log();
+            const plugins = context.plugins.byType("cli-command-error");
+            for (let i = 0; i < plugins.length; i++) {
+                const plugin = plugins[i];
+                plugin.handle({
+                    error,
+                    context
+                });
+            }
+        }
+
+        process.exit(1);
+    });
+
+(async () => {
+    await createCommands(yargs, context);
+    // Enable help and run the CLI.
+    yargs.help().argv;
+})();

package/commands/index.js

@@ -0,0 +1,13 @@
+const run = require("./run");
+const telemetry = require("./telemetry");
+const upgrade = require("./upgrade");
+
+module.exports.createCommands = async (yargs, context) => {
+    context.plugins.register(run, telemetry, upgrade);
+
+    await context.loadUserPlugins();
+
+    context.plugins.byType("cli-command").forEach(plugin => {
+        plugin.create({ yargs, context });
+    });
+};

package/commands/run/index.js

@@ -0,0 +1,30 @@
+const camelCase = require("camelcase");
+const findUp = require("find-up");
+
+module.exports = {
+    type: "cli-command",
+    name: "cli-command-run",
+    create({ yargs, context }) {
+        yargs.command(
+            "run <command> [options]",
+            `Run command defined in webiny.config.{js,ts}.\nNote: run from folder containing webiny.config.{js,ts} file.`,
+            yargs => {
+                yargs.positional("command", {
+                    describe: `Command to run in webiny.config.{js,ts}`,
+                    type: "string"
+                });
+            },
+            async argv => {
+                const configFile = findUp.sync(["webiny.config.ts", "webiny.config.js"]);
+                const config = context.import(configFile);
+
+                const command = camelCase(argv.command);
+                if (config.commands && typeof config.commands[command] === "function") {
+                    return await config.commands[command]({ ...argv }, context);
+                }
+
+                throw Error(`Command "${command}" is not defined in "${configFile}"!`);
+            }
+        );
+    }
+};

package/commands/telemetry/index.js

@@ -0,0 +1,31 @@
+const telemetry = require("@webiny/telemetry/cli");
+
+module.exports = {
+    type: "cli-command",
+    name: "cli-command-telemetry",
+    create({ yargs, context }) {
+        yargs.command("enable-telemetry", "Enable anonymous telemetry.", async () => {
+            telemetry.enable();
+            await telemetry.sendEvent({ event: "enable-telemetry" });
+            context.info(
+                `Webiny telemetry is now ${context.info.hl(
+                    "enabled"
+                )}! Thank you for helping us in making Webiny better!`
+            );
+            context.info(
+                `For more information, please visit the following link: https://www.webiny.com/telemetry.`
+            );
+        });
+
+        yargs.command("disable-telemetry", "Disable anonymous telemetry.", async () => {
+            await telemetry.sendEvent({ event: "disable-telemetry" });
+            telemetry.disable();
+            context.info(`Webiny telemetry is now ${context.info.hl("disabled")}!`);
+            context.info(
+                `Note that, in order to complete the process, you will also need to re-deploy your project, using the ${context.info.hl(
+                    "yarn webiny deploy"
+                )} command.`
+            );
+        });
+    }
+};

package/commands/upgrade/index.js

@@ -0,0 +1,107 @@
+const { red } = require("chalk");
+const execa = require("execa");
+const semver = require("semver");
+
+module.exports = [
+    {
+        type: "cli-command",
+        name: "cli-command-upgrade",
+        create({ yargs, context }) {
+            yargs.example("$0 upgrade");
+            yargs.command(
+                "upgrade",
+                `Run an upgrade script for currently installed version of Webiny`,
+                yargs => {
+                    yargs.option("skip-checks", {
+                        describe: "Do not perform CLI version and Git tree checks.",
+                        type: "boolean",
+                        default: false
+                    });
+                    yargs.option("debug", {
+                        default: false,
+                        describe: `Turn on debug logs`,
+                        type: "boolean"
+                    });
+                    yargs.option("use-version", {
+                        describe:
+                            "Use upgrade script for a specific version. Should only be used for development/testing purposes.",
+                        type: "string"
+                    });
+                },
+                async argv => {
+                    if (!argv.skipChecks) {
+                        // Before doing any upgrading, there must not be any active changes in the current branch.
+                        let gitStatus = "";
+                        try {
+                            let { stdout } = execa.sync("git", ["status", "--porcelain"]);
+                            gitStatus = stdout.trim();
+                        } catch {}
+
+                        if (gitStatus) {
+                            console.error(
+                                red(
+                                    "This git repository has untracked files or uncommitted changes:"
+                                ) +
+                                    "\n\n" +
+                                    gitStatus
+                                        .split("\n")
+                                        .map(line => line.match(/ .*/g)[0].trim())
+                                        .join("\n") +
+                                    "\n\n" +
+                                    red(
+                                        "Remove untracked files, stash or commit any changes, and try again."
+                                    )
+                            );
+                            process.exit(1);
+                        }
+                    }
+
+                    const defaultUpgradeTargetVersion = semver.coerce(context.version).version;
+
+                    const command = [
+                        "https://github.com/webiny/webiny-upgrades",
+                        argv.useVersion || defaultUpgradeTargetVersion
+                    ];
+
+                    if (yargs.argv.debug) {
+                        context.debug("npx", ...command);
+                    }
+
+                    const npx = execa("npx", command, {
+                        env: {
+                            FORCE_COLOR: true
+                        }
+                    });
+
+                    npx.stdout.on("data", data => {
+                        const lines = data.toString().replace(/\n$/, "").split("\n");
+                        for (let i = 0; i < lines.length; i++) {
+                            const line = lines[i];
+                            try {
+                                const json = JSON.parse(line);
+                                if (json.type === "error") {
+                                    context.error(
+                                        "An error occurred while performing the upgrade."
+                                    );
+                                    console.log(json.message);
+                                    if (yargs.argv.debug) {
+                                        context.debug(json.data.stack);
+                                    }
+                                }
+                            } catch {
+                                // Not JSON, let's just print the line then.
+                                console.log(line);
+                            }
+                        }
+                    });
+
+                    npx.stderr.on("data", data => {
+                        console.log(data.toString());
+                    });
+
+                    await npx;
+                }
+            );
+        }
+    }
+];

package/context.js

@@ -0,0 +1,137 @@
+const fs = require("fs");
+const path = require("path");
+const { importModule, getProject, PluginsContainer, log, localStorage } = require("./utils");
+
+const project = getProject();
+
+if (!project) {
+    console.log(
+        `🚨 Couldn't locate "webiny.project.js"! Webiny CLI relies on that file to find the root of a Webiny project.`
+    );
+    process.exit(1);
+}
+
+class Context {
+    constructor() {
+        this.loadedEnvFiles = {};
+
+        this.version = require("./package.json").version;
+        this.project = project;
+
+        // Check if `projectName` was injected properly.
+        if (this.project.name === "[PROJECT_NAME]") {
+            console.log(
+                [
+                    "",
+                    "🚨 IMPORTANT 🚨",
+                    "Looks like your project was not bootstrapped correctly! We recommend creating a new project from scratch.",
+                    "If you see errors during project creation, please report them to us:",
+                    "🔗 Github:\thttps://github.com/webiny/webiny-js",
+                    "🔗 Slack:\thttps://www.webiny.com/slack",
+                    ""
+                ].join("\n")
+            );
+            process.exit(1);
+        }
+
+        this.plugins = new PluginsContainer();
+
+        this.localStorage = localStorage();
+
+        this.onExitCallbacks = [];
+
+        let onExitProcessed = false;
+        process.on("SIGINT", async () => {
+            if (onExitProcessed) {
+                return;
+            }
+
+            onExitProcessed = true;
+
+            for (let i = 0; i < this.onExitCallbacks.length; i++) {
+                await this.onExitCallbacks[i]("SIGINT");
+            }
+
+            process.exit(1);
+        });
+    }
+
+    onExit(callback) {
+        this.onExitCallbacks.push(callback);
+    }
+
+    import(name) {
+        return importModule(name);
+    }
+
+    async loadUserPlugins() {
+        if (this.project.config.cli) {
+            let plugins = this.project.config.cli.plugins || [];
+            if (typeof plugins === "function") {
+                plugins = await plugins();
+            }
+
+            this.plugins.register(
+                ...plugins.map(plugin => {
+                    if (typeof plugin === "string") {
+                        let loadedPlugin;
+                        try {
+                            loadedPlugin = require(path.join(this.project.root, plugin)); // Try loading the package from the project's root
+                        } catch {
+                            // If it fails, perhaps the user still has the package installed somewhere locally...
+                            loadedPlugin = require(plugin);
+                        }
+                        return loadedPlugin;
+                    }
+                    return plugin;
+                })
+            );
+        }
+    }
+
+    log = log.log;
+    info = log.info;
+    success = log.success;
+    debug = log.debug;
+    warning = log.warning;
+    error = log.error;
+
+    resolve(...dir) {
+        return path.resolve(this.project.root, ...dir);
+    }
+
+    replaceProjectRoot(path) {
+        return path.replace(this.project.root, "<projectRoot>").replace(/\\/g, "/");
+    }
+
+    /**
+     * Uses `dotenv` lib to load env files, by accepting a simple file path.
+     * @param filePath
+     * @param debug
+     * @returns {Promise<void>}
+     */
+    async loadEnv(filePath, { debug = false } = {}) {
+        if (this.loadedEnvFiles[filePath]) {
+            return;
+        }
+
+        if (!fs.existsSync(filePath)) {
+            debug && this.debug(`No environment file found on ${this.debug.hl(filePath)}.`);
+            return;
+        }
+
+        try {
+            require("dotenv").config({ path: filePath });
+            debug && this.success(`Loaded environment variables from ${filePath}.`);
+            this.loadedEnvFiles[filePath] = true;
+        } catch (err) {
+            if (debug) {
+                this.error(`Could not load env variables from ${filePath}:`);
+                this.error(err.message);
+                console.log();
+            }
+        }
+    }
+}
+
+module.exports = new Context();

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@webiny/cli",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"bin": {
+		"webiny": "./bin.js"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/cli"
+	},
+	"author": "Pavel Denisjuk <pavel@webiny.com>",
+	"description": "A tool to bootstrap a Webiny project.",
+	"dependencies": {
+		"@webiny/telemetry": "0.0.0-mt-1",
+		"boolean": "3.1.4",
+		"camelcase": "5.3.1",
+		"chalk": "4.1.2",
+		"dotenv": "8.2.0",
+		"execa": "2.1.0",
+		"fast-glob": "3.2.7",
+		"find-up": "5.0.0",
+		"pirates": "4.0.1",
+		"semver": "7.3.4",
+		"typescript": "4.1.3",
+		"uniqid": "5.4.0",
+		"yargs": "14.2.3"
+	},
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public",
+		"directory": "."
+	},
+	"adio": {
+		"ignoreDirs": [
+			"/create/template/",
+			"/node_modules/",
+			"/dist/"
+		],
+		"ignore": {
+			"src": [
+				"@webiny/project-utils",
+				"@webiny/api-file-manager",
+				"@webiny/cli-plugin-deploy-pulumi",
+				"@webiny/handler",
+				"@webiny/handler-http",
+				"@webiny/handler-args",
+				"@webiny/handler-client",
+				"@webiny/api-elasticsearch",
+				"@webiny/api-tenancy",
+				"@webiny/api-security",
+				"@webiny/api-i18n",
+				"@webiny/api-i18n-content",
+				"@webiny/api-page-builder",
+				"@webiny/api-prerendering-service",
+				"@webiny/api-form-builder",
+				"@webiny/api-headless-cms"
+			]
+		}
+	},
+	"gitHead": "37736d8456a6ecb342a6c3645060bd9a3f2d4bb0"
+}