@webiny/cli 0.0.0-mt-2 → 0.0.0-unstable.1145e7667f

package/types.d.ts

@@ -15,7 +15,7 @@ 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;
@@ -40,9 +40,9 @@ interface Project {
  * 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;
 }
 
 /**
@@ -100,7 +100,7 @@ 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.
@@ -111,39 +111,3 @@ export interface CliContext {
         get: (key: string) => any;
     };
 }
-
-/**
- * Args received from the CLI.
- */
-interface CliUpgradePluginOptions {
-    /**
-     * Targeted version of the upgrade.
-     */
-    targetVersion: string;
-}
-/**
- *
- */
-export interface CliUpgradePlugin extends Plugin {
-    /**
-     * Name of the plugin to differentiate from others.
-     * Something like: cli-upgrade-5.0.0
-     */
-    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>;
-}

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/getApiProjectApplicationFolder.js

@@ -0,0 +1,12 @@
+const fs = require("fs");
+const path = require("path");
+
+// This function has been created in order to help preserve backwards compatibility
+// (from 5.29.0, the `api` app has been moved into the `apps/api` directory).
+module.exports = project => {
+    if (fs.existsSync(path.join(project.root, "api"))) {
+        return "api";
+    }
+
+    return "apps/api";
+};

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,55 @@ 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
+    );
+
+    // 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,
-        root: applicationRoot,
+        description,
+        type,
+        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 => {

package/utils/index.d.ts

@@ -0,0 +1 @@
+export function getApiProjectApplicationFolder(project: Record<string, any>): boolean;

package/utils/index.js

@@ -1,17 +1,26 @@
 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 noop = () => {
+    // Do nothing.
+};
+
 module.exports = {
-    importModule,
+    createProjectApplicationWorkspace,
+    getApiProjectApplicationFolder,
     getProject,
     getProjectApplication,
+    importModule,
     localStorage,
     log,
+    noop,
     sendEvent,
     PluginsContainer
 };

package/utils/loadEnvVariables.js

@@ -0,0 +1,46 @@
+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}`));
+}
+
+// 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);
+}

package/utils/log.js

@@ -1,28 +1,26 @@
 const chalk = require("chalk");
 
-const getLogType = type => {
-    switch (type) {
-        case "log":
-            return type;
-        case "info":
-            return `${chalk.blueBright(type)}`;
-        case "error":
-            return `${chalk.red(type)}`;
-        case "warning":
-            return `${chalk.yellow(type)}`;
-        case "debug":
-            return `${chalk.gray(type)}`;
-        case "success":
-            return `${chalk.green(type)}`;
-    }
+const logColors = {
+    log: v => v,
+    info: chalk.blueBright,
+    error: chalk.red,
+    warning: chalk.yellow,
+    debug: chalk.gray,
+    success: chalk.green
+};
+
+const colorizePlaceholders = (type, string) => {
+    return string.replace(/\%[a-zA-Z]/g, match => {
+        return logColors[type](match);
+    });
 };
 
 const webinyLog = (type, ...args) => {
-    const prefix = `webiny ${getLogType(type)}: `;
+    const prefix = `webiny ${logColors[type](type)}: `;
 
     const [first, ...rest] = args;
     if (typeof first === "string") {
-        return console.log(prefix + first, ...rest);
+        return console.log(prefix + colorizePlaceholders(type, first), ...rest);
     }
     return console.log(prefix, first, ...rest);
 };