@webiny/cli 0.0.0-mt-3 → 0.0.0-unstable.3386f66516

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

@@ -7,14 +7,14 @@ const semver = require("semver");
 const currentNodeVersion = process.versions.node;
 
 (async () => {
-    if (!semver.satisfies(currentNodeVersion, "^12 || ^14")) {
+    if (!semver.satisfies(currentNodeVersion, ">=14")) {
         console.error(
             chalk.red(
-                "You are running Node " +
-                    currentNodeVersion +
-                    ".\n" +
-                    "Webiny requires Node ^12 or ^14. \n" +
-                    "Please update your version of Node."
+                [
+                    `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);
@@ -22,13 +22,15 @@ const currentNodeVersion = process.versions.node;
 
     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!`));
+        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 or ^3 to be installed!`));
-        console.log(`Please visit https://yarnpkg.com/ to install "yarn".`);
+        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);
     }
 

package/cli.js

@@ -1,32 +1,11 @@
 #!/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)}.`);
-        }
-    }
-}
+// Loads environment variables from multiple sources.
+require("./utils/loadEnvVariables");
 
 const { blue, red } = require("chalk");
 const context = require("./context");
@@ -38,7 +17,7 @@ yargs
     .recommendCommands()
     .scriptName("webiny")
     .epilogue(
-        `To find more information, docs and tutorials, see ${blue("https://docs.webiny.com")}.`
+        `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) {

package/commands/index.js

@@ -5,6 +5,13 @@ 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 => {

package/commands/run/index.js

@@ -1,5 +1,6 @@
 const camelCase = require("camelcase");
 const findUp = require("find-up");
+const path = require("path");
 
 module.exports = {
     type: "cli-command",
@@ -16,9 +17,16 @@ module.exports = {
             },
             async argv => {
                 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/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()];

package/commands/wcp/login.js

@@ -0,0 +1,228 @@
+const open = require("open");
+const { GraphQLClient } = require("graphql-request");
+const { setProjectId, setWcpPat, sleep } = require("./utils");
+const chalk = require("chalk");
+const { getWcpGqlApiUrl, getWcpAppUrl } = require("@webiny/wcp");
+
+// 120 retries * 2000ms interval = 4 minutes until the command returns an error.
+const LOGIN_RETRIES_COUNT = 30;
+const LOGIN_RETRIES_INTERVAL = 2000;
+
+const USER_PAT_FIELDS = /* GraphQL */ `
+    fragment UserPatFields on UserPat {
+        name
+        meta
+        token
+        expiresOn
+        user {
+            email
+        }
+    }
+`;
+
+const GENERATE_USER_PAT = /* GraphQL */ `
+    mutation GenerateUserPat {
+        users {
+            generateUserPat
+        }
+    }
+`;
+
+const GET_USER_PAT = /* GraphQL */ `
+    ${USER_PAT_FIELDS}
+    query GetUserPat($token: ID!) {
+        users {
+            getUserPat(token: $token) {
+                ...UserPatFields
+            }
+        }
+    }
+`;
+
+const CREATE_USER_PAT = /* GraphQL */ `
+    ${USER_PAT_FIELDS}
+    mutation CreateUserPat($expiresIn: Int, $token: ID, $data: CreateUserPatDataInput) {
+        users {
+            createUserPat(expiresIn: $expiresIn, token: $token, data: $data) {
+                ...UserPatFields
+            }
+        }
+    }
+`;
+
+module.exports.command = () => ({
+    type: "cli-command",
+    name: "cli-command-wcp-login",
+    create({ yargs, context }) {
+        yargs.command(
+            "login [pat]",
+            `Log in to the Webiny Control Panel`,
+            yargs => {
+                yargs.example("$0 login");
+                yargs.positional("pat", {
+                    describe: `Personal access token (PAT)`,
+                    type: "string"
+                });
+                yargs.option("debug", {
+                    describe: `Turn on debug logs`,
+                    type: "boolean"
+                });
+                yargs.option("debug-level", {
+                    default: 1,
+                    describe: `Set the debug logs verbosity level`,
+                    type: "number"
+                });
+            },
+            async ({ debug, debugLevel, pat: patFromParams }) => {
+                const graphQLClient = new GraphQLClient(getWcpGqlApiUrl());
+
+                let pat;
+
+                if (patFromParams) {
+                    try {
+                        graphQLClient.setHeaders({ authorization: patFromParams });
+                        pat = await graphQLClient
+                            .request(GET_USER_PAT, { token: patFromParams })
+                            .then(({ users }) => users.getUserPat);
+
+                        // If we've received a PAT that has expiration, let's create a long-lived PAT.
+                        // We don't want to have our users interrupted because of an expired PAT.
+                        if (pat.expiresOn) {
+                            pat = await graphQLClient
+                                .request(CREATE_USER_PAT, { data: { meta: pat.meta } })
+                                .then(({ users }) => users.createUserPat);
+                        }
+                    } catch (e) {
+                        if (debug) {
+                            context.debug(
+                                `Could not use the provided ${context.debug.hl(
+                                    patFromParams
+                                )} PAT because of the following error:`
+                            );
+                            console.debug(e);
+                        }
+
+                        throw new Error(
+                            `Invalid PAT received. Please try again or login manually via the ${context.error.hl(
+                                "yarn webiny login"
+                            )} command.`
+                        );
+                    }
+                } else {
+                    const generatedPat = await graphQLClient
+                        .request(GENERATE_USER_PAT)
+                        .then(({ users }) => users.generateUserPat);
+
+                    const queryParams = `pat=${generatedPat}&pat_name=${encodeURIComponent(
+                        "Webiny CLI"
+                    )}&ref=cli`;
+                    const openUrl = `${getWcpAppUrl()}/login/cli?${queryParams}`;
+
+                    debug && context.debug(`Opening ${context.debug.hl(openUrl)}...`);
+                    await open(openUrl);
+
+                    const graphql = {
+                        variables: { token: generatedPat },
+                        headers: {
+                            Authorization: generatedPat
+                        }
+                    };
+
+                    graphQLClient.setHeaders(graphql.headers);
+
+                    let retries = 0;
+                    const result = await new Promise(resolve => {
+                        const interval = setInterval(async () => {
+                            retries++;
+                            if (retries > LOGIN_RETRIES_COUNT) {
+                                clearInterval(interval);
+                                resolve(null);
+                            }
+
+                            try {
+                                const pat = await graphQLClient
+                                    .request(GET_USER_PAT, graphql.variables)
+                                    .then(({ users }) => users.getUserPat);
+
+                                clearInterval(interval);
+                                resolve(pat);
+                            } catch (e) {
+                                // Do nothing.
+                                if (debug) {
+                                    context.debug(
+                                        `Could not login. Will try again in ${LOGIN_RETRIES_INTERVAL}ms.`
+                                    );
+                                    if (debugLevel > 1) {
+                                        context.debug("GraphQL Request: ");
+                                        console.log(JSON.stringify(graphql, null, 2));
+                                    }
+                                    if (debugLevel > 2) {
+                                        context.debug(e.message);
+                                    }
+                                }
+                            }
+                        }, LOGIN_RETRIES_INTERVAL);
+                    });
+
+                    if (!result) {
+                        throw new Error(
+                            `Could not login. Did you complete the sign in / sign up process at ${getWcpAppUrl()}?`
+                        );
+                    }
+
+                    pat = result;
+                }
+
+                setWcpPat(pat.token);
+
+                console.log(
+                    `${chalk.green("✔")} You've successfully logged in to Webiny Control Panel.`
+                );
+
+                let projectInitialized = Boolean(
+                    context.project.config.id || process.env.WCP_PROJECT_ID
+                );
+
+                // If we have `orgId` and `projectId` in PAT's metadata, let's immediately link the project.
+                if (pat.meta && pat.meta.orgId && pat.meta.projectId) {
+                    await sleep();
+
+                    console.log();
+
+                    const { orgId, projectId } = pat.meta;
+
+                    const id = `${orgId}/${projectId}`;
+                    console.log(`Project ${chalk.green(id)} detected. Linking...`);
+
+                    await sleep();
+
+                    await setProjectId({
+                        project: context.project,
+                        orgId,
+                        projectId
+                    });
+
+                    console.log(`Project ${context.success.hl(id)} linked successfully.`);
+                    projectInitialized = true;
+                }
+
+                await sleep();
+
+                console.log();
+                console.log(chalk.bold("Next Steps"));
+
+                if (!projectInitialized) {
+                    console.log(
+                        `‣ link your project via the ${chalk.green(
+                            "yarn webiny project link"
+                        )} command`
+                    );
+                }
+
+                console.log(
+                    `‣ deploy your project via the ${chalk.green("yarn webiny deploy")} command`
+                );
+            }
+        );
+    }
+});

package/commands/wcp/logout.js

@@ -0,0 +1,28 @@
+const { setWcpPat } = require("./utils");
+
+module.exports.command = () => ({
+    type: "cli-command",
+    name: "cli-command-wcp-logout",
+    create({ yargs }) {
+        yargs.command(
+            "logout",
+            `Log out from the Webiny Control Panel`,
+            yargs => {
+                yargs.example("$0 logout");
+                yargs.option("debug", {
+                    describe: `Turn on debug logs`,
+                    type: "boolean"
+                });
+                yargs.option("debug-level", {
+                    default: 1,
+                    describe: `Set the debug logs verbosity level`,
+                    type: "number"
+                });
+            },
+            async () => {
+                setWcpPat(null);
+                console.log(`You've successfully logged out from Webiny Control Panel.`);
+            }
+        );
+    }
+});