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

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.`);
+            }
+        );
+    }
+});

package/commands/wcp/project.js

@@ -0,0 +1,202 @@
+const open = require("open");
+const inquirer = require("inquirer");
+const chalk = require("chalk");
+const { getUser, WCP_APP_URL, setProjectId, sleep } = require("./utils");
+
+module.exports.command = () => [
+    {
+        type: "cli-command",
+        name: "cli-command-wcp-project",
+        create({ yargs, context }) {
+            yargs.command(
+                ["project <command>"],
+                `Webiny project-related commands`,
+                projectCommand => {
+                    projectCommand.command(
+                        "link",
+                        `Link a Webiny project with Webiny Control Panel (WCP)`,
+                        command => {
+                            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"
+                            });
+                            command.example("$0 project link");
+                        },
+                        () => handler({ context })
+                    );
+
+                    projectCommand.command(
+                        "init",
+                        `Initialize a Webiny project (deprecated, please use the link command instead)`,
+                        command => {
+                            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"
+                            });
+                            command.example("$0 project init");
+                        },
+                        () => handler({ context })
+                    );
+                }
+            );
+        }
+    }
+];
+
+const handler = async ({ context }) => {
+    // Check login.
+    const user = await getUser();
+
+    // User already linked a project?
+    const { id: orgProjectId } = context.project.config;
+    if (orgProjectId) {
+        const [, projectId] = orgProjectId.split("/");
+        const project = user.projects.find(item => item.id === projectId);
+        if (project) {
+            console.log(`Your ${chalk.green(orgProjectId)} project has already been linked.`);
+
+            const prompt = inquirer.createPromptModule();
+            const { proceed } = await prompt({
+                name: "proceed",
+                message: "Would you like to re-initialize it?",
+                type: "confirm",
+                default: false
+            });
+
+            if (!proceed) {
+                return;
+            }
+
+            console.log();
+        }
+    }
+
+    // Get user's organizations.
+    if (!user.orgs.length) {
+        console.log(
+            "It seems you're not part of any organization. Please log in to Webiny Control Panel and create one."
+        );
+
+        const prompt = inquirer.createPromptModule();
+        const { proceed } = await prompt({
+            name: "proceed",
+            message: "Would you like to do that now?",
+            type: "confirm",
+            default: false
+        });
+
+        if (proceed) {
+            await open(WCP_APP_URL);
+        }
+        return;
+    }
+
+    let selectedOrg;
+    if (user.orgs.length === 1) {
+        selectedOrg = user.orgs[0];
+    } else {
+        console.log("It seems you're part of multiple organizations. ");
+        const choices = user.orgs.map(item => ({
+            name: item.name,
+            value: item
+        }));
+
+        const prompt = inquirer.createPromptModule();
+        selectedOrg = await prompt({
+            name: "org",
+            message: "Select organization:",
+            type: "list",
+            choices,
+            default: choices[0].value
+        }).then(result => result.org);
+    }
+
+    const orgProjects = user.projects.filter(item => item.org.id === selectedOrg.id);
+
+    // Get user's projects.
+    if (!orgProjects.length) {
+        console.log(
+            `It seems there are no projects created within the ${chalk.green(
+                selectedOrg.name
+            )} organization.`
+        );
+
+        const prompt = inquirer.createPromptModule();
+        const { proceed } = await prompt({
+            name: "proceed",
+            message: "Would you like to create one now?",
+            type: "confirm",
+            default: false
+        });
+
+        if (proceed) {
+            await open(WCP_APP_URL);
+        }
+        return;
+    }
+
+    let selectedProject;
+    if (orgProjects.length === 1) {
+        selectedProject = user.projects[0];
+    } else {
+        console.log(
+            `It seems there are multiple projects created within the ${chalk.green(
+                selectedOrg.name
+            )} organization.`
+        );
+        const choices = orgProjects.map(item => ({
+            name: item.name,
+            value: item
+        }));
+        const prompt = inquirer.createPromptModule();
+        selectedProject = await prompt({
+            name: "project",
+            message: "Select project:",
+            type: "list",
+            choices,
+            default: choices[0].value
+        }).then(result => result.project);
+    }
+
+    const orgId = selectedOrg.id,
+        projectId = selectedProject.id;
+
+    await sleep();
+    console.log();
+
+    console.log(`Initializing ${context.success.hl(selectedProject.name)} project...`);
+
+    await sleep();
+
+    // Assign the necessary IDs into root `webiny.project.ts` project file.
+    await setProjectId({
+        project: context.project,
+        orgId,
+        projectId
+    });
+
+    console.log(
+        `${chalk.green("✔")} Project ${context.success.hl(
+            selectedProject.name
+        )} linked successfully.`
+    );
+
+    await sleep();
+
+    console.log();
+    console.log(chalk.bold("Next Steps"));
+
+    console.log(`‣ deploy your project via the ${chalk.green("yarn webiny deploy")} command`);
+};
+
+module.exports.handler = handler;

package/commands/wcp/utils/getProjectEnvironment.js

@@ -0,0 +1,120 @@
+const { localStorage, log } = require("@webiny/cli/utils");
+const { request } = require("graphql-request");
+const { getWcpGqlApiUrl } = require("@webiny/wcp");
+
+const ENVIRONMENT_FIELDS = /* GraphQL */ `
+    fragment EnvironmentFields on Environment {
+        id
+        status
+        name
+        apiKey
+        org {
+            id
+            name
+        }
+        project {
+            id
+            name
+        }
+        user {
+            id
+            email
+        }
+    }
+`;
+
+const CREATE_ENVIRONMENT = /* GraphQL */ `
+    ${ENVIRONMENT_FIELDS}
+    mutation CreateEnvironment(
+        $orgId: ID!
+        $projectId: ID!
+        $userId: ID
+        $data: CreateEnvironmentDataInput!
+    ) {
+        projects {
+            createEnvironment(orgId: $orgId, projectId: $projectId, userId: $userId, data: $data) {
+                ...EnvironmentFields
+            }
+        }
+    }
+`;
+
+const GET_ENVIRONMENT = /* GraphQL */ `
+    ${ENVIRONMENT_FIELDS}
+    query GetEnvironment(
+        $environmentId: ID
+        $orgId: ID
+        $projectId: ID
+        $userId: ID
+        $apiKey: String
+    ) {
+        projects {
+            getEnvironment(
+                environmentId: $environmentId
+                orgId: $orgId
+                projectId: $projectId
+                userId: $userId
+                apiKey: $apiKey
+            ) {
+                ...EnvironmentFields
+            }
+        }
+    }
+`;
+
+module.exports.getProjectEnvironment = async ({
+    orgId,
+    projectId,
+    userId,
+    environmentId,
+    apiKey
+}) => {
+    if (apiKey) {
+        return request(getWcpGqlApiUrl(), GET_ENVIRONMENT, { apiKey })
+            .then(response => response.projects.getEnvironment)
+            .catch(() => {
+                throw new Error(
+                    `It seems the API key you provided is incorrect or disabled. Please double check the API key and try again.`
+                );
+            });
+    }
+
+    const pat = localStorage().get("wcpPat");
+    if (!pat) {
+        throw new Error(
+            `It seems you are not logged in. Please login using the ${log.error.hl(
+                "webiny login"
+            )} command.`
+        );
+    }
+
+    const headers = { authorization: pat };
+    return request(
+        getWcpGqlApiUrl(),
+        GET_ENVIRONMENT,
+        {
+            orgId,
+            projectId,
+            userId,
+            environmentId,
+            apiKey
+        },
+        headers
+    )
+        .then(async response => response.projects.getEnvironment)
+        .catch(() => {
+            return request(
+                getWcpGqlApiUrl(),
+                CREATE_ENVIRONMENT,
+                {
+                    orgId,
+                    projectId,
+                    userId,
+                    data: {
+                        name: environmentId
+                    }
+                },
+                headers
+            ).then(async response => response.projects.createEnvironment);
+        });
+};

package/commands/wcp/utils/getUser.js

@@ -0,0 +1,100 @@
+const { log } = require("@webiny/cli/utils");
+const { request } = require("graphql-request");
+const { getWcpPat } = require("./getWcpPat");
+const { getWcpGqlApiUrl } = require("@webiny/wcp");
+
+const GET_CURRENT_USER = /* GraphQL */ `
+    query GetUser {
+        users {
+            getCurrentUser {
+                id
+                email
+                firstName
+                lastName
+            }
+        }
+    }
+`;
+
+const LIST_ORGS = /* GraphQL */ `
+    query ListOrgs {
+        orgs {
+            listOrgs {
+                data {
+                    id
+                    name
+                }
+            }
+        }
+    }
+`;
+
+const LIST_PROJECTS = /* GraphQL */ `
+    query ListProjects($orgId: ID!) {
+        projects {
+            listProjects(orgId: $orgId) {
+                data {
+                    id
+                    name
+                    org {
+                        id
+                        name
+                    }
+                }
+            }
+        }
+    }
+`;
+
+let user;
+module.exports.getUser = async () => {
+    if (user) {
+        return user;
+    }
+
+    const pat = getWcpPat();
+    if (!pat) {
+        throw new Error(
+            `It seems you are not logged into your WCP project. Please log in using the ${log.error.hl(
+                "yarn webiny login"
+            )} command. If you are not using WCP, make sure you don't have an "id" property in your "webiny.project.ts" file.`
+        );
+    }
+
+    try {
+        const headers = { authorization: pat };
+        user = await request(getWcpGqlApiUrl(), GET_CURRENT_USER, {}, headers).then(
+            async response => {
+                const user = response.users.getCurrentUser;
+
+                const orgs = await request(getWcpGqlApiUrl(), LIST_ORGS, {}, headers).then(
+                    async response => {
+                        const orgs = response.orgs.listOrgs.data;
+                        for (let i = 0; i < orgs.length; i++) {
+                            const org = orgs[i];
+                            org.projects = await request(
+                                getWcpGqlApiUrl(),
+                                LIST_PROJECTS,
+                                { orgId: org.id },
+                                headers
+                            ).then(response => response.projects.listProjects.data);
+                        }
+                        return orgs;
+                    }
+                );
+
+                const projects = orgs.map(org => org.projects).flat();
+
+                return { ...user, orgs, projects };
+            }
+        );
+    } catch {
+        throw new Error(
+            `It seems the personal access token is incorrect or does not exist. Please log out and log in again using the ${log.error.hl(
+                "yarn webiny login"
+            )} command.`
+        );
+    }
+
+    return user;
+};

package/commands/wcp/utils/getWcpPat.js

@@ -0,0 +1,5 @@
+const { localStorage } = require("@webiny/cli/utils");
+
+module.exports.getWcpPat = wcpPat => {
+    return localStorage().get("wcpPat", wcpPat);
+};

package/commands/wcp/utils/index.js

@@ -0,0 +1,17 @@
+const { getUser } = require("./getUser");
+const { getProjectEnvironment } = require("./getProjectEnvironment");
+const { updateUserLastActiveOn } = require("./updateUserLastActiveOn");
+const { setProjectId } = require("./setProjectId");
+const { setWcpPat } = require("./setWcpPat");
+const { getWcpPat } = require("./getWcpPat");
+const { sleep } = require("./sleep");
+
+module.exports = {
+    getUser,
+    getProjectEnvironment,
+    updateUserLastActiveOn,
+    setProjectId,
+    setWcpPat,
+    getWcpPat,
+    sleep
+};