@webiny/cli 0.0.0-ee-vpcs.549378cf03

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,38 @@
+#!/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, ">=14")) {
+        console.error(
+            chalk.red(
+                [
+                    `You are running Node.js ${currentNodeVersion}, but Webiny requires version 14 or higher.`,
+                    `Please switch to one of the required versions and try again.`,
+                    `For more information, please visit https://docs.webiny.com/docs/tutorials/install-webiny#prerequisites.`
+                ].join(" ")
+            )
+        );
+        process.exit(1);
+    }
+
+    try {
+        const { stdout } = await execa("yarn", ["--version"]);
+        if (!semver.satisfies(stdout, ">=2")) {
+            console.error(chalk.red(`"@webiny/cli" requires yarn >=2!`));
+            process.exit(1);
+        }
+    } catch (err) {
+        console.error(chalk.red(`"@webiny/cli" requires yarn >=2!`));
+        console.log(
+            `Run ${chalk.blue("yarn set version berry")} to install a compatible version of yarn.`
+        );
+        process.exit(1);
+    }
+
+    require("./cli");
+})();

package/cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+const yargs = require("yargs");
+
+// Disable help processing until after plugins are imported.
+yargs.help(false);
+
+// Loads environment variables from multiple sources.
+require("./utils/loadEnvVariables");
+
+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://www.webiny.com/docs")}.`
+    )
+    .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,20 @@
+const run = require("./run");
+const telemetry = require("./telemetry");
+const upgrade = require("./upgrade");
+
+module.exports.createCommands = async (yargs, context) => {
+    context.plugins.register(run, telemetry, upgrade);
+
+    try {
+        const wcp = require("./wcp");
+        context.plugins.register(wcp);
+    } catch {
+        // Skip WCP command
+    }
+
+    await context.loadUserPlugins();
+
+    context.plugins.byType("cli-command").forEach(plugin => {
+        plugin.create({ yargs, context });
+    });
+};

package/commands/run/index.js

@@ -0,0 +1,38 @@
+const camelCase = require("camelcase");
+const findUp = require("find-up");
+const path = require("path");
+
+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"]);
+                let config = context.import(configFile);
+
+                const command = camelCase(argv.command);
+                if (typeof config === "function") {
+                    config = config({
+                        options: { ...argv, cwd: path.dirname(configFile) },
+                        context
+                    });
+                }
+
+                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/commands/wcp/hooks.js

@@ -0,0 +1,133 @@
+const { encrypt, decrypt } = require("@webiny/wcp");
+const { getUser, getProjectEnvironment, updateUserLastActiveOn } = require("./utils");
+
+/**
+ * The two environment variables we set via these hooks are the following:
+ * - WCP_PROJECT_ENVIRONMENT - contains encrypted data about the deployed project environment
+ * - WCP_PROJECT_ENVIRONMENT_API_KEY - for easier access, we also set the API key
+ */
+
+/**
+ * There are multiple ways the hooks below prepare the WCP-enabled project for deployment.
+ * 1. If `WCP_PROJECT_ENVIRONMENT` metadata env var is defined, we decrypt it, retrieve the
+ *    API key from it, and assign it as the `WCP_PROJECT_ENVIRONMENT_API_KEY` env var.
+ * 2. If `WCP_PROJECT_ENVIRONMENT_API_KEY` env var is defined, then we use that as the
+ *    project environment API key. We use that to load the project environment data
+ *    and to also assign the `WCP_PROJECT_ENVIRONMENT` metadata env var.
+ * 3. If none of the above is defined, we retrieve (or create) the project environment,
+ *    retrieve its API key and again assign it as `WCP_PROJECT_ENVIRONMENT_API_KEY` env var.
+ *    As in 2), we also assign the `WCP_PROJECT_ENVIRONMENT` metadata env var.
+ */
+
+let projectEnvironment;
+
+const getEnvironmentHookHandler = async (args, context) => {
+    // If the project isn't linked with WCP, do nothing.
+    const wcpProjectId = context.project.config.id || process.env.WCP_PROJECT_ID;
+    if (!wcpProjectId) {
+        return;
+    }
+
+    // For development purposes, we allow setting the WCP_PROJECT_ENVIRONMENT env var directly.
+    if (process.env.WCP_PROJECT_ENVIRONMENT) {
+        // If we have WCP_PROJECT_ENVIRONMENT env var, we set the WCP_PROJECT_ENVIRONMENT_API_KEY too.
+        const decryptedProjectEnvironment = decrypt(process.env.WCP_PROJECT_ENVIRONMENT);
+        process.env.WCP_PROJECT_ENVIRONMENT_API_KEY = decryptedProjectEnvironment.apiKey;
+        return;
+    }
+
+    // The `id` has the orgId/projectId structure, for example `my-org-x/my-project-y`.
+    const [orgId, projectId] = wcpProjectId.split("/");
+
+    const apiKey = process.env.WCP_PROJECT_ENVIRONMENT_API_KEY;
+
+    let projectEnvironment;
+    if (apiKey) {
+        projectEnvironment = await getProjectEnvironment({ apiKey });
+    } else {
+        const isValidId = orgId && projectId;
+        if (!isValidId) {
+            throw new Error(
+                `It seems the project ID, specified in "webiny.project.ts" file, is invalid.`
+            );
+        }
+
+        // If there is no API key, that means we need to retrieve the currently logged-in user.
+        const user = await getUser();
+        const project = user.projects.find(item => item.id === projectId);
+        if (!project) {
+            throw new Error(
+                `It seems you don't belong to the current project or the current project has been deleted.`
+            );
+        }
+
+        projectEnvironment = await getProjectEnvironment({
+            orgId,
+            projectId,
+            userId: user.id,
+            environmentId: args.env
+        });
+    }
+
+    if (projectEnvironment.org.id !== orgId) {
+        throw new Error(
+            `Cannot proceed with the deployment because the "${projectEnvironment.name}" project environment doesn't belong to the "${orgId}" organization. Please check your WCP project ID (currently set to "${wcpProjectId}").`
+        );
+    }
+
+    if (projectEnvironment.project.id !== projectId) {
+        throw new Error(
+            `Cannot proceed with the deployment because the "${projectEnvironment.name}" project environment doesn't belong to the "${wcpProjectId}" project. Please check your WCP project ID (currently set to "${wcpProjectId}").`
+        );
+    }
+
+    if (projectEnvironment && projectEnvironment.status !== "enabled") {
+        throw new Error(
+            `Cannot proceed with the deployment because the "${projectEnvironment.name}" project environment has been disabled.`
+        );
+    }
+
+    // Assign `WCP_PROJECT_ENVIRONMENT` and `WCP_PROJECT_ENVIRONMENT_API_KEY`
+    const wcpProjectEnvironment = {
+        id: projectEnvironment.id,
+        apiKey: projectEnvironment.apiKey,
+        org: { id: projectEnvironment.org.id },
+        project: { id: projectEnvironment.project.id }
+    };
+
+    process.env.WCP_PROJECT_ENVIRONMENT = encrypt(wcpProjectEnvironment);
+    process.env.WCP_PROJECT_ENVIRONMENT_API_KEY = projectEnvironment.apiKey;
+};
+
+const updateLastActiveOnHookHandler = async () => {
+    if (!projectEnvironment) {
+        return;
+    }
+
+    // Is this a user environment? If so, let's update his "last active" field.
+    if (projectEnvironment.user) {
+        await updateUserLastActiveOn();
+    }
+};
+
+// Export hooks plugins for deploy and watch commands.
+module.exports = () => [
+    // Deploy hook handlers.
+    {
+        type: "hook-before-deploy",
+        name: "hook-before-deploy-environment-get-environment",
+        hook: getEnvironmentHookHandler
+    },
+    {
+        type: "hook-before-deploy",
+        name: "hook-before-deploy-update-last-active-on",
+        hook: updateLastActiveOnHookHandler
+    },
+
+    // Watch hook handlers.
+    {
+        type: "hook-before-watch",
+        name: "hook-before-watch-environment-get-environment",
+        hook: getEnvironmentHookHandler
+    }
+];

package/commands/wcp/index.js

@@ -0,0 +1,8 @@
+const { command: login } = require("./login");
+const { command: logout } = require("./logout");
+const { command: whoami } = require("./whoami");
+const { command: project } = require("./project");
+
+const hooks = require("./hooks");
+
+module.exports = [login(), logout(), whoami(), project(), hooks()];