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

package/index.d.ts

@@ -0,0 +1,5 @@
+import {CliContext} from "./types";
+
+export * from "./regions"
+
+export declare const cli: CliContext;

package/index.js

@@ -0,0 +1,5 @@
+const context = require("./context");
+const regions = require("./regions");
+
+module.exports.cli = context;
+module.exports.regions = regions;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/cli",
-	"version": "0.0.0-mt-3",
+	"version": "0.0.0-unstable.06b2ede40f",
 	"main": "index.js",
 	"bin": {
 		"webiny": "./bin.js"
@@ -13,19 +13,28 @@
 	"author": "Pavel Denisjuk <pavel@webiny.com>",
 	"description": "A tool to bootstrap a Webiny project.",
 	"dependencies": {
-		"@webiny/telemetry": "0.0.0-mt-3",
-		"boolean": "3.1.4",
-		"camelcase": "5.3.1",
+		"@webiny/system-requirements": "0.0.0-unstable.06b2ede40f",
+		"@webiny/telemetry": "0.0.0-unstable.06b2ede40f",
+		"@webiny/wcp": "0.0.0-unstable.06b2ede40f",
+		"boolean": "3.2.0",
+		"camelcase": "6.3.0",
 		"chalk": "4.1.2",
-		"dotenv": "8.2.0",
-		"execa": "2.1.0",
-		"fast-glob": "3.2.7",
+		"ci-info": "4.2.0",
+		"dotenv": "8.6.0",
+		"execa": "5.1.1",
+		"fast-glob": "3.2.12",
 		"find-up": "5.0.0",
-		"pirates": "4.0.1",
-		"semver": "7.3.4",
-		"typescript": "4.1.3",
+		"fs-extra": "11.2.0",
+		"graphql-request": "3.7.0",
+		"inquirer": "8.2.6",
+		"ncp": "2.0.0",
+		"open": "8.4.2",
+		"pirates": "4.0.6",
+		"semver": "7.6.3",
+		"ts-morph": "11.0.3",
+		"typescript": "5.3.3",
 		"uniqid": "5.4.0",
-		"yargs": "14.2.3"
+		"yargs": "17.7.2"
 	},
 	"license": "MIT",
 	"publishConfig": {
@@ -43,9 +52,7 @@
 				"@webiny/project-utils",
 				"@webiny/api-file-manager",
 				"@webiny/cli-plugin-deploy-pulumi",
-				"@webiny/handler",
-				"@webiny/handler-http",
-				"@webiny/handler-args",
+				"@webiny/api",
 				"@webiny/handler-client",
 				"@webiny/api-elasticsearch",
 				"@webiny/api-tenancy",
@@ -59,5 +66,5 @@
 			]
 		}
 	},
-	"gitHead": "ebea815be2be99404591cba465cc1fe88355bd48"
+	"gitHead": "06b2ede40fc2212a70eeafd74afd50b56fb0ce82"
 }

package/regions.d.ts

@@ -0,0 +1,6 @@
+export interface RegionValue {
+    name: string;
+    value: string;
+}
+
+export declare const regions: RegionValue[];

package/regions.js

@@ -0,0 +1,30 @@
+const regions = [
+    { value: "us-east-1", name: "us-east-1 (US East, N. Virginia)" },
+    { value: "us-east-2", name: "us-east-2 (US East, Ohio)" },
+    { value: "us-west-1", name: "us-west-1 (US West, N. California)" },
+    { value: "us-west-2", name: "us-west-2 (US West, Oregon)" },
+    { value: "ca-central-1", name: "ca-central-1 (Canada, Central)" },
+    { value: "eu-central-1", name: "eu-central-1 (EU, Frankfurt)" },
+    { value: "eu-west-1", name: "eu-west-1 (EU, Ireland)" },
+    { value: "eu-west-2", name: "eu-west-2 (EU, London)" },
+    /**
+     * This was commented out because cognito was not available in this region in 2021.
+     * TODO - uncomment and test it out
+     */
+    /*{ value: "eu-south-1", name: "eu-south-1 (EU, Milan)" },*/
+    { value: "eu-west-3", name: "eu-west-3 (EU, Paris)" },
+    { value: "eu-north-1", name: "eu-north-1 (EU, Stockholm)" },
+    { value: "af-south-1", name: "af-south-1 (Africa, Cape Town)" },
+    { value: "ap-east-1", name: "ap-east-1 (Asia Pacific, Hong Kong)" },
+    { value: "ap-south-1", name: "ap-south-1 (Asia Pacific, Mumbai)" },
+    { value: "ap-northeast-2", name: "ap-northeast-2 (Asia Pacific, Seoul)" },
+    { value: "ap-southeast-1", name: "ap-southeast-1 (Asia Pacific, Singapore)" },
+    { value: "ap-southeast-2", name: "ap-southeast-2 (Asia Pacific, Sydney)" },
+    { value: "ap-northeast-1", name: "ap-northeast-1 (Asia Pacific, Tokyo)" },
+    // { value: "me-south-1", name: "me-south-1 (Middle East, Bahrain)" },
+    { value: "sa-east-1", name: "sa-east-1 (South America, São Paulo)" }
+];
+
+module.exports = {
+    regions
+};

package/types.d.ts

@@ -1,13 +1,20 @@
+import type yargs from "yargs";
+
 /**
  * Rename file to types.ts when switching the package to Typescript.
  */
+export type GenericRecord<K extends PropertyKey = PropertyKey, V = any> = Record<K, V>;
+
+export type NonEmptyArray<T> = [T, ...T[]];
 
 /**
  * A simplified plugins container interface, used specifically within the Webiny CLI.
  * Not in relation with "@webiny/plugins" package.
  */
 export interface PluginsContainer {
+    register(...args: any[]): void;
     byType<T extends Plugin>(type: T["type"]): T[];
+
     byName<T extends Plugin>(name: T["name"]): T;
 }
 
@@ -15,9 +22,10 @@ export interface PluginsContainer {
  * A simplified plugin interface, used specifically within the Webiny CLI.
  * Not in relation with "@webiny/plugins" package.
  */
-export interface Plugin<T = Record<string, any>> {
+export interface Plugin {
     type: string;
     name?: string;
+
     [key: string]: any;
 }
 
@@ -29,20 +37,93 @@ interface Project {
     /**
      * Configurations.
      */
-    config: Record<string, any>;
+    config: {
+        appAliases: {
+            [key: string]: string;
+        }
+        [key: string]: any;
+    };
     /**
      * Root path of the project.
      */
     root: string;
 }
 
+
+export interface IProjectApplicationPackage {
+    name: string;
+    paths: {
+        root: string;
+        relative: string;
+        packageJson: string;
+        config: string;
+    };
+    packageJson: Record<string, any>;
+    get config(): any;
+}
+
+export interface IProjectApplicationConfigCli {
+    watch?: boolean;
+}
+
+export interface IProjectApplicationConfig {
+    appAliases?: Record<string, string>;
+    cli?: IProjectApplicationConfigCli;
+    [key: string]: unknown
+}
+
+export interface ProjectApplication {
+    /**
+     * Unique ID of the project application.
+     */
+    id: string;
+    /**
+     * Name of the project application.
+     */
+    name: string;
+    /**
+     * Description of the project application.
+     */
+    description: string;
+    /**
+     * Type of the project application.
+     */
+    type: string;
+    /**
+     * Root path of the project application.
+     */
+    root: string;
+    /**
+     * Commonly used paths.
+     */
+    paths: {
+        relative: string;
+        absolute: string;
+        workspace: string;
+    };
+    /**
+     * Project application config (exported via `webiny.application.ts` file).
+     */
+    config: IProjectApplicationConfig;
+    /**
+     * Project application package.json.
+     */
+    project: Project;
+
+    /**
+     * A list of all the packages in the project application.
+     */
+    get packages(): IProjectApplicationPackage[];
+}
+
 /**
  * A type that represents the logging method.
  */
 interface Log {
-    (...args): string;
-    hl: (...args) => string;
-    highlight: (...args) => string;
+    (...args: any): string;
+
+    hl: (...args: any) => string;
+    highlight: (...args: any) => string;
 }
 
 /**
@@ -53,6 +134,10 @@ export interface CliContext {
      * All registered plugins.
      */
     plugins: PluginsContainer;
+    /**
+     * Load environment variables from a given file.
+     */
+    loadEnv(filePath: string, options?: {debug?: boolean}): Promise<void>;
     /**
      * All the environment variables.
      */
@@ -100,50 +185,50 @@ export interface CliContext {
     /**
      * Resolve given dir or dirs against project root path.
      */
-    resolve: (dir) => string;
+    resolve: (dir: string) => string;
 
     /**
-     * Provides a way to store some meta data in the project's local ".webiny/cli.json" file.
+     * Provides a way to store some metadata in the project's local ".webiny/cli.json" file.
      * Only trivial data should be passed here, specific to the current project.
      */
     localStorage: {
-        set: (key: string, value: string) => Record<string, any>;
+        set: (key: string, value: any) => Record<string, any>;
         get: (key: string) => any;
     };
 }
 
 /**
- * Args received from the CLI.
+ * Arguments for CliPlugin.create
+ *
+ * @category Cli
  */
-interface CliUpgradePluginOptions {
-    /**
-     * Targeted version of the upgrade.
-     */
-    targetVersion: string;
+export interface CliCommandPluginArgs {
+    yargs: typeof yargs;
+    context: CliContext;
 }
+
 /**
+ * A plugin defining cli-command type.
  *
+ * @category Plugin
+ * @category Cli
  */
-export interface CliUpgradePlugin extends Plugin {
-    /**
-     * Name of the plugin to differentiate from others.
-     * Something like: cli-upgrade-5.0.0
-     */
+export interface CliCommandPlugin extends Plugin {
+    type: "cli-command";
     name: string;
-    /**
-     * Type of the plugin.
-     */
-    type: "cli-upgrade";
-    /**
-     * Version the plugin is for.
-     */
-    version: string;
-    /**
-     * Is this plugin usable for the upgrade?
-     */
-    canUpgrade?: (options: CliUpgradePluginOptions, context: CliContext) => Promise<boolean>;
-    /**
-     * Apply the upgrade.
-     */
-    upgrade: (options: CliUpgradePluginOptions, context: CliContext) => Promise<void>;
+    create: (args: CliCommandPluginArgs) => void;
+}
+
+export interface CliCommandErrorPluginHandleParams {
+    context: CliContext;
+    error: Error;
+}
+
+export interface CliCommandErrorPluginHandle {
+    (params: CliCommandErrorPluginHandleParams):void;
+}
+
+export interface CliCommandErrorPlugin extends Plugin {
+    type: "cli-command-error";
+    handle: CliCommandErrorPluginHandle;
 }

package/utils/createProjectApplicationWorkspace.js

@@ -0,0 +1,16 @@
+const util = require("util");
+const fs = require("fs-extra");
+const ncpBase = require("ncp");
+const ncp = util.promisify(ncpBase.ncp);
+
+module.exports = async projectApplication => {
+    if (await fs.pathExists(projectApplication.paths.workspace)) {
+        await fs.remove(projectApplication.paths.workspace);
+    }
+
+    await fs.ensureDir(projectApplication.paths.workspace);
+    await ncp(projectApplication.paths.absolute, projectApplication.paths.workspace);
+
+    // Wait a bit and make sure the files are ready to have its content replaced.
+    return new Promise(resolve => setTimeout(resolve, 10));
+};

package/utils/ensureSameWebinyPackageVersions.js

@@ -0,0 +1,99 @@
+const execa = require("execa");
+const logger = require("./log");
+
+const DEBUG_FLAG = "--debug";
+const usingDebugFlag = process.argv.includes(DEBUG_FLAG);
+
+const SKIP_WEBINY_VERSIONS_CHECK_FLAG = "--no-package-versions-check";
+const skippingWebinyVersionsCheck = process.argv.includes(SKIP_WEBINY_VERSIONS_CHECK_FLAG);
+
+function listWebinyPackageVersions() {
+    const { stdout } = execa.sync("yarn", ["info", "@webiny/*", "--name-only", "--all", "--json"], {
+        encoding: "utf-8"
+    });
+
+    // Each line is a JSON string, so parse them individually
+    const lines = stdout
+        .trim()
+        .split("\n")
+        .map(line => JSON.parse(line));
+
+    const versionMap = new Map();
+
+    for (const entry of lines) {
+        // An example entry: "@webiny/cli@npm:5.42.3"
+        const match = entry.match(/^(@webiny\/[^@]+)@npm:(.+)$/);
+        if (!match) {
+            continue;
+        }
+
+        const [, pkg, version] = match;
+        if (!versionMap.has(pkg)) {
+            versionMap.set(pkg, new Set());
+        }
+
+        versionMap.get(pkg).add(version);
+    }
+
+    return versionMap;
+}
+
+function ensureSameWebinyPackageVersions() {
+    // Just in case, we want to allow users to skip the check.
+    if (skippingWebinyVersionsCheck) {
+        return;
+    }
+
+    let webinyVersions;
+    try {
+        webinyVersions = listWebinyPackageVersions();
+    } catch (e) {
+        const message = ["Failed to inspect Webiny package versions."];
+
+        if (!usingDebugFlag) {
+            message.push(
+                `For more information, try running with ${logger.warning.hl(DEBUG_FLAG)}.`
+            );
+        }
+
+        message.push("Learn more: https://webiny.link/webiny-package-versions-check");
+
+        logger.warning(message.join(" "));
+        if (usingDebugFlag) {
+            logger.debug(e);
+        }
+
+        console.log();
+        return;
+    }
+
+    let hasMismatch = false;
+    const mismatchedPackages = [];
+    for (const [pkg, versions] of webinyVersions.entries()) {
+        if (versions.size > 1) {
+            hasMismatch = true;
+            mismatchedPackages.push([pkg, versions]);
+        }
+    }
+
+    if (hasMismatch) {
+        const message = [
+            "The following Webiny packages have mismatched versions:",
+            "",
+            ...mismatchedPackages.map(([pkg, versions]) => {
+                return `‣ ${pkg}: ${Array.from(versions).join(", ")}`;
+            }),
+            "",
+            `Please ensure all Webiny packages are using the same version. If you think this is a mistake, you can also skip this check by appending the ${logger.error.hl(
+                SKIP_WEBINY_VERSIONS_CHECK_FLAG
+            )} flag. Learn more: https://webiny.link/webiny-package-versions-check`
+        ];
+
+        logger.error(message.join("\n"));
+        process.exit(1);
+    }
+}
+
+module.exports = {
+    ensureSameWebinyPackageVersions
+};

package/utils/getProjectApplication.js

@@ -1,4 +1,4 @@
-const { dirname, basename, join } = require("path");
+const { dirname, basename, join, relative } = require("path");
 const findUp = require("find-up");
 const getProject = require("./getProject");
 const { importModule } = require("./importModule");
@@ -15,31 +15,49 @@ module.exports = args => {
     }
 
     const rootFile = applicationRootFile.replace(/\\/g, "/");
-    const applicationRoot = dirname(rootFile);
+    const projectAppRootPath = dirname(rootFile);
 
     let applicationConfig;
     if (appConfigs.includes(basename(rootFile))) {
         applicationConfig = importModule(rootFile);
     }
 
-    let name, id;
+    let id, name, description;
     if (applicationConfig) {
         id = applicationConfig.id;
         name = applicationConfig.name;
+        description = applicationConfig.description;
     } else {
-        name = basename(applicationRoot);
+        name = basename(projectAppRootPath);
+        description = name;
         id = name;
     }
 
+    const project = getProject(args);
+
+    const projectAppRelativePath = relative(project.root, projectAppRootPath);
+    const projectAppWorkspacePath = join(
+        project.root,
+        ".webiny",
+        "workspaces",
+        projectAppRelativePath
+    );
+
     return {
         id,
         name,
-        root: applicationRoot,
+        description,
+        root: projectAppRootPath,
+        paths: {
+            relative: projectAppRelativePath,
+            absolute: projectAppRootPath,
+            workspace: projectAppWorkspacePath
+        },
         config: applicationConfig,
-        project: getProject(args),
+        project,
         get packages() {
             const webinyConfigs = glob.sync(
-                join(applicationRoot, "**/webiny.config*.{ts,js}").replace(/\\/g, "/")
+                join(projectAppRootPath, "**/webiny.config*.{ts,js}").replace(/\\/g, "/")
             );
 
             return webinyConfigs.map(config => {
@@ -48,6 +66,8 @@ module.exports = args => {
                 return {
                     name: packageJson.name,
                     paths: {
+                        absolute: dirname(config),
+                        relative: relative(project.root, dirPath),
                         root: dirname(config),
                         packageJson: join(dirPath, "package.json"),
                         config

package/utils/index.d.ts

@@ -0,0 +1,28 @@
+import { Project, ProjectApplication } from "../types";
+
+export interface IGetProjectParams {
+    cwd: string;
+}
+
+export declare function getProject(params?: IGetProjectParams): Project;
+
+export interface IGetProjectApplicationParams {
+    cwd: string;
+}
+
+export declare function getProjectApplication(
+    params: IGetProjectApplicationParams
+): ProjectApplication;
+
+export declare function sendEvent(event: string, properties?: Record<string, any>): Promise<void>;
+
+export declare function sleepSync(ms?: number): void;
+
+export declare const log: {
+    log: ((...args: any[]) => void) & { hl: (message: string) => string };
+    info: ((...args: any[]) => void) & { hl: (message: string) => string };
+    success: ((...args: any[]) => void) & { hl: (message: string) => string };
+    debug: ((...args: any[]) => void) & { hl: (message: string) => string };
+    warning: ((...args: any[]) => void) & { hl: (message: string) => string };
+    error: ((...args: any[]) => void) & { hl: (message: string) => string };
+};

package/utils/index.js

@@ -1,17 +1,28 @@
 const { importModule } = require("./importModule");
+const createProjectApplicationWorkspace = require("./createProjectApplicationWorkspace");
 const getProject = require("./getProject");
 const getProjectApplication = require("./getProjectApplication");
 const localStorage = require("./localStorage");
 const log = require("./log");
 const sendEvent = require("./sendEvent");
 const PluginsContainer = require("./PluginsContainer");
+const sleep = require("./sleep");
+const sleepSync = require("./sleepSync");
+
+const noop = () => {
+    // Do nothing.
+};
 
 module.exports = {
-    importModule,
+    createProjectApplicationWorkspace,
     getProject,
     getProjectApplication,
+    importModule,
     localStorage,
     log,
+    noop,
     sendEvent,
-    PluginsContainer
+    PluginsContainer,
+    sleep,
+    sleepSync
 };

package/utils/loadEnvVariables.js

@@ -0,0 +1,63 @@
+const path = require("path");
+const yargs = require("yargs");
+const log = require("./log");
+const getProject = require("./getProject");
+const { boolean } = require("boolean");
+
+// Load environment variables from following sources:
+// - `webiny.project.ts` file
+// - `.env` file
+// - `.env.{PASSED_ENVIRONMENT}` file
+
+const project = getProject();
+
+// `webiny.project.ts` file.
+// Environment variables defined via the `env` property.
+if (project.config.env) {
+    Object.assign(process.env, project.config.env);
+}
+
+// `.env.{PASSED_ENVIRONMENT}` and `.env` files.
+let paths = [path.join(project.root, ".env")];
+
+if (yargs.argv.env) {
+    paths.push(path.join(project.root, `.env.${yargs.argv.env}`));
+}
+
+// If the `WCP_PROJECT_ID` environment variable is not set already, we check if there's
+// a WCP project ID set via the `webiny.project.ts` config file. If so, we assign it
+// to the `WCP_PROJECT_ID` environment variable.
+if (!process.env.WCP_PROJECT_ID) {
+    if (project.config.id) {
+        process.env.WCP_PROJECT_ID = project.config.id;
+    }
+}
+
+// Let's load environment variables
+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)}.`);
+        }
+    }
+}
+
+// Feature flags defined via the `featureFlags` property.
+// We set twice, to be available for both backend and frontend application code.
+// TODO: one day we might want to sync this up a bit.
+if (project.config.featureFlags) {
+    process.env.WEBINY_FEATURE_FLAGS = JSON.stringify(project.config.featureFlags);
+    process.env.REACT_APP_WEBINY_FEATURE_FLAGS = JSON.stringify(project.config.featureFlags);
+}
+
+// With 5.38.0, we are hiding the `WEBINY_ELASTICSEARCH_INDEX_LOCALE` env variable and always setting it to `true`.
+// This is because this variable is not something users should be concerned with, nor should they be able to change it.
+// In order to ensure backwards compatibility, we first check if the variable is set, and if it is, we don't override it.
+const esIndexLocaleEnvVarExists = "WEBINY_ELASTICSEARCH_INDEX_LOCALE" in process.env;
+if (!esIndexLocaleEnvVarExists) {
+    process.env.WEBINY_ELASTICSEARCH_INDEX_LOCALE = "true";
+}