@webiny/cli 0.0.0-mt-2 → 0.0.0-unstable.06b2ede40f

package/README.md

@@ -4,4 +4,4 @@
 [![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. 
+A pluggable tool to run commands within a Webiny project. 

package/bin.js

@@ -1,36 +1,103 @@
 #!/usr/bin/env node
-"use strict";
 
-const chalk = require("chalk");
-const execa = require("execa");
-const semver = require("semver");
-const currentNodeVersion = process.versions.node;
+// Suppress punycode warnings. This is a known issue which we can't fix.
+require("./utils/suppressPunycodeWarnings");
 
-(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);
-    }
+// Ensure system requirements are met.
+require("@webiny/system-requirements").ensureSystemRequirements();
+
+// Detect different Webiny package versions.
+require("./utils/ensureSameWebinyPackageVersions").ensureSameWebinyPackageVersions();
+
+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, bold, bgYellow } = 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();
 
-    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".`);
+
+        console.log();
+        // Unfortunately, yargs doesn't provide passed args here, so we had to do it via process.argv.
+        const debugEnabled = process.argv.includes("--debug");
+        if (debugEnabled) {
+            context.debug(error);
+        } else {
+            context.error(error.message);
+        }
+
+        const gracefulError = error.cause?.gracefulError;
+        if (gracefulError instanceof Error) {
+            console.log();
+            console.log(bgYellow(bold("💡 How can I resolve this?")));
+            console.log(gracefulError.message);
+        }
+
+        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);
-    }
+    });
 
-    require("./cli");
+(async () => {
+    await createCommands(yargs, context);
+    // Enable help and run the CLI.
+    yargs.help().argv;
 })();

package/commands/about/getDatabaseSetup.js

@@ -0,0 +1,45 @@
+const { getProject } = require("@webiny/cli/utils");
+const path = require("path");
+const fs = require("fs");
+
+const DATABASE_SETUPS = {
+    DDB: "ddb",
+    DDB_ES: "ddb-es",
+    DDB_OS: "ddb-os"
+};
+
+const DATABASE_SETUPS_LABELS = {
+    [DATABASE_SETUPS.DDB]: "Amazon DynamoDB",
+    [DATABASE_SETUPS.DDB_ES]: "Amazon DynamoDB + Amazon Elasticsearch Service",
+    [DATABASE_SETUPS.DDB_OS]: "Amazon DynamoDB + Amazon OpenSearch Service"
+};
+
+// In order to get the database setup, we check for existence of `elasticSearch`
+//  or `openSearch` strings within the `apps/core/webiny.application.ts` file.
+const getDatabaseSetup = () => {
+    const project = getProject();
+    const webinyAppTsPath = path.join(project.root, "apps", "core", "webiny.application.ts");
+
+    const webinyAppTs = fs.readFileSync(webinyAppTsPath, "utf8");
+    if (webinyAppTs.includes("elasticSearch")) {
+        return "ddb-es";
+    }
+
+    if (webinyAppTs.includes("openSearch")) {
+        return "ddb-os";
+    }
+
+    return "ddb";
+};
+
+const getDatabaseSetupLabel = () => {
+    const setup = getDatabaseSetup();
+    return DATABASE_SETUPS_LABELS[setup];
+};
+
+module.exports = {
+    getDatabaseSetup,
+    getDatabaseSetupLabel,
+    DATABASE_SETUPS,
+    DATABASE_SETUPS_LABELS
+};

package/commands/about/getNpmVersion.js

@@ -0,0 +1,5 @@
+const { SystemRequirements } = require("@webiny/system-requirements");
+
+module.exports.getNpmVersion = async () => {
+    return SystemRequirements.getNpmVersion();
+};

package/commands/about/getNpxVersion.js

@@ -0,0 +1,5 @@
+const { SystemRequirements } = require("@webiny/system-requirements");
+
+module.exports.getNpxVersion = async () => {
+    return SystemRequirements.getNpxVersion();
+};

package/commands/about/getPulumiVersions.js

@@ -0,0 +1,43 @@
+const execa = require("execa");
+
+module.exports.getPulumiVersions = async () => {
+    let pulumi, pulumiAws;
+
+    try {
+        {
+            const { stdout } = await execa("yarn", [
+                "info",
+                "@pulumi/pulumi",
+                "-A",
+                "-R",
+                "--name-only",
+                "--json"
+            ]);
+
+            const match = stdout.match(/npm:(.*?)"/);
+            if (match) {
+                pulumi = match[1];
+            }
+        }
+
+        {
+            const { stdout } = await execa("yarn", [
+                "info",
+                "@pulumi/aws",
+                "-A",
+                "-R",
+                "--name-only",
+                "--json"
+            ]);
+
+            const match = stdout.match(/npm:(.*?)"/);
+            if (match) {
+                pulumiAws = match[1];
+            }
+        }
+    } catch (err) {
+        return "";
+    }
+
+    return [pulumi, pulumiAws];
+};

package/commands/about/getYarnVersion.js

@@ -0,0 +1,5 @@
+const { SystemRequirements } = require("@webiny/system-requirements");
+
+module.exports.getYarnVersion = async () => {
+    return SystemRequirements.getYarnVersion();
+};

package/commands/about/index.js

@@ -0,0 +1,97 @@
+const NO_VALUE = "-";
+const { isCI } = require("ci-info");
+
+const getData = async context => {
+    const { getUser } = require("../wcp/utils");
+    const { getNpxVersion } = require("./getNpxVersion");
+    const { getNpmVersion } = require("./getNpmVersion");
+    const { getPulumiVersions } = require("./getPulumiVersions");
+    const { getYarnVersion } = require("./getYarnVersion");
+    const { getDatabaseSetupLabel } = require("./getDatabaseSetup");
+
+    const [pulumiVersion, pulumiAwsVersion] = await getPulumiVersions();
+
+    const wcpProjectId = process.env.WCP_PROJECT_ID;
+    const wcpUser = await getUser().catch(() => null);
+    const wcpUsingProjectEnvironmentApiKey = Boolean(process.env.WCP_ENVIRONMENT_API_KEY);
+
+    return [
+        {
+            sectionName: "Webiny Project",
+            data: {
+                Name: context.project.name,
+                Version: context.version,
+                "Database Setup": getDatabaseSetupLabel(),
+                "Debug Enabled": process.env.DEBUG === "true" ? "Yes" : "No",
+                "Feature Flags": process.env.WEBINY_FEATURE_FLAGS || "N/A"
+            }
+        },
+        {
+            sectionName: "Webiny Control Panel (WCP)",
+            data: {
+                "Project ID": wcpProjectId,
+                User: wcpUser?.email || "N/A",
+                "Using Project Environment API Key": wcpUsingProjectEnvironmentApiKey ? "Yes" : "No"
+            }
+        },
+        {
+            sectionName: "Host",
+            data: {
+                OS: `${process.platform} (${process.arch})`,
+                "Node.js": process.version,
+                NPM: await getNpmVersion(),
+                NPX: await getNpxVersion(),
+                Yarn: await getYarnVersion(),
+                "Is CI": isCI ? "Yes" : "No"
+            }
+        },
+        {
+            sectionName: "Pulumi",
+            data: {
+                "@pulumi/pulumi": pulumiVersion,
+                "@pulumi/aws": pulumiAwsVersion,
+                "Secrets Provider": process.env.PULUMI_SECRETS_PROVIDER,
+                "Using Password": process.env.PULUMI_CONFIG_PASSPHRASE ? "Yes" : "No"
+            }
+        }
+    ];
+};
+
+module.exports = {
+    type: "cli-command",
+    name: "cli-command-about",
+    create({ yargs, context }) {
+        yargs.command(
+            "about",
+            `Prints out information helpful for debugging purposes.`,
+            yargs => {
+                yargs.option("json", {
+                    describe: "Emit output as JSON.",
+                    type: "boolean",
+                    default: false
+                });
+            },
+            async yargs => {
+                const data = await getData(context);
+
+                if (yargs.json) {
+                    console.log(JSON.stringify(data, null, 2));
+                    return;
+                }
+
+                data.forEach(({ sectionName, data }, index) => {
+                    if (index > 0) {
+                        console.log();
+                    }
+
+                    const { bold } = require("chalk");
+                    console.log(bold(sectionName));
+
+                    Object.keys(data).forEach(key => {
+                        console.log(key.padEnd(36), data[key] || NO_VALUE);
+                    });
+                });
+            }
+        );
+    }
+};

package/commands/index.js

@@ -1,9 +1,17 @@
+const about = require("./about");
 const run = require("./run");
 const telemetry = require("./telemetry");
 const upgrade = require("./upgrade");
 
 module.exports.createCommands = async (yargs, context) => {
-    context.plugins.register(run, telemetry, upgrade);
+    context.plugins.register(about, run, telemetry, upgrade);
+
+    try {
+        const wcp = require("./wcp");
+        context.plugins.register(wcp);
+    } catch {
+        // Skip WCP command
+    }
 
     await context.loadUserPlugins();
 

package/commands/run/index.js

@@ -1,6 +1,3 @@
-const camelCase = require("camelcase");
-const findUp = require("find-up");
-
 module.exports = {
     type: "cli-command",
     name: "cli-command-run",
@@ -15,10 +12,21 @@ module.exports = {
                 });
             },
             async argv => {
+                const camelCase = require("camelcase");
+                const findUp = require("find-up");
+                const path = require("path");
+
                 const configFile = findUp.sync(["webiny.config.ts", "webiny.config.js"]);
-                const config = context.import(configFile);
+                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);
                 }

package/commands/telemetry/index.js

@@ -1,16 +1,15 @@
-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 () => {
+            const telemetry = require("@webiny/telemetry/cli");
+
             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!`
+                `Webiny telemetry is now %s! Thank you for helping us in making Webiny better!`,
+                "enabled"
             );
             context.info(
                 `For more information, please visit the following link: https://www.webiny.com/telemetry.`
@@ -18,13 +17,14 @@ module.exports = {
         });
 
         yargs.command("disable-telemetry", "Disable anonymous telemetry.", async () => {
+            const telemetry = require("@webiny/telemetry/cli");
+
             await telemetry.sendEvent({ event: "disable-telemetry" });
             telemetry.disable();
-            context.info(`Webiny telemetry is now ${context.info.hl("disabled")}!`);
+            context.info(`Webiny telemetry is now %s!`, "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.`
+                `Note that, in order to complete the process, you will also need to re-deploy your project, using the %s command.`,
+                "yarn webiny deploy"
             );
         });
     }

package/commands/upgrade/index.js

@@ -1,7 +1,3 @@
-const { red } = require("chalk");
-const execa = require("execa");
-const semver = require("semver");
-
 module.exports = [
     {
         type: "cli-command",
@@ -29,6 +25,10 @@ module.exports = [
                     });
                 },
                 async argv => {
+                    const { red } = require("chalk");
+                    const execa = require("execa");
+                    const semver = require("semver");
+
                     if (!argv.skipChecks) {
                         // Before doing any upgrading, there must not be any active changes in the current branch.
                         let gitStatus = "";
@@ -70,7 +70,8 @@ module.exports = [
                     const npx = execa("npx", command, {
                         env: {
                             FORCE_COLOR: true
-                        }
+                        },
+                        stdin: process.stdin
                     });
 
                     npx.stdout.on("data", data => {

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()];