@schalkneethling/miyagi-core 4.3.0 → 4.4.0

package/lib/cli/run.js

@@ -0,0 +1,281 @@
+import { t } from "../i18n/index.js";
+import initRendering from "../init/rendering.js";
+import log from "../logger.js";
+import mockGenerator from "../generator/mocks.js";
+import getConfig from "../config.js";
+import createCli from "../init/args.js";
+import {
+	lint,
+	component as createComponentViaCli,
+	drupalAssets,
+	doctor,
+} from "./index.js";
+import { EXIT_CODES, MiyagiError } from "../errors.js";
+
+/**
+ * @returns {object}
+ */
+function createSuccessResult() {
+	return {
+		success: true,
+		code: EXIT_CODES.SUCCESS,
+		shouldExit: true,
+	};
+}
+
+/**
+ * @param {string} message
+ * @param {number} [code]
+ * @returns {object}
+ */
+function createFailureResult(message, code = EXIT_CODES.GENERAL_ERROR) {
+	log("error", message);
+	return {
+		success: false,
+		code,
+		shouldExit: true,
+		message,
+	};
+}
+
+/**
+ * @param {number} code
+ * @param {string[]} argv
+ * @returns {void}
+ */
+function maybeLogDoctorHint(code, argv) {
+	if (code !== EXIT_CODES.CONFIG_ERROR) {
+		return;
+	}
+
+	if (argv.includes("doctor")) {
+		return;
+	}
+
+	log("info", "Run `miyagi doctor` for a setup check.");
+}
+
+/**
+ * @param {object} args
+ * @param {boolean} [isBuild]
+ * @param {boolean} [isComponentGenerator]
+ * @returns {Promise<object>}
+ */
+async function loadCliConfig(args, isBuild = false, isComponentGenerator = false) {
+	global.config = await getConfig(args, isBuild, isComponentGenerator);
+
+	if (!global.config.components.folder && !global.config.docs.folder) {
+		return createFailureResult(
+			"Please specify at least either components.folder or docs.folder in your configuration file.",
+			EXIT_CODES.CONFIG_ERROR,
+		);
+	}
+
+	return {
+		success: true,
+		config: global.config,
+	};
+}
+
+/**
+ * @param {object} args
+ * @returns {void}
+ */
+function applyCliEnv(args) {
+	if (args.verbose) {
+		process.env.VERBOSE = String(args.verbose);
+	}
+}
+
+/**
+ * @param {object} args
+ * @param {object} [options]
+ * @param {string} [options.defaultNodeEnv]
+ * @param {string} [options.forcedNodeEnv]
+ * @param {boolean} [options.isBuild]
+ * @param {boolean} [options.isComponentGenerator]
+ * @param {Function} run
+ * @returns {Promise<object>}
+ */
+async function withCliConfig(args, options = {}, run) {
+	applyCliEnv(args);
+
+	if (options.forcedNodeEnv) {
+		process.env.NODE_ENV = options.forcedNodeEnv;
+	} else if (options.defaultNodeEnv && !process.env.NODE_ENV) {
+		process.env.NODE_ENV = options.defaultNodeEnv;
+	}
+
+	const configResult = await loadCliConfig(
+		args,
+		options.isBuild,
+		options.isComponentGenerator,
+	);
+	if (!configResult.success) {
+		return configResult;
+	}
+
+	return await run(configResult.config);
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+async function runStartCommand(args) {
+	return await withCliConfig(
+		args,
+		{ defaultNodeEnv: "development" },
+		async (config) => {
+			log(
+				"info",
+				t("serverStarting").replace("{{node_env}}", process.env.NODE_ENV),
+			);
+
+			return await initRendering(config);
+		},
+	);
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+async function runBuildCommand(args) {
+	return await withCliConfig(
+		args,
+		{ forcedNodeEnv: "production", isBuild: true },
+		async (config) => {
+			log("info", t("buildStarting"));
+			return await initRendering(config);
+		},
+	);
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+async function runComponentCommand(args) {
+	return await withCliConfig(
+		args,
+		{ defaultNodeEnv: "development", isComponentGenerator: true },
+		async () => {
+			log("info", t("generator.starting"));
+			return await createComponentViaCli(args);
+		},
+	);
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+async function runMocksCommand(args) {
+	return await withCliConfig(
+		args,
+		{ defaultNodeEnv: "development" },
+		async (config) => {
+			const result = await mockGenerator(args.component, config.files);
+			if (result?.message) {
+				log(result.message.type, result.message.text, result.message.verbose);
+			}
+
+			return {
+				success: result.success,
+				code: result.success ? EXIT_CODES.SUCCESS : EXIT_CODES.GENERAL_ERROR,
+				shouldExit: true,
+				message: result.message?.text,
+			};
+		},
+	);
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+async function runLintCommand(args) {
+	applyCliEnv(args);
+	return await lint(args);
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+async function runDrupalAssetsCommand(args) {
+	return await withCliConfig(
+		args,
+		{ forcedNodeEnv: "development" },
+		async () => await drupalAssets(args),
+	);
+}
+
+/**
+ * @param {object} args
+ * @returns {Promise<object>}
+ */
+async function runDoctorCommand(args) {
+	applyCliEnv(args);
+	return await doctor(args);
+}
+
+/**
+ * @param {Error|MiyagiError|string} error
+ * @param {string[]} argv
+ * @returns {object}
+ */
+function normalizeCliError(error, argv) {
+	if (error instanceof MiyagiError) {
+		if (!error.logged) {
+			log("error", error.message);
+		}
+		maybeLogDoctorHint(error.code, argv);
+
+		return {
+			success: false,
+			code: error.code,
+			shouldExit: true,
+			message: error.message,
+		};
+	}
+
+	const message = error instanceof Error ? error.message : String(error);
+	log("error", message);
+	maybeLogDoctorHint(EXIT_CODES.GENERAL_ERROR, argv);
+	return {
+		success: false,
+		code: EXIT_CODES.GENERAL_ERROR,
+		shouldExit: true,
+		message,
+	};
+}
+
+/**
+ * @param {string[]} [argv]
+ * @returns {Promise<object>}
+ */
+export async function runCli(argv = process.argv) {
+	const { cli, getResult } = createCli(
+		{
+			start: runStartCommand,
+			build: runBuildCommand,
+			new: runComponentCommand,
+			mocks: runMocksCommand,
+			lint: runLintCommand,
+			drupalAssets: runDrupalAssetsCommand,
+			doctor: runDoctorCommand,
+		},
+		argv,
+	);
+
+	try {
+		await cli.parseAsync();
+		const result = getResult() || createSuccessResult();
+		maybeLogDoctorHint(result.code, argv);
+		return result;
+	} catch (error) {
+		return normalizeCliError(error, argv);
+	}
+}

package/lib/config.js

@@ -62,6 +62,16 @@ function getCliArgs(args) {
 
 	delete cliArgs._;
 	delete cliArgs.$0;
+	delete cliArgs.component;
+	delete cliArgs.verbose;
+	delete cliArgs.skip;
+	delete cliArgs.only;
+	delete cliArgs.engine;
+	delete cliArgs.config;
+	delete cliArgs.libraries;
+	delete cliArgs.components;
+	delete cliArgs.ignorePrefixes;
+	delete cliArgs.dryRun;
 
 	if (cliArgs.folder) {
 		buildArgs.folder = cliArgs.folder;

package/lib/default-config.js

@@ -142,7 +142,7 @@ export default {
 			report: {
 				enabled: true,
 				onStart: true,
-				format: "pretty",
+				format: "summary",
 				destination: "stdout",
 				useColors: true,
 			},

package/lib/errors.js

@@ -0,0 +1,31 @@
+/**
+ * CLI/process exit codes used by miyagi.
+ *
+ * Keep this list small and coarse-grained. The goal is predictable automation,
+ * not a unique code for every possible failure.
+ */
+export const EXIT_CODES = Object.freeze({
+	SUCCESS: 0,
+	GENERAL_ERROR: 1,
+	CLI_USAGE_ERROR: 2,
+	CONFIG_ERROR: 3,
+	VALIDATION_ERROR: 4,
+});
+
+export class MiyagiError extends Error {
+	/**
+	 * @param {string} message
+	 * @param {object} [options]
+	 * @param {number} [options.code] Exit code from `EXIT_CODES`.
+	 * @param {boolean} [options.logged] True if this error was already sent to the logger and should not be logged again at the CLI boundary.
+	 */
+	constructor(
+		message,
+		{ code = EXIT_CODES.GENERAL_ERROR, logged = false } = {},
+	) {
+		super(message);
+		this.name = "MiyagiError";
+		this.code = code;
+		this.logged = logged;
+	}
+}

package/lib/index.js

@@ -6,81 +6,11 @@
  */
 
 import { t } from "./i18n/index.js";
-import initRendering from "./init/rendering.js";
 import log from "./logger.js";
-import yargs from "./init/args.js";
-import mockGenerator from "./generator/mocks.js";
 import getConfig from "./config.js";
-import {
-	lint,
-	component as createComponentViaCli,
-	drupalAssets,
-} from "./cli/index.js";
+import { EXIT_CODES } from "./errors.js";
 import apiApp from "../api/app.js";
 
-/**
- * Checks if miyagi was started with "mocks" command
- * @param {object} args - the cli args
- * @returns {boolean} is true if the miyagi was started with "mocks"
- */
-function argsIncludeMockGenerator(args) {
-	return args._.includes("mocks");
-}
-
-/**
- * Checks if miyagi was started with "new" command
- * @param {object} args - the cli args
- * @returns {boolean} is true if the miyagi was started with "new"
- */
-function argsIncludeComponentGenerator(args) {
-	return args._.includes("new");
-}
-
-/**
- * Checks if miyagi was started with "build" command
- * @param {object} args - the cli args
- * @returns {boolean} is true if the miyagi was started with "new"
- */
-function argsIncludeBuild(args) {
-	return args._.includes("build");
-}
-
-/**
- * Checks if miyagi was started with "start" command
- * @param {object} args - the cli args
- * @returns {boolean} is true if the miyagi was started with "start"
- */
-function argsIncludeServer(args) {
-	return args._.includes("start");
-}
-
-/**
- * Checks if miyagi was started with "lint" command
- * @param {object} args
- * @returns {boolean}
- */
-function argsIncludeLint(args) {
-	return args._.includes("lint");
-}
-
-/**
- * @param {object} args
- * @returns {boolean}
- */
-function argsIncludeDrupalAssets(args) {
-	return args._.includes("drupal-assets");
-}
-
-/**
- * Runs the mock generator
- * @param {object} config - the user configuration object
- * @param {object} args - the cli args
- * @returns {Promise}
- */
-function runMockGenerator(config, args) {
-	return mockGenerator(args._.slice(1)[0], config.files).catch(() => {});
-}
-
 /**
  * @param {object} config
  * @returns {Promise<object>}
@@ -105,85 +35,11 @@ export default async function Miyagi(cmd, { isBuild: isApiBuild } = {}) {
 		return await initApi(global.config);
 	}
 
-	let args;
-	let isServer;
-	let isBuild;
-	let isComponentGenerator;
-	let isMockGenerator;
-	let isLinter;
-	let isDrupalAssets;
-
-	if (cmd) {
-		isBuild = cmd === "build";
-	} else {
-		args = await yargs.argv;
-		isServer = argsIncludeServer(args);
-		isBuild = argsIncludeBuild(args);
-		isComponentGenerator = argsIncludeComponentGenerator(args);
-		isMockGenerator = argsIncludeMockGenerator(args);
-		isLinter = argsIncludeLint(args);
-		isDrupalAssets = argsIncludeDrupalAssets(args);
-	}
-
-	if (args && args.verbose) {
-		process.env.VERBOSE = String(args.verbose);
-	}
-
-	if (isLinter) {
-		return lint(args);
-	}
-
-	if (isDrupalAssets) {
-		process.env.NODE_ENV = "development";
-		global.config = await getConfig(args);
-		await drupalAssets(args);
-		process.exit();
-	}
-
-	if (isBuild || isComponentGenerator || isServer || isMockGenerator) {
-		if (isBuild) {
-			process.env.NODE_ENV = "production";
-			log("info", t("buildStarting"));
-		} else {
-			if (!process.env.NODE_ENV) {
-				process.env.NODE_ENV = "development";
-			}
-
-			if (isComponentGenerator) {
-				log("info", t("generator.starting"));
-			} else if (isServer) {
-				log(
-					"info",
-					t("serverStarting").replace("{{node_env}}", process.env.NODE_ENV),
-				);
-			}
-		}
-
-		global.config = await getConfig(args, isBuild, isComponentGenerator);
-
-		if (!global.config.components.folder && !global.config.docs.folder) {
-			log(
-				"error",
-				"Please specify at least either components.folder or docs.folder in your configuration file.",
-			);
-			process.exit(1);
-		}
-
-		if (isMockGenerator) {
-			await runMockGenerator(global.config, args);
-			// Force-exit in case imported user config has active resources preventing Node.js from exiting.
-			process.exit();
-		}
-
-		if (isComponentGenerator) {
-			await createComponentViaCli(args);
-			// Force-exit in case imported user config has active resources preventing Node.js from exiting.
-			process.exit();
-		}
-
-		return initRendering(global.config);
-	}
-
 	log("error", t("commandNotFound"));
-	process.exit(1);
+	return {
+		success: false,
+		code: EXIT_CODES.CLI_USAGE_ERROR,
+		shouldExit: true,
+		message: t("commandNotFound"),
+	};
 }