@webiny/cli 0.0.0-unstable.fcdad0bc61 → 0.0.0-unstable.fdd9228b5d

package/index.d.ts

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

package/index.js

@@ -1,3 +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-unstable.fcdad0bc61",
+	"version": "0.0.0-unstable.fdd9228b5d",
 	"main": "index.js",
 	"bin": {
 		"webiny": "./bin.js"
@@ -13,26 +13,28 @@
 	"author": "Pavel Denisjuk <pavel@webiny.com>",
 	"description": "A tool to bootstrap a Webiny project.",
 	"dependencies": {
-		"@webiny/telemetry": "0.0.0-unstable.fcdad0bc61",
-		"@webiny/wcp": "0.0.0-unstable.fcdad0bc61",
-		"boolean": "3.1.4",
-		"camelcase": "5.3.1",
+		"@webiny/system-requirements": "0.0.0-unstable.fdd9228b5d",
+		"@webiny/telemetry": "0.0.0-unstable.fdd9228b5d",
+		"@webiny/wcp": "0.0.0-unstable.fdd9228b5d",
+		"boolean": "3.2.0",
+		"camelcase": "6.3.0",
 		"chalk": "4.1.2",
-		"dotenv": "8.2.0",
+		"ci-info": "4.2.0",
+		"dotenv": "8.6.0",
 		"execa": "5.1.1",
-		"fast-glob": "3.2.7",
+		"fast-glob": "3.2.12",
 		"find-up": "5.0.0",
-		"fs-extra": "9.1.0",
+		"fs-extra": "11.2.0",
 		"graphql-request": "3.7.0",
-		"inquirer": "7.3.3",
+		"inquirer": "8.2.6",
 		"ncp": "2.0.0",
-		"open": "8.4.0",
-		"pirates": "4.0.5",
-		"semver": "7.3.8",
+		"open": "8.4.2",
+		"pirates": "4.0.6",
+		"semver": "7.6.3",
 		"ts-morph": "11.0.3",
-		"typescript": "4.7.4",
+		"typescript": "5.3.3",
 		"uniqid": "5.4.0",
-		"yargs": "17.6.0"
+		"yargs": "17.7.2"
 	},
 	"license": "MIT",
 	"publishConfig": {
@@ -64,5 +66,5 @@
 			]
 		}
 	},
-	"gitHead": "40d639c3665e384a5e2d26674d43ce26f3295e8c"
+	"gitHead": "fdd9228b5d2636463e8a34b6e0d26eea1e29c01d"
 }

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;
 }
 
@@ -18,6 +25,7 @@ export interface PluginsContainer {
 export interface Plugin {
     type: string;
     name?: string;
+
     [key: string]: any;
 }
 
@@ -29,18 +37,91 @@ 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: 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.
      */
@@ -103,11 +188,47 @@ export interface CliContext {
     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;
     };
 }
+
+/**
+ * Arguments for CliPlugin.create
+ *
+ * @category Cli
+ */
+export interface CliCommandPluginArgs {
+    yargs: typeof yargs;
+    context: CliContext;
+}
+
+/**
+ * A plugin defining cli-command type.
+ *
+ * @category Plugin
+ * @category Cli
+ */
+export interface CliCommandPlugin extends Plugin {
+    type: "cli-command";
+    name: string;
+    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/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

@@ -43,16 +43,10 @@ module.exports = args => {
         projectAppRelativePath
     );
 
-    // If we're missing the `pulumi` property in the `applicationConfig` object, that
-    // means we're dealing with an old project application where all of the Pulumi code is
-    // located in user's project. New projects applications have this code abstracted away.
-    const type = applicationConfig.pulumi ? "v5-workspaces" : "v5";
-
     return {
         id,
         name,
         description,
-        type,
         root: projectAppRootPath,
         paths: {
             relative: projectAppRelativePath,
@@ -72,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

@@ -1 +1,28 @@
-export function getApiProjectApplicationFolder(project: Record<string, any>): boolean;
+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

@@ -2,11 +2,12 @@ const { importModule } = require("./importModule");
 const createProjectApplicationWorkspace = require("./createProjectApplicationWorkspace");
 const getProject = require("./getProject");
 const getProjectApplication = require("./getProjectApplication");
-const getApiProjectApplicationFolder = require("./getApiProjectApplicationFolder");
 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.
@@ -14,7 +15,6 @@ const noop = () => {
 
 module.exports = {
     createProjectApplicationWorkspace,
-    getApiProjectApplicationFolder,
     getProject,
     getProjectApplication,
     importModule,
@@ -22,5 +22,7 @@ module.exports = {
     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";
+}

package/utils/sendEvent.js

@@ -1,15 +1,11 @@
 const { sendEvent } = require("@webiny/telemetry/cli");
 const getProject = require("./getProject");
 
-module.exports = ({ event, properties, extraPayload }) => {
+module.exports = (event, properties) => {
     const project = getProject();
     if (project.config.cli && project.config.cli.telemetry === false) {
         return;
     }
 
-    return sendEvent({
-        event,
-        properties,
-        extraPayload
-    });
+    return sendEvent({ event, properties });
 };

package/utils/sleep.js

@@ -0,0 +1,3 @@
+const sleep = (ms = 1500) => new Promise(resolve => setTimeout(resolve, ms));
+
+module.exports = sleep;

package/utils/sleepSync.js

@@ -0,0 +1,8 @@
+const sleepSync = (ms = 1500) => {
+    const start = Date.now();
+    while (Date.now() < start + ms) {
+        // Do nothing.
+    }
+};
+
+module.exports = sleepSync;

package/utils/suppressPunycodeWarnings.js

@@ -0,0 +1,7 @@
+const originalConsoleError = console.error;
+console.error = (message, ...args) => {
+    if (typeof message === "string" && message.includes("punycode")) {
+        return;
+    }
+    originalConsoleError.call(console, message, ...args);
+};