@webiny/cli 5.22.0 → 5.23.0-beta.1

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.23.0-beta.1](https://github.com/webiny/webiny-js/compare/v5.23.0-beta.0...v5.23.0-beta.1) (2022-02-14)
+
+**Note:** Version bump only for package @webiny/cli
+
+
+
+
+
+# [5.23.0-beta.0](https://github.com/webiny/webiny-js/compare/v5.22.1...v5.23.0-beta.0) (2022-02-13)
+
+
+### Bug Fixes
+
+* check project ID ([fe56278](https://github.com/webiny/webiny-js/commit/fe562788ace11ae3b571aa39d06328bcd220b100))
+* correct comment ([54c3686](https://github.com/webiny/webiny-js/commit/54c36860132ac4c6ee6f09cc4035223ba977c4f2))
+* eslint ([ad11ead](https://github.com/webiny/webiny-js/commit/ad11ead640111993e0cf6fb97ff6395633239cca))
+* remove redundant code ([d1dde23](https://github.com/webiny/webiny-js/commit/d1dde23233f04f09eae9fc42374752eb46f36512))
+* update deps ([6879623](https://github.com/webiny/webiny-js/commit/6879623d98b04229f07796fd601f4a3f0f534c3b))
+* use the right hooks ([318db7a](https://github.com/webiny/webiny-js/commit/318db7acb30a85fe15ad3f4082536a2bf7a52f22))
+
+
+
+
+
+## [5.22.1](https://github.com/webiny/webiny-js/compare/v5.22.1-beta.0...v5.22.1) (2022-01-29)
+
+**Note:** Version bump only for package @webiny/cli
+
+
+
+
+
+## [5.22.1-beta.0](https://github.com/webiny/webiny-js/compare/v5.22.0...v5.22.1-beta.0) (2022-01-29)
+
+**Note:** Version bump only for package @webiny/cli
+
+
+
+
+
 # [5.22.0](https://github.com/webiny/webiny-js/compare/v5.22.0-beta.3...v5.22.0) (2022-01-24)
 
 **Note:** Version bump only for package @webiny/cli

package/commands/index.js

@@ -1,10 +1,16 @@
 const run = require("./run");
 const telemetry = require("./telemetry");
+const wcp = require("./wcp");
 const upgrade = require("./upgrade");
 
 module.exports.createCommands = async (yargs, context) => {
     context.plugins.register(run, telemetry, upgrade);
 
+    // For now, only register WCP related commands if
+    // `WCP_APP_URL` and `WCP_API_URL` env vars are defined.
+    if (process.env.WCP_APP_URL && process.env.WCP_API_URL) {
+        context.plugins.register(wcp);
+    }
     await context.loadUserPlugins();
 
     context.plugins.byType("cli-command").forEach(plugin => {

package/commands/wcp/api/getProjectEnvironmentBySlug.js

@@ -0,0 +1,108 @@
+const { localStorage, log } = require("@webiny/cli/utils");
+const { request } = require("graphql-request");
+
+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.getProjectEnvironmentBySlug = async ({
+    orgId,
+    projectId,
+    userId,
+    environmentSlug
+}) => {
+    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 { WCP_API_URL } = require(".");
+    const headers = { authorization: pat };
+    return request(
+        WCP_API_URL,
+        GET_ENVIRONMENT,
+        {
+            orgId,
+            projectId,
+            userId,
+            environmentId: environmentSlug
+        },
+        headers
+    )
+        .then(async response => response.projects.getEnvironment)
+        .catch(() => {
+            return request(
+                WCP_API_URL,
+                CREATE_ENVIRONMENT,
+                {
+                    orgId,
+                    projectId,
+                    userId,
+                    data: {
+                        name: environmentSlug
+                    }
+                },
+                headers
+            ).then(async response => response.projects.createEnvironment);
+        });
+};

package/commands/wcp/api/getUser.js

@@ -0,0 +1,94 @@
+const { localStorage, log } = require("@webiny/cli/utils");
+const { request } = require("graphql-request");
+
+const GET_CURRENT_USER = /* GraphQL */ `
+    query GetUser {
+        users {
+            getCurrentUser {
+                id
+                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 = 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.`
+        );
+    }
+
+    try {
+        const { WCP_API_URL } = require(".");
+        const headers = { authorization: pat };
+        user = await request(WCP_API_URL, GET_CURRENT_USER, {}, headers).then(async response => {
+            const user = response.users.getCurrentUser;
+
+            const orgs = await request(WCP_API_URL, 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(
+                        WCP_API_URL,
+                        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 again log in using the ${log.error.hl(
+                "yarn webiny login"
+            )} command.`
+        );
+    }
+
+    return user;
+};

package/commands/wcp/api/index.js

@@ -0,0 +1,14 @@
+const WCP_APP_URL = process.env.WCP_APP_URL || "https://wcp.webiny.com";
+const WCP_API_URL = process.env.WCP_API_URL || "https://api.wcp.webiny.com/graphql";
+
+const { getUser } = require("./getUser");
+const { getProjectEnvironmentBySlug } = require("./getProjectEnvironmentBySlug");
+const { updateUserLastActiveOn } = require("./updateUserLastActiveOn");
+
+module.exports = {
+    getUser,
+    getProjectEnvironmentBySlug,
+    updateUserLastActiveOn,
+    WCP_APP_URL,
+    WCP_API_URL
+};

package/commands/wcp/api/updateUserLastActiveOn.js

@@ -0,0 +1,28 @@
+const { request } = require("graphql-request");
+const { localStorage, log } = require("@webiny/cli/utils");
+
+const UPDATE_LAST_ACTIVE_TO_NOW = /* GraphQL */ `
+    mutation UpdateLastActiveToNow {
+        users {
+            updateLastActiveToNow {
+                id
+                lastActiveOn
+            }
+        }
+    }
+`;
+
+module.exports.updateUserLastActiveOn = async () => {
+    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 { WCP_API_URL } = require(".");
+    const headers = { authorization: pat };
+    return request(WCP_API_URL, UPDATE_LAST_ACTIVE_TO_NOW, {}, headers);
+};

package/commands/wcp/hooks.js

@@ -0,0 +1,67 @@
+const { getUser, getProjectEnvironmentBySlug, updateUserLastActiveOn } = require("./api");
+
+module.exports = () => [
+    // Within this hook, we're setting the `WCP_ENVIRONMENT_API_KEY` env variable, which can then be used in
+    // build / deploy steps. For example, we pass it to GraphQL and Headless CMS Lambda functions.
+    {
+        type: "hook-before-deploy",
+        name: "hook-before-deploy-environment-api-key",
+        async hook(args, context) {
+            // If the `WCP_ENVIRONMENT_API_KEY` has already been assigned, no need to do anything.
+            if (process.env.WCP_ENVIRONMENT_API_KEY) {
+                return;
+            }
+
+            const environment = await getProjectEnvironment(args, context);
+            if (environment) {
+                process.env.WCP_ENVIRONMENT_API_KEY = environment.apiKey;
+            }
+        }
+    },
+    // Within this hook, we're updating user's "last active" field.
+    {
+        type: "hook-before-deploy",
+        name: "hook-before-deploy-update-last-active-on",
+        async hook(args, context) {
+            // Is this a user environment? If so, let's update his "last active" field.
+            const environment = await getProjectEnvironment(args, context);
+            if (environment && environment.user) {
+                await updateUserLastActiveOn();
+            }
+        }
+    }
+];
+
+const getProjectEnvironment = async (args, context) => {
+    // If the project isn't activated, also do nothing.
+    if (!context.project.config.id) {
+        return;
+    }
+
+    // The `id` has the orgId/projectId structure, for example `my-org-x/my-project-y`.
+    const orgProject = context.project.config.id;
+    const [orgId, projectId] = orgProject.split("/");
+
+    const isValidId = orgId && projectId;
+    if (!isValidId) {
+        throw new Error(
+            `It seems the project ID, specified in "webiny.project.ts" file, is invalid.`
+        );
+    }
+
+    // Check login.
+    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.`
+        );
+    }
+
+    return getProjectEnvironmentBySlug({
+        orgId,
+        projectId,
+        environmentSlug: args.env,
+        userId: user.id
+    });
+};

package/commands/wcp/index.js

@@ -0,0 +1,5 @@
+const login = require("./login");
+const project = require("./project");
+const hooks = require("./hooks");
+
+module.exports = [login(), project(), hooks()];

package/commands/wcp/login.js

@@ -0,0 +1,188 @@
+const open = require("open");
+const { GraphQLClient } = require("graphql-request");
+const { WCP_API_URL, WCP_APP_URL } = require("./api");
+
+// 120 retries * 2000ms interval = 4 minutes until the command returns an error.
+const LOGIN_RETRIES_COUNT = 30;
+const LOGIN_RETRIES_INTERVAL = 2000;
+
+const GENERATE_USER_PAT = /* GraphQL*/ `
+    mutation GenerateUserPat {
+        users {
+            generateUserPat
+        }
+    }
+`;
+
+const GET_USER_PAT = /* GraphQL*/ `
+    query GetUserPat($token: ID!) {
+        users {
+            getUserPat(token: $token) {
+                name
+                user {
+                    email
+                }
+            }
+        }
+    }
+`;
+
+module.exports = () => ({
+    type: "cli-command",
+    name: "cli-command-wcp-login",
+    create({ yargs, context }) {
+        yargs.command(
+            "login",
+            `Log in to the Webiny Control Panel`,
+            yargs => {
+                yargs.example("$0 login");
+                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 }) => {
+                const graphQLClient = new GraphQLClient(WCP_API_URL);
+                const token = await graphQLClient
+                    .request(GENERATE_USER_PAT)
+                    .then(({ users }) => users.generateUserPat);
+
+                const queryParams = `pat=${token}&pat_name=${encodeURIComponent(
+                    "Webiny CLI"
+                )}&ref=cli`;
+                const openUrl = `${WCP_APP_URL}/login/cli?${queryParams}`;
+
+                debug && context.debug(`Opening ${context.debug.hl(openUrl)}...`);
+                await open(openUrl);
+
+                const graphql = {
+                    variables: { token },
+                    headers: {
+                        Authorization: token
+                    }
+                };
+
+                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(false);
+                        }
+
+                        try {
+                            await graphQLClient.request(GET_USER_PAT, graphql.variables);
+                            clearInterval(interval);
+                            resolve(true);
+                        } 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 ${WCP_APP_URL}?`
+                    );
+                }
+
+                context.localStorage.set("wcpPat", token);
+
+                context.success(`You've successfully logged in to Webiny Control Panel!`);
+            }
+        );
+
+        yargs.command(
+            "logout",
+            `Log out from the Webiny Control Panel`,
+            yargs => {
+                yargs.example("$0 login");
+                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 () => {
+                context.info(`You've successfully logged out from Webiny Control Panel.`);
+
+                context.localStorage.set("wcpPat", null);
+            }
+        );
+
+        yargs.command(
+            "whoami",
+            `Display the current logged-in user`,
+            yargs => {
+                yargs.example("$0 login");
+                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 }) => {
+                const pat = context.localStorage.get("wcpPat");
+                if (!pat) {
+                    throw new Error(
+                        `It seems you are not logged in. Please login using the ${context.error.hl(
+                            "webiny login"
+                        )} command.`
+                    );
+                }
+
+                const graphQLClient = new GraphQLClient(WCP_API_URL);
+                graphQLClient.setHeaders({ authorization: pat });
+
+                try {
+                    const user = await graphQLClient
+                        .request(GET_USER_PAT, { token: pat })
+                        .then(({ users }) => users.getUserPat.user);
+
+                    context.info(
+                        `You are logged in to Webiny Control Panel as ${context.info.hl(
+                            user.email
+                        )}.`
+                    );
+                } catch (e) {
+                    if (debug) {
+                        context.debug(e);
+                    }
+                    throw new Error(
+                        `It seems you are not logged in. Please login using the ${context.error.hl(
+                            "webiny login"
+                        )} command.`
+                    );
+                }
+            }
+        );
+    }
+});

package/commands/wcp/project.js

@@ -0,0 +1,207 @@
+const { getUser } = require("./api");
+const { WCP_APP_URL } = require("./api");
+const open = require("open");
+const inquirer = require("inquirer");
+const path = require("path");
+const tsMorph = require("ts-morph");
+
+module.exports = () => [
+    {
+        type: "cli-command",
+        name: "cli-command-wcp-project",
+        create({ yargs, context }) {
+            yargs.command(
+                ["project <command>"],
+                `Webiny project-related commands`,
+                projectCommand => {
+                    projectCommand.command(
+                        "init",
+                        `Initialize a Webiny project`,
+                        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");
+                        },
+                        async () => {
+                            // Check login.
+                            const user = await getUser();
+
+                            // User already initialized a project?
+                            const { id } = context.project.config;
+                            if (id) {
+                                const project = user.projects.find(item => item.id === id);
+                                if (project) {
+                                    context.info(
+                                        `It seems this project was already initialized (project name: ${context.info.hl(
+                                            project.name
+                                        )}).`
+                                    );
+
+                                    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;
+                                    }
+                                }
+                            }
+
+                            // Get user's organizations.
+                            if (!user.orgs.length) {
+                                context.info(
+                                    "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 {
+                                context.info("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) {
+                                context.info(
+                                    `It seems there are no projects created within the ${context.info.hl(
+                                        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 {
+                                context.info(
+                                    `It seems there are multiple projects created within the ${context.info.hl(
+                                        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);
+                            }
+
+                            // Assign the necessary IDs into root `webiny.project.ts` project file.
+                            const webinyProjectPath = path.join(
+                                context.project.root,
+                                "webiny.project.ts"
+                            );
+
+                            const tsMorphProject = new tsMorph.Project();
+                            tsMorphProject.addSourceFileAtPath(webinyProjectPath);
+
+                            const source = tsMorphProject.getSourceFile(webinyProjectPath);
+
+                            const defaultExport = source.getFirstDescendant(node => {
+                                if (tsMorph.Node.isExportAssignment(node) === false) {
+                                    return false;
+                                }
+                                return node.getText().startsWith("export default ");
+                            });
+
+                            if (!defaultExport) {
+                                throw new Error(
+                                    `Could not find the default export in ${context.error.hl(
+                                        "webiny.project.ts"
+                                    )}.`
+                                );
+                            }
+
+                            // Get ObjectLiteralExpression within the default export and assign the `id` property to it.
+                            const exportedObjectLiteral = defaultExport.getFirstDescendant(
+                                node => tsMorph.Node.isObjectLiteralExpression(node) === true
+                            );
+
+                            const existingIdProperty = exportedObjectLiteral.getProperty(node => {
+                                return (
+                                    tsMorph.Node.isPropertyAssignment(node) &&
+                                    node.getName() === "id"
+                                );
+                            });
+
+                            if (tsMorph.Node.isPropertyAssignment(existingIdProperty)) {
+                                existingIdProperty.setInitializer(`"${selectedProject.id}"`);
+                            } else {
+                                exportedObjectLiteral.insertProperty(
+                                    0,
+                                    `id: "${selectedOrg.id}/${selectedProject.id}"`
+                                );
+                            }
+
+                            await tsMorphProject.save();
+                        }
+                    );
+                }
+            );
+        }
+    },
+    {
+        type: "cli-plugi"
+    }
+];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/cli",
-	"version": "5.22.0",
+	"version": "5.23.0-beta.1",
 	"main": "index.js",
 	"bin": {
 		"webiny": "./bin.js"
@@ -13,7 +13,7 @@
 	"author": "Pavel Denisjuk <pavel@webiny.com>",
 	"description": "A tool to bootstrap a Webiny project.",
 	"dependencies": {
-		"@webiny/telemetry": "5.22.0",
+		"@webiny/telemetry": "5.23.0-beta.1",
 		"boolean": "3.1.4",
 		"camelcase": "5.3.1",
 		"chalk": "4.1.2",
@@ -21,8 +21,12 @@
 		"execa": "2.1.0",
 		"fast-glob": "3.2.7",
 		"find-up": "5.0.0",
-		"pirates": "4.0.4",
+		"graphql-request": "3.7.0",
+		"inquirer": "7.3.3",
+		"open": "8.4.0",
+		"pirates": "4.0.5",
 		"semver": "7.3.4",
+		"ts-morph": "11.0.3",
 		"typescript": "4.1.3",
 		"uniqid": "5.4.0",
 		"yargs": "14.2.3"
@@ -59,5 +63,5 @@
 			]
 		}
 	},
-	"gitHead": "ab2ca1af058fdec3aa1bed3f30afd51f4592dbb6"
+	"gitHead": "04f2d5e43684b9086251e2a6370b3c085e6d51cb"
 }