@schalkneethling/miyagi-core 4.0.2 → 4.2.0

package/api/index.js

@@ -7,6 +7,11 @@ import build from "../lib/build/index.js";
 import generateMockData from "../lib/generator/mocks.js";
 import generateComponent from "../lib/generator/component.js";
 import validateMockData from "../lib/validator/mocks.js";
+import {
+	getSchemaValidationMode,
+	toSchemaValidationResult,
+	validateSchemas,
+} from "../lib/validator/schemas.js";
 
 /**
  * @param {object} obj
@@ -172,14 +177,44 @@ export const createComponent = async ({ component, only = [], skip = [] }) => {
 
 export const lintComponents = async () => {
 	global.app = await init("api");
-	const promises = [];
+	const mode = getSchemaValidationMode();
+	const components = global.state.routes.filter((route) => route.paths.tpl);
+	const schemaValidation = validateSchemas({
+		components,
+	});
+	const schemaErrorsByComponent = new Map();
+
+	schemaValidation.errors.forEach((entry) => {
+		if (!schemaErrorsByComponent.has(entry.component)) {
+			schemaErrorsByComponent.set(entry.component, []);
+		}
+		schemaErrorsByComponent
+			.get(entry.component)
+			.push(toSchemaValidationResult(entry));
+	});
 
-	global.state.routes.forEach((route) => {
-		if (route.paths.tpl) {
-			promises.push(
+	if (mode === "fail-fast" && schemaValidation.errors.length > 0) {
+		return {
+			success: false,
+			data: getLintComponentErrorsInRouteOrder({
+				components,
+				errorMap: schemaErrorsByComponent,
+			}),
+		};
+	}
+
+	const promises = components
+		.filter((route) => !schemaErrorsByComponent.has(route.paths.dir.short))
+		.map(
+			(route) =>
 				new Promise((resolve) => {
 					getComponentData(route).then((data) => {
-						const validation = validateMockData(route, data || [], true);
+						const validation = validateMockData(
+							route,
+							data || [],
+							true,
+							schemaValidation.validSchemas,
+						);
 
 						resolve({
 							component: route.alias,
@@ -187,13 +222,25 @@ export const lintComponents = async () => {
 						});
 					});
 				}),
-			);
-		}
-	});
+		);
 
 	return await Promise.all(promises)
 		.then((res) => {
-			const errors = res.filter((result) => result?.errors?.length > 0);
+			res.forEach((result) => {
+				if (!result?.errors?.length) {
+					return;
+				}
+				const componentErrors = schemaErrorsByComponent.get(result.component) || [];
+				schemaErrorsByComponent.set(result.component, [
+					...componentErrors,
+					...result.errors,
+				]);
+			});
+
+			const errors = getLintComponentErrorsInRouteOrder({
+				components,
+				errorMap: schemaErrorsByComponent,
+			});
 
 			return {
 				success: errors.length === 0,
@@ -216,8 +263,26 @@ export const lintComponent = async ({ component }) => {
 			message: `The component ${component} does not seem to exist.`,
 		};
 
+	const allSchemaValidation = validateSchemas({
+		components: [componentObject],
+	});
+
+	if (allSchemaValidation.errors.length > 0) {
+		return {
+			success: false,
+			data: allSchemaValidation.errors.map((entry) =>
+				toSchemaValidationResult(entry),
+			),
+		};
+	}
+
 	const data = await getComponentData(componentObject);
-	const errors = validateMockData(componentObject, data, true);
+	const errors = validateMockData(
+		componentObject,
+		data || [],
+		true,
+		allSchemaValidation.validSchemas,
+	);
 
 	return {
 		success: errors === null || errors?.length === 0,
@@ -234,3 +299,26 @@ function getComponentsObject(component) {
 		(route) => route.paths.dir.short === component,
 	);
 }
+
+/**
+ * @param {object} params
+ * @param {Array<object>} params.components
+ * @param {Map<string, Array<object>>} params.errorMap
+ * @returns {Array<object>}
+ */
+function getLintComponentErrorsInRouteOrder({ components, errorMap }) {
+	return components
+		.map((route) => {
+			const componentErrors = errorMap.get(route.alias) || [];
+
+			if (componentErrors.length === 0) {
+				return null;
+			}
+
+			return {
+				component: route.alias,
+				errors: componentErrors,
+			};
+		})
+		.filter(Boolean);
+}

package/lib/build/index.js

@@ -380,6 +380,19 @@ export default () => {
 			});
 		}
 
+		const sharedCss = (assetsConfig.shared?.css || []).map((file) =>
+			path.join(
+				assetsConfig.root,
+				typeof file === "string" ? file : file.src,
+			),
+		);
+		const sharedJs = (assetsConfig.shared?.js || []).map((file) =>
+			path.join(
+				assetsConfig.root,
+				typeof file === "string" ? file : file.src,
+			),
+		);
+
 		const cssJsFiles = [
 			...new Set([
 				...assetsConfig.css.map((file) =>
@@ -394,6 +407,8 @@ export default () => {
 						typeof file === "string" ? file : file.src,
 					),
 				),
+				...sharedCss,
+				...sharedJs,
 				...assetsConfig.customProperties.files.map((file) =>
 					path.join(assetsConfig.root, file),
 				),
@@ -655,6 +670,7 @@ export default () => {
 						res: global.app,
 						component,
 						componentData: data.resolved,
+						componentDeclaredAssets: data.$assets || null,
 						cb: async (err, response) => {
 							if (err) {
 								if (typeof err === "string") {

package/lib/cli/drupal-assets.js

@@ -0,0 +1,159 @@
+// @ts-check
+
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import log from "../logger.js";
+import { loadAssetsConfig } from "../drupal/load-assets-config.js";
+import {
+	parseLibrariesYaml,
+	resolveComponentAssets,
+	mapLibraryToComponent,
+} from "../drupal/resolve-library-assets.js";
+
+/**
+ * @typedef {{src: string, type?: string}} JsEntry
+ * @typedef {{css: string[], js: JsEntry[]}} ComponentAssets
+ */
+
+/**
+ * @param {object} args - CLI arguments from yargs
+ */
+export default async function drupalAssets(args) {
+	let config;
+	try {
+		config = await loadAssetsConfig(args);
+	} catch (err) {
+		log("error", /** @type {Error} */ (err).message);
+		process.exit(1);
+	}
+
+	if (!config.libraries) {
+		log("error", "No libraries file specified. Use --libraries or configure it in .miyagi-assets.js.");
+		process.exit(1);
+	}
+
+	let yamlContent;
+	try {
+		yamlContent = await readFile(config.libraries, "utf8");
+	} catch {
+		log("error", `Could not read libraries file: ${config.libraries}`);
+		process.exit(1);
+	}
+
+	const librariesMap = parseLibrariesYaml(yamlContent);
+	const targetLibraries = config.components || Object.keys(librariesMap);
+	const componentsFolder = global.config?.components?.folder || "src";
+
+	let updatedCount = 0;
+
+	for (const libraryName of targetLibraries) {
+		if (!librariesMap[libraryName]) {
+			log("warn", `Library "${libraryName}" not found in ${config.libraries} — skipping.`);
+			continue;
+		}
+
+		const componentPath = mapLibraryToComponent(
+			libraryName,
+			config.mapping,
+			componentsFolder,
+			config.autoDiscoveryPrefixes ?? undefined,
+		);
+
+		if (!componentPath) {
+			log("warn", `Could not map library "${libraryName}" to a component folder — skipping.`);
+			continue;
+		}
+
+		const assets = resolveComponentAssets(
+			libraryName,
+			librariesMap,
+			config.ignorePrefixes,
+		);
+
+		if (config.dryRun) {
+			log("info", `[dry-run] ${libraryName} → ${componentPath}`);
+			console.log(JSON.stringify({ $assets: assets }, null, "\t"));
+			continue;
+		}
+
+		const updated = await updateMockFile(
+			path.join(componentsFolder, componentPath),
+			assets,
+		);
+
+		if (updated) {
+			updatedCount++;
+			log("info", `Updated $assets in ${componentPath}`);
+		}
+	}
+
+	if (!config.dryRun) {
+		log("success", `Done. Updated ${updatedCount} component(s).`);
+	}
+}
+
+/**
+ * Reads a component's mock file, injects/replaces $assets, writes back.
+ * @param {string} componentDir - absolute or relative path to component folder
+ * @param {ComponentAssets} assets
+ * @returns {Promise<boolean>} true if file was updated
+ */
+async function updateMockFile(componentDir, assets) {
+	const mocksConfig = global.config?.files?.mocks || {
+		name: "mocks",
+		extension: ["yaml", "yml", "json", "js"],
+	};
+	const extensions = Array.isArray(mocksConfig.extension)
+		? mocksConfig.extension
+		: [mocksConfig.extension];
+
+	for (const ext of extensions) {
+		const filePath = path.join(componentDir, `${mocksConfig.name}.${ext}`);
+
+		let content;
+		try {
+			content = await readFile(filePath, "utf8");
+		} catch {
+			continue;
+		}
+
+		if (["yaml", "yml"].includes(ext)) {
+			/** @type {Record<string, unknown>} */
+			const data = /** @type {Record<string, unknown>} */ (
+				yaml.load(content) || {}
+			);
+			data.$assets = cleanAssets(assets);
+			await writeFile(filePath, yaml.dump(data, { indent: 2 }));
+			return true;
+		}
+
+		if (ext === "json") {
+			/** @type {Record<string, unknown>} */
+			const data = JSON.parse(content);
+			data.$assets = cleanAssets(assets);
+			await writeFile(filePath, JSON.stringify(data, null, 2) + "\n");
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Strips empty arrays from assets to keep mock files clean.
+ * @param {ComponentAssets} assets
+ * @returns {Partial<ComponentAssets>}
+ */
+function cleanAssets(assets) {
+	/** @type {Partial<ComponentAssets>} */
+	const result = {};
+	if (assets.css?.length > 0) {
+		result.css = assets.css;
+	}
+
+	if (assets.js?.length > 0) {
+		result.js = assets.js;
+	}
+	return result;
+}

package/lib/cli/index.js

@@ -1,5 +1,7 @@
 import lintImport from "./lint.js";
 import componentImport from "./component.js";
+import drupalAssetsImport from "./drupal-assets.js";
 
 export const lint = lintImport;
 export const component = componentImport;
+export const drupalAssets = drupalAssetsImport;

package/lib/cli/lint.js

@@ -4,6 +4,11 @@ import getConfig from "../config.js";
 import log from "../logger.js";
 import { getComponentData } from "../mocks/index.js";
 import validateMockData from "../validator/mocks.js";
+import {
+	getSchemaValidationMode,
+	toSchemaValidationResult,
+	validateSchemas,
+} from "../validator/schemas.js";
 import { t } from "../i18n/index.js";
 
 /**
@@ -14,6 +19,8 @@ export default async function lint(args) {
 
 	const componentArg = args._.slice(1)[0];
 	const config = await getConfig(args);
+	process.env.MIYAGI_LOG_CONTEXT = "lint";
+	process.env.MIYAGI_LOG_LEVEL = config.lint?.logLevel || "error";
 	global.app = await init(config);
 
 	if (componentArg) {
@@ -23,8 +30,20 @@ export default async function lint(args) {
 		);
 
 		if (component) {
+			const schemaValidation = validateSchemas({
+				components: [component],
+			});
+
+			if (schemaValidation.errors.length > 0) {
+				reportSchemaErrors(schemaValidation.errors);
+				process.exit(1);
+			}
+
+			log("success", "All schemas valid.");
+
 			await validateComponentMockData({
 				component,
+				validSchemas: schemaValidation.validSchemas,
 			});
 		} else {
 			log("error", `The component ${componentArg} does not seem to exist.`);
@@ -40,81 +59,90 @@ export default async function lint(args) {
  */
 async function validateAllMockData(exitProcess = true) {
 	log("info", t("linter.all.start"));
+	const mode = getSchemaValidationMode();
+	const components = global.state.routes.filter(
+		(route) => route.type === "components" && route.paths.tpl,
+	);
+	const schemaValidation = validateSchemas({
+		components,
+	});
+	const invalidSchemaComponents = new Set(
+		schemaValidation.errors.map((entry) => entry.component),
+	);
 
-	const promises = [];
-
-	global.state.routes.forEach((route) => {
-		if (route.type === "components") {
-			promises.push(
-				new Promise((resolve, reject) => {
-					validateComponentMockData({
-						component: route,
-						silent: true,
-						exitProcess: false,
-					})
-						.then((result) => resolve(result))
-						.catch((err) => {
-							console.error(err);
-							reject();
-						});
-				}),
-			);
+	if (schemaValidation.errors.length === 0) {
+		log("success", "All schemas valid.");
+	}
+
+	if (schemaValidation.errors.length > 0 && mode === "fail-fast") {
+		reportSchemaErrors(schemaValidation.errors);
+		log(
+			"error",
+			schemaValidation.errors.length === 1
+				? t("linter.all.schema.invalid.one")
+				: t("linter.all.schema.invalid.other").replace(
+						"{{amount}}",
+						schemaValidation.errors.length,
+					),
+		);
+		if (exitProcess) {
+			process.exit(1);
 		}
-	});
+		return;
+	}
 
-	Promise.all(promises)
-		.then((results) => {
-			const mockInvalidResults = results.filter(
-				(result) => result?.valid === false && result.type === "mocks",
-			);
-			const schemaInvalidResults = results.filter(
-				(result) => result?.valid === false && result.type === "schema",
-			);
+	const results = await Promise.all(
+		components
+			.filter((route) => !invalidSchemaComponents.has(route.paths.dir.short))
+			.map((component) =>
+				validateComponentMockData({
+					component,
+					silent: true,
+					exitProcess: false,
+					validSchemas: schemaValidation.validSchemas,
+				}),
+			),
+	);
+	const mockInvalidResults = results.filter(
+		(result) => result?.valid === false && result.type === "mocks",
+	);
 
-			if (
-				mockInvalidResults.length === 0 &&
-				schemaInvalidResults.length === 0
-			) {
-				log("success", t("linter.all.valid"));
-				if (exitProcess) {
-					process.exit(0);
-				}
-			}
+	if (mode === "collect-all" && schemaValidation.errors.length > 0) {
+		reportSchemaErrors(schemaValidation.errors);
+		log(
+			"error",
+			schemaValidation.errors.length === 1
+				? t("linter.all.schema.invalid.one")
+				: t("linter.all.schema.invalid.other").replace(
+						"{{amount}}",
+						schemaValidation.errors.length,
+					),
+		);
+	}
 
-			if (schemaInvalidResults.length > 0) {
-				log(
-					"error",
-					schemaInvalidResults.length === 1
-						? t("linter.all.schema.invalid.one")
-						: t("linter.all.schema.invalid.other").replace(
-								"{{amount}}",
-								schemaInvalidResults.length,
-							),
-				);
-			}
+	if (mockInvalidResults.length > 0) {
+		log(
+			"error",
+			mockInvalidResults.length === 1
+				? t("linter.all.mocks.invalid.one")
+				: t("linter.all.mocks.invalid.other").replace(
+						"{{amount}}",
+						mockInvalidResults.length,
+					),
+		);
+	}
 
-			if (mockInvalidResults.length > 0) {
-				log(
-					"error",
-					mockInvalidResults.length === 1
-						? t("linter.all.mocks.invalid.one")
-						: t("linter.all.mocks.invalid.other").replace(
-								"{{amount}}",
-								mockInvalidResults.length,
-							),
-				);
-			}
+	if (mockInvalidResults.length === 0 && schemaValidation.errors.length === 0) {
+		log("success", t("linter.all.valid"));
+		if (exitProcess) {
+			process.exit(0);
+		}
+		return;
+	}
 
-			if (exitProcess) {
-				process.exit(1);
-			}
-		})
-		.catch((err) => {
-			console.error(err);
-			if (exitProcess) {
-				process.exit(1);
-			}
-		});
+	if (exitProcess) {
+		process.exit(1);
+	}
 }
 
 /**
@@ -122,12 +150,14 @@ async function validateAllMockData(exitProcess = true) {
  * @param {object} obj.component
  * @param {boolean} [obj.silent]
  * @param {boolean} [obj.exitProcess]
+ * @param {Array<object>} [obj.validSchemas]
  * @returns {Promise<object|null>}
  */
 async function validateComponentMockData({
 	component,
 	silent,
 	exitProcess = true,
+	validSchemas = [],
 }) {
 	if (!silent) {
 		log(
@@ -139,42 +169,60 @@ async function validateComponentMockData({
 		);
 	}
 
-	const data = await getComponentData(component);
+	const data = (await getComponentData(component)) || [];
 
-	if (data) {
-		for (const { messages } of data) {
+	if (data.length > 0) {
+		for (const { messages = [] } of data) {
 			for (const { type, text, verbose } of messages) {
 				log(type, text, verbose);
 			}
 		}
+	}
 
-		const results = validateMockData(component, data);
+	const results = validateMockData(component, data, false, validSchemas);
 
-		if (!results) return null;
+	if (!results) return null;
 
-		if (results.length === 0) {
-			if (!silent) {
-				log("success", t("linter.component.valid"));
-			}
+	if (results.length === 0) {
+		if (!silent) {
+			log("success", t("linter.component.valid"));
+		}
 
-			if (exitProcess) {
-				process.exit(0);
-			} else {
-				return {
-					valid: true,
-				};
-			}
-		} else {
-			if (exitProcess) {
-				process.exit(0);
-			} else {
-				return {
-					valid: false,
-					type: results[0].type,
-				};
-			}
+		if (exitProcess) {
+			process.exit(0);
 		}
+
+		return {
+			valid: true,
+		};
 	}
 
-	return null;
+	if (exitProcess) {
+		process.exit(1);
+	}
+
+	return {
+		valid: false,
+		type: results[0].type,
+	};
+}
+
+/**
+ * @param {Array<object>} schemaErrors
+ */
+function reportSchemaErrors(schemaErrors) {
+	schemaErrors.forEach((entry) => {
+		const result = toSchemaValidationResult(entry);
+		log("error", `${entry.component}:\n${result.data[0].message}`);
+		log("error", `schema: ${entry.schemaFile}`);
+		if (entry.schemaPath || entry.instancePath) {
+			log(
+				"error",
+				`schemaPath: ${entry.schemaPath || "-"} | instancePath: ${entry.instancePath || "-"}`,
+			);
+		}
+		if (entry.hint) {
+			log("warn", entry.hint);
+		}
+	});
 }

package/lib/constants/lint-log-levels.js

@@ -0,0 +1,11 @@
+export const LINT_LOG_LEVELS = Object.freeze({
+	ERROR: "error",
+	WARN: "warn",
+	INFO: "info",
+});
+
+export const LINT_LOG_LEVEL_ORDER = Object.freeze({
+	[LINT_LOG_LEVELS.ERROR]: 0,
+	[LINT_LOG_LEVELS.WARN]: 1,
+	[LINT_LOG_LEVELS.INFO]: 2,
+});

package/lib/default-config.js

@@ -5,6 +5,11 @@ export default {
 		assets: {
 			root: "",
 			css: [],
+			shared: {
+				css: [],
+				js: [],
+			},
+			isolateComponents: false,
 			customProperties: {
 				files: [],
 				prefixes: {
@@ -41,6 +46,9 @@ export default {
 			render: null,
 			options: {},
 		},
+		lint: {
+			logLevel: "error",
+		},
 		extensions: [],
 		files: {
 			css: {
@@ -91,7 +99,9 @@ export default {
 		},
 		schema: {
 			ajv: AJV,
+			verbose: false,
 		},
+		schemaValidationMode: "collect-all",
 	},
 	projectName: "miyagi",
 	defaultPort: 5000,