@schalkneethling/miyagi-core 4.3.1 → 4.4.1

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

@@ -1,173 +1,174 @@
 import AJV from "ajv";
 
 export default {
-	defaultUserConfig: {
-		assets: {
-			root: "",
-			css: [],
-			shared: {
-				css: [],
-				js: [],
-			},
-			isolateComponents: false,
-			customProperties: {
-				files: [],
-				prefixes: {
-					typo: "typo",
-					color: "color",
-					spacing: "spacing",
-				},
-			},
-			folder: [],
-			js: [],
-			manifest: null,
-		},
-		build: {
-			basePath: "/",
-			folder: "build",
-		},
-		docs: {
-			folder: "docs",
-		},
-		components: {
-			folder: "src",
-			ignores: [
-				"node_modules",
-				".git",
-				"package.json",
-				"package-lock.json",
-				".miyagi.js",
-				".miyagi.mjs",
-			],
-			lang: "en",
-			textDirection: "ltr",
-		},
-		engine: {
-			render: null,
-			options: {},
-		},
-		lint: {
-			logLevel: "error",
-		},
-		extensions: [],
-		files: {
-			css: {
-				abbr: "css",
-				name: "index",
-				extension: "css",
-			},
-			js: {
-				abbr: "js",
-				name: "index",
-				extension: "js",
-			},
-			mocks: {
-				abbr: "mocks",
-				name: "mocks",
-				extension: ["json", "js"],
-			},
-			schema: {
-				abbr: "schema",
-				name: "schema",
-				extension: "json",
-			},
-			templates: {
-				abbr: "tpl",
-				name: "index",
-			},
-		},
-		namespaces: {},
-		projectName: "miyagi",
-		ui: {
-			mode: "light",
-			lang: "en",
-			reload: true,
-			reloadAfterChanges: {
-				componentAssets: false,
-			},
-			textDirection: "ltr",
-			theme: {
-				css: null,
-				favicon: null,
-				js: null,
-				logo: {
-					light: null,
-					dark: null,
-				},
-			},
-			watchConfigFile: true,
-		},
-		watch: {
-			enabled: true,
-			backend: "chokidar",
-			sources: [],
-			ignore: {
-				defaults: true,
-				patterns: [],
-			},
-			behavior: {
-				debounceMs: 60,
-				coalesceWindowMs: 120,
-				awaitWriteFinish: {
-					enabled: true,
-					stabilityThresholdMs: 200,
-					pollIntervalMs: 50,
-				},
-			},
-			reload: {
-				enabled: true,
-				rules: {
-					template: "iframe",
-					data: "parent",
-					docs: "parent",
-					schema: "iframe",
-					componentAsset: "none",
-					globalCss: "none",
-					globalJs: "none",
-					unknown: "parent",
-				},
-			},
-			socket: {
-				reconnect: {
-					enabled: true,
-					initialDelayMs: 250,
-					maxDelayMs: 5000,
-					jitter: true,
-				},
-				heartbeat: {
-					enabled: true,
-					intervalMs: 30000,
-				},
-			},
-			report: {
-				enabled: true,
-				onStart: true,
-				format: "summary",
-				destination: "stdout",
-				useColors: true,
-			},
-			configFile: {
-				enabled: true,
-			},
-			debug: {
-				logEvents: false,
-				logDecisions: false,
-				logResolvedSources: false,
-			},
-		},
-		schema: {
-			ajv: AJV,
-			verbose: false,
-		},
-		schemaValidationMode: "collect-all",
-	},
-	projectName: "miyagi",
-	defaultPort: 5000,
-	folders: {
-		assets: {
-			development: "frontend/assets",
-			production: "dist",
-		},
-	},
-	defaultVariationName: "default",
+  defaultUserConfig: {
+    assets: {
+      root: "",
+      css: [],
+      shared: {
+        css: [],
+        js: [],
+      },
+      isolateComponents: false,
+      customProperties: {
+        files: [],
+        prefixes: {
+          typo: "typo",
+          color: "color",
+          spacing: "spacing",
+        },
+      },
+      folder: [],
+      js: [],
+      manifest: null,
+    },
+    build: {
+      basePath: "/",
+      folder: "build",
+    },
+    docs: {
+      folder: "docs",
+    },
+    components: {
+      folder: "src",
+      ignores: [
+        "node_modules",
+        ".git",
+        "package.json",
+        "package-lock.json",
+        ".miyagi.js",
+        ".miyagi.mjs",
+      ],
+      lang: "en",
+      textDirection: "ltr",
+    },
+    engine: {
+      render: null,
+      options: {},
+    },
+    lint: {
+      logLevel: "error",
+    },
+    extensions: [],
+    files: {
+      css: {
+        abbr: "css",
+        name: "index",
+        extension: "css",
+      },
+      js: {
+        abbr: "js",
+        name: "index",
+        extension: "js",
+      },
+      mocks: {
+        abbr: "mocks",
+        name: "mocks",
+        extension: ["json", "js"],
+      },
+      schema: {
+        abbr: "schema",
+        name: "schema",
+        extension: "json",
+      },
+      templates: {
+        abbr: "tpl",
+        name: "index",
+      },
+    },
+    namespaces: {},
+    projectName: "miyagi",
+    ui: {
+      mode: "light",
+      lang: "en",
+      reload: true,
+      reloadAfterChanges: {
+        componentAssets: true,
+      },
+      textDirection: "ltr",
+      theme: {
+        css: null,
+        favicon: null,
+        js: null,
+        logo: {
+          light: null,
+          dark: null,
+        },
+      },
+      watchConfigFile: true,
+    },
+    watch: {
+      enabled: true,
+      backend: "chokidar",
+      sources: [],
+      ignore: {
+        defaults: true,
+        patterns: [],
+      },
+      behavior: {
+        startupGraceMs: 500,
+        debounceMs: 60,
+        coalesceWindowMs: 120,
+        awaitWriteFinish: {
+          enabled: true,
+          stabilityThresholdMs: 200,
+          pollIntervalMs: 50,
+        },
+      },
+      reload: {
+        enabled: true,
+        rules: {
+          template: "iframe",
+          data: "parent",
+          docs: "parent",
+          schema: "iframe",
+          componentAsset: "iframe",
+          globalCss: "iframe",
+          globalJs: "iframe",
+          unknown: "parent",
+        },
+      },
+      socket: {
+        reconnect: {
+          enabled: true,
+          initialDelayMs: 250,
+          maxDelayMs: 5000,
+          jitter: true,
+        },
+        heartbeat: {
+          enabled: true,
+          intervalMs: 30000,
+        },
+      },
+      report: {
+        enabled: true,
+        onStart: true,
+        format: "summary",
+        destination: "stdout",
+        useColors: true,
+      },
+      configFile: {
+        enabled: true,
+      },
+      debug: {
+        logEvents: false,
+        logDecisions: false,
+        logResolvedSources: false,
+      },
+    },
+    schema: {
+      ajv: AJV,
+      verbose: false,
+    },
+    schemaValidationMode: "collect-all",
+  },
+  projectName: "miyagi",
+  defaultPort: 5000,
+  folders: {
+    assets: {
+      development: "frontend/assets",
+      production: "dist",
+    },
+  },
+  defaultVariationName: "default",
 };

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;
+	}
+}