@webiny/cli 0.0.0-mt-1

package/types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Rename file to types.ts when switching the package to Typescript.
+ */
+
+/**
+ * A simplified plugins container interface, used specifically within the Webiny CLI.
+ * Not in relation with "@webiny/plugins" package.
+ */
+export interface PluginsContainer {
+    byType<T extends Plugin>(type: T["type"]): T[];
+    byName<T extends Plugin>(name: T["name"]): T;
+}
+
+/**
+ * A simplified plugin interface, used specifically within the Webiny CLI.
+ * Not in relation with "@webiny/plugins" package.
+ */
+export interface Plugin<T = Record<string, any>> {
+    type: string;
+    name?: string;
+    [key: string]: any;
+}
+
+interface Project {
+    /**
+     * Name of the project.
+     */
+    name: string;
+    /**
+     * Configurations.
+     */
+    config: Record<string, any>;
+    /**
+     * Root path of the project.
+     */
+    root: string;
+}
+
+/**
+ * A type that represents the logging method.
+ */
+interface Log {
+    (...args): string;
+    hl: (...args) => string;
+    highlight: (...args) => string;
+}
+
+/**
+ * Interface representing the CLI Context.
+ */
+export interface CliContext {
+    /**
+     * All registered plugins.
+     */
+    plugins: PluginsContainer;
+    /**
+     * All the environment variables.
+     */
+    loadedEnvFiles: Record<string, any>;
+    /**
+     * Version of the Webiny CLI.
+     */
+    version: string;
+    /**
+     * Project information.
+     */
+    project: Project;
+    /**
+     * Trigger given callback on SIGINT.
+     */
+    onExit: (cb: () => any) => void;
+    /**
+     * Import a given module.
+     */
+    import: (module: string) => Promise<void>;
+    /**
+     * Regular logging.
+     */
+    log: Log;
+    /**
+     * Info logging.
+     */
+    info: Log;
+    /**
+     * Success logging.
+     */
+    success: Log;
+    /**
+     * Debug logging.
+     */
+    debug: Log;
+    /**
+     * Warnings logging.
+     */
+    warning: Log;
+    /**
+     * Errors logging.
+     */
+    error: Log;
+    /**
+     * Resolve given dir or dirs against project root path.
+     */
+    resolve: (dir) => string;
+
+    /**
+     * Provides a way to store some meta data 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>;
+        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/PluginsContainer.js

@@ -0,0 +1,49 @@
+const uniqid = require("uniqid");
+
+// Since the Webiny CLI can rely on "@webiny/plugins" package (chicken-egg problem), then
+// we need to make a copy of its PluginsContainer class. We removed all of the extra
+// features that are in reality not needed for the Webiny CLI.
+const assign = (plugins, target) => {
+    for (let i = 0; i < plugins.length; i++) {
+        const plugin = plugins[i];
+        if (Array.isArray(plugin)) {
+            assign(plugin, target);
+            continue;
+        }
+
+        let name = plugin._name || plugin.name;
+        if (!name) {
+            plugin.name = name = uniqid(plugin.type + "-");
+        }
+
+        target[name] = plugin;
+    }
+};
+
+module.exports = class PluginsContainer {
+    plugins = {};
+    constructor(...args) {
+        this.register(...args);
+    }
+
+    byName(name) {
+        return this.plugins[name];
+    }
+
+    byType(type) {
+        const plugins = this.findByType(type);
+        return Array.from(plugins);
+    }
+
+    findByType(type) {
+        return Object.values(this.plugins).filter(pl => pl.type === type);
+    }
+
+    register(...args) {
+        assign(args, this.plugins);
+    }
+
+    unregister(name) {
+        delete this.plugins[name];
+    }
+};

package/utils/getProject.js

@@ -0,0 +1,48 @@
+const findUp = require("find-up");
+const { dirname } = require("path");
+const { importModule } = require("./importModule");
+
+const projectConfigs = ["webiny.project.js", "webiny.project.ts"];
+
+function getRoot({ cwd } = {}) {
+    let root = findUp.sync(projectConfigs, { cwd });
+    if (root) {
+        return dirname(root).replace(/\\/g, "/");
+    }
+
+    // For backwards compatibility
+    root = findUp.sync("webiny.root.js", { cwd });
+    if (root) {
+        return dirname(root).replace(/\\/g, "/");
+    }
+
+    throw new Error("Couldn't detect Webiny project.");
+}
+
+function getConfig({ cwd } = {}) {
+    let path = findUp.sync(projectConfigs, { cwd });
+    if (path) {
+        return importModule(path);
+    }
+
+    path = findUp.sync("webiny.root.js", { cwd });
+    if (path) {
+        return require(path);
+    }
+
+    throw new Error("Couldn't detect Webiny project.");
+}
+
+module.exports = args => {
+    const root = getRoot(args);
+    return {
+        get name() {
+            // Check "projectName" for backwards compatibility.
+            return process.env.WEBINY_PROJECT_NAME || this.config.projectName || this.config.name;
+        },
+        root,
+        get config() {
+            return getConfig(args);
+        }
+    };
+};

package/utils/getProjectApplication.js

@@ -0,0 +1,63 @@
+const { dirname, basename, join } = require("path");
+const findUp = require("find-up");
+const getProject = require("./getProject");
+const { importModule } = require("./importModule");
+const glob = require("fast-glob");
+
+const appConfigs = ["webiny.application.js", "webiny.application.ts"];
+
+module.exports = args => {
+    // Using "Pulumi.yaml" for the backwards compatibility.
+    const applicationRootFile = findUp.sync(appConfigs.concat("Pulumi.yaml"), { cwd: args.cwd });
+
+    if (!applicationRootFile) {
+        throw new Error(`Could not detect project application in given directory (${args.cwd}).`);
+    }
+
+    const rootFile = applicationRootFile.replace(/\\/g, "/");
+    const applicationRoot = dirname(rootFile);
+
+    let applicationConfig;
+    if (appConfigs.includes(basename(rootFile))) {
+        applicationConfig = importModule(rootFile);
+    }
+
+    let name, id;
+    if (applicationConfig) {
+        id = applicationConfig.id;
+        name = applicationConfig.name;
+    } else {
+        name = basename(applicationRoot);
+        id = name;
+    }
+
+    return {
+        id,
+        name,
+        root: applicationRoot,
+        config: applicationConfig,
+        project: getProject(args),
+        get packages() {
+            const webinyConfigs = glob.sync(
+                join(applicationRoot, "**/webiny.config*.{ts,js}").replace(/\\/g, "/")
+            );
+
+            return webinyConfigs.map(config => {
+                const dirPath = dirname(config);
+                const packageJson = require(join(dirPath, "package.json"));
+                return {
+                    name: packageJson.name,
+                    paths: {
+                        root: dirname(config),
+                        packageJson: join(dirPath, "package.json"),
+                        config
+                    },
+                    packageJson,
+                    get config() {
+                        return require(config).default || require(config);
+                    }
+                };
+            });
+        }
+    };
+};

package/utils/importModule.js

@@ -0,0 +1,43 @@
+const fs = require("fs");
+const path = require("path");
+const { addHook } = require("pirates");
+
+/**
+ * Add support for TS
+ */
+
+addHook(
+    code => {
+        const ts = require("typescript");
+        const { outputText } = ts.transpileModule(code, {
+            compilerOptions: {
+                target: "es6",
+                allowJs: true,
+                allowSyntheticDefaultImports: true,
+                esModuleInterop: true,
+                outDir: "bin",
+                moduleResolution: "node",
+                module: "commonjs"
+            }
+        });
+
+        return outputText;
+    },
+    {
+        exts: [".ts"],
+        matcher: () => true
+    }
+);
+
+module.exports.importModule = configPath => {
+    if (!fs.existsSync(configPath)) {
+        throw Error(`"${configPath}" does not exist!`);
+    }
+
+    const extension = path.extname(configPath);
+    if (extension === ".ts") {
+        return require(configPath).default;
+    } else {
+        return require(configPath);
+    }
+};

package/utils/index.js

@@ -0,0 +1,17 @@
+const { importModule } = require("./importModule");
+const getProject = require("./getProject");
+const getProjectApplication = require("./getProjectApplication");
+const localStorage = require("./localStorage");
+const log = require("./log");
+const sendEvent = require("./sendEvent");
+const PluginsContainer = require("./PluginsContainer");
+
+module.exports = {
+    importModule,
+    getProject,
+    getProjectApplication,
+    localStorage,
+    log,
+    sendEvent,
+    PluginsContainer
+};

package/utils/localStorage.js

@@ -0,0 +1,44 @@
+// This is a small class that enables us to store some useful
+// data into the .webiny folder, located in the project root.
+// For example, we are saving the path entered while creating
+// GraphQL services, so that the user doesn't have to type
+// the same paths over and over.
+const fs = require("fs");
+const path = require("path");
+const getProject = require("./getProject");
+
+module.exports = function (filename = "cli.json") {
+    const project = getProject();
+    const DOT_WEBINY = path.join(project.root, ".webiny");
+    const dataFilePath = path.join(DOT_WEBINY, filename);
+
+    let data = {};
+    if (fs.existsSync(dataFilePath)) {
+        try {
+            data = JSON.parse(fs.readFileSync(dataFilePath));
+        } catch (e) {
+            throw new Error(
+                `Could not parse Webiny CLI's locale storage data file located at ${dataFilePath}.`
+            );
+        }
+    }
+
+    return {
+        set(key, value) {
+            data[key] = value;
+
+            if (!fs.existsSync(DOT_WEBINY)) {
+                fs.mkdirSync(DOT_WEBINY);
+            }
+
+            fs.writeFileSync(dataFilePath, JSON.stringify(data));
+            return data;
+        },
+        get(key) {
+            if (!key) {
+                return data;
+            }
+            return data[key];
+        }
+    };
+};

package/utils/log.js

@@ -0,0 +1,69 @@
+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 webinyLog = (type, ...args) => {
+    const prefix = `webiny ${getLogType(type)}: `;
+
+    const [first, ...rest] = args;
+    if (typeof first === "string") {
+        return console.log(prefix + first, ...rest);
+    }
+    return console.log(prefix, first, ...rest);
+};
+
+const functions = {
+    log(...args) {
+        webinyLog("log", ...args);
+    },
+
+    info(...args) {
+        webinyLog("info", ...args);
+    },
+
+    success(...args) {
+        webinyLog("success", ...args);
+    },
+
+    debug(...args) {
+        webinyLog("debug", ...args);
+    },
+
+    warning(...args) {
+        webinyLog("warning", ...args);
+    },
+
+    error(...args) {
+        webinyLog("error", ...args);
+    }
+};
+
+functions.log.highlight = chalk.highlight;
+functions.log.hl = chalk.highlight;
+functions.info.highlight = chalk.blue;
+functions.info.hl = chalk.blueBright;
+functions.success.highlight = chalk.green;
+functions.success.hl = chalk.green;
+functions.debug.highlight = chalk.gray;
+functions.debug.hl = chalk.gray;
+functions.warning.highlight = chalk.yellow;
+functions.warning.hl = chalk.yellow;
+functions.error.highlight = chalk.red;
+functions.error.hl = chalk.red;
+
+module.exports = functions;

package/utils/sendEvent.js

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