@schalkneethling/miyagi-core 4.0.2

package/lib/generator/mocks.js

@@ -0,0 +1,201 @@
+import { readFile, writeFile } from "node:fs/promises";
+import schemaFaker from "@stoplight/json-schema-sampler";
+import jsYaml from "js-yaml";
+import path from "path";
+import log from "../logger.js";
+import { t } from "../i18n/index.js";
+
+/**
+ * Module for creating dummy mock data based on JSON schema
+ * @module generatorMocks
+ * @param {string} folderPath - the path for the component that should be created
+ * @param {object} filesConfig - the files configuration from the user configuration object
+ * @returns {Promise<{success, message?}>}
+ */
+export default async function mockGenerator(folderPath, filesConfig) {
+	if (!folderPath) {
+		return {
+			success: false,
+			message: {
+				type: "error",
+				text: t("dataGenerator.noComponentFolderDefined"),
+			},
+		};
+	}
+
+	log("info", t("dataGenerator.starting").replace("{{fileName}}", folderPath));
+
+	const mockFilePath = `${path.join(folderPath, filesConfig.mocks.name)}.${
+		filesConfig.mocks.extension[0]
+	}`;
+	const schemaFilePath = `${path.join(folderPath, filesConfig.schema.name)}.${
+		filesConfig.schema.extension
+	}`;
+
+	const {
+		status,
+		data: schemaData,
+		message,
+	} = await readAndParseFile(schemaFilePath, filesConfig);
+
+	if (status === "success") {
+		try {
+			const content = getContent(filesConfig.mocks.extension[0], schemaData);
+
+			const { status, data } = await readAndParseFile(
+				mockFilePath,
+				filesConfig,
+			);
+
+			if (status === "success") {
+				if (data === "") {
+					const { status, message } = await createFile(content, mockFilePath);
+
+					if (status === "error") {
+						return {
+							success: false,
+							message: {
+								type: "error",
+								text: message,
+							},
+						};
+					} else {
+						return {
+							success: true,
+						};
+					}
+				} else {
+					return {
+						success: false,
+						message: {
+							type: "error",
+							text: t("dataGenerator.dataFileExists").replace(
+								"{{fileName}}",
+								mockFilePath,
+							),
+						},
+					};
+				}
+			} else {
+				const { status, message } = await createFile(content, mockFilePath);
+
+				if (status === "error") {
+					return {
+						success: false,
+						message: {
+							type: "error",
+							text: message,
+						},
+					};
+				} else {
+					return {
+						success: true,
+					};
+				}
+			}
+			// eslint-disable-next-line no-unused-vars
+		} catch (e) {
+			return {
+				success: false,
+				message: {
+					type: "error",
+					text: t("dataGenerator.schemaFileCantBeParsed").replace(
+						"{{fileName}}",
+						schemaFilePath,
+					),
+				},
+			};
+		}
+	} else {
+		return {
+			success: false,
+			message: {
+				type: "error",
+				text: t("dataGenerator.noSchemaFile").replace(
+					"{{fileName}}",
+					schemaFilePath,
+				),
+				verbose: message,
+			},
+		};
+	}
+}
+
+/**
+ * Returns the dummy mock data in the correct format
+ * @param {string} fileType - the file type of the mock data that should be created
+ * @param {object} schema - the JSON schema object
+ * @returns {string} the dummy mock data
+ */
+function getContent(fileType, schema) {
+	let content;
+	const data = schemaFaker.sample(schema);
+
+	switch (fileType) {
+		case "yaml":
+		case "yml":
+			content = jsYaml.dump(data);
+			break;
+		case "json":
+			content = JSON.stringify(data, null, 2);
+			break;
+		case "js":
+			content = `module.exports = ${JSON.stringify(data, null, 2)}
+      `;
+			break;
+		default:
+			content = "";
+	}
+
+	return content;
+}
+
+/**
+ * Creates the mock file with the dummy mock data
+ * @param {string} content - the content for the mock file
+ * @param {string} mockFilePath - the path to the mock file
+ * @returns {Promise<object>}
+ */
+async function createFile(content, mockFilePath) {
+	try {
+		await writeFile(mockFilePath, content);
+		return {
+			status: "success",
+			message: t("generator.done"),
+		};
+	} catch (err) {
+		return {
+			status: "error",
+			message: err.message,
+		};
+	}
+}
+
+/**
+ * Reads the content of a given file
+ * @param {string} filePath - path to a file that should be read
+ * @param {object} filesConfig
+ * @returns {Promise<object>}
+ */
+async function readAndParseFile(filePath, filesConfig) {
+	try {
+		const result = await readFile(filePath, "utf8");
+		let data;
+
+		if (["yaml", "yml"].includes(filesConfig.schema.extension)) {
+			data = jsYaml.load(result);
+		} else {
+			data = JSON.parse(result);
+		}
+
+		return {
+			status: "success",
+			data,
+		};
+	} catch (err) {
+		return {
+			status: "error",
+			message: err.message,
+		};
+	}
+}

package/lib/helpers.js

@@ -0,0 +1,184 @@
+import v8 from "v8";
+import path from "path";
+
+/**
+ * Module for globally used helper functions
+ * @module helpers
+ */
+
+/**
+ * Removes all keys starting with $ from an object
+ * @param {object} [obj] the object whose keys with $ should be removed
+ * @returns {object} the modified object
+ */
+export const removeInternalKeys = function (obj = {}) {
+	const o = {};
+
+	for (const [key, value] of Object.entries(obj)) {
+		if (!key.startsWith("$") || key === "$ref" || key === "$opts") {
+			o[key] = value;
+		}
+	}
+
+	return o;
+};
+
+/**
+ * Returns everything after the last "." of a file extension (e.g. `html.twig` -> `twig`)
+ * @param {string} [extension] - File extension like `twig` or `html.twig`
+ * @returns {string} the last part of a the file extension
+ */
+export const getSingleFileExtension = function (extension = "") {
+	return extension.slice(extension.lastIndexOf(".") + 1);
+};
+
+/**
+ * Normalizes a string be replacing whitespace, underscore, / etc with - and lowercases it
+ * @param {string} [str] string that should be normalized
+ * @returns {string} the normalized string
+ */
+export const normalizeString = function (str = "") {
+	if (typeof str === "string") {
+		return str
+			.replace(/[^\w\s]/gi, "-")
+			.replace(/_/g, "-")
+			.replace(/ /g, "-")
+			.toLowerCase();
+	}
+
+	return str;
+};
+
+/**
+ * If "<component>"" is set as the file name in the config, it returns the given file name, otherwise it returns the value from the config
+ * @param {string} nameInConfig - The defined name for a file in the config
+ * @param {string} fileName - The actual file name
+ * @returns {string} the filename based on the configuration file
+ */
+export const getResolvedFileName = function (nameInConfig, fileName) {
+	if (nameInConfig === "<component>") {
+		return fileName;
+	}
+
+	return nameInConfig;
+};
+
+/**
+ * Creates a deep clone of a object using internal v8 methods
+ * @param {object} obj - the object to clone
+ * @returns {object} clone of rhe given object
+ */
+export const cloneDeep = function (obj) {
+	return v8.deserialize(v8.serialize(obj));
+};
+
+/**
+ * Accepts a path relative from the config.components.folder and returns the complete path based on the file system
+ * @param {string} shortPath - a relative file path based from the components folder
+ * @returns {string} absolute file path
+ */
+export const getFullPathFromShortPath = function (shortPath) {
+	return path.join(
+		process.cwd(),
+		`${global.config.components.folder}/${shortPath}`,
+	);
+};
+
+/**
+ * Accepts an absolute (file system based) path and returns the short path relative from config.components.folder
+ * @param {string} fullPath - absolute file path
+ * @returns {string} relative file path based from the components folder
+ */
+export const getShortPathFromFullPath = function (fullPath) {
+	return fullPath.replace(
+		`${path.join(process.cwd(), global.config.components.folder)}/`,
+		"",
+	);
+};
+
+/**
+ * Accepts a file path and checks if it is a mock file
+ * @param {string} filePath - path to any type of file
+ * @returns {boolean} is true if the given file is a mock file
+ */
+export const fileIsDataFile = function (filePath) {
+	const extension = path.extname(filePath);
+
+	if (!["js", "json", "yaml", "yml"].includes(extension.slice(1))) return false;
+
+	const basename = path.basename(filePath, extension);
+	if (global.config.files.mocks.name === basename) return true;
+
+	return false;
+};
+
+/**
+ * Accepts a file path and checks if it is a documentation file
+ * @param {string} filePath - path to any type of file
+ * @returns {boolean} is true if the given file is a doc file
+ */
+export const fileIsDocumentationFile = function (filePath) {
+	return path.extname(filePath) === ".md";
+};
+
+/**
+ * Accepts a file path and checks if it is a schema file
+ * @param {string} filePath - path to any type of file
+ * @returns {boolean} is true if the given file is a schema file
+ */
+export const fileIsSchemaFile = function (filePath) {
+	return (
+		path.basename(filePath) ===
+		`${global.config.files.schema.name}.${global.config.files.schema.extension}`
+	);
+};
+
+/**
+ * Accepts a file path and checks if it is component js or css file
+ * @param {string} filePath - path to any type of file
+ * @returns {boolean} is true if the given file is a css or js file
+ */
+export const fileIsAssetFile = function (filePath) {
+	return (
+		path.basename(filePath) ===
+			`${getResolvedFileName(
+				global.config.files.css.name,
+				path.basename(filePath, `.${global.config.files.css.extension}`),
+			)}.${global.config.files.css.extension}` ||
+		path.basename(filePath) ===
+			`${getResolvedFileName(
+				global.config.files.js.name,
+				path.basename(filePath, `.${global.config.files.js.extension}`),
+			)}.${global.config.files.js.extension}`
+	);
+};
+
+/**
+ * Accepts a file path and returns checks if it is a template file
+ * @param {string} filePath - path to any type of file
+ * @returns {boolean} is true if the given file is a template file
+ */
+export const fileIsTemplateFile = function (filePath) {
+	return (
+		path.basename(filePath) ===
+		`${getResolvedFileName(
+			global.config.files.templates.name,
+			path.basename(filePath, `.${global.config.files.templates.extension}`),
+		)}.${global.config.files.templates.extension}`
+	);
+};
+
+export const docFileIsIndexFile = function (fileName) {
+	const baseName = path.basename(fileName);
+	const extname = path.extname(fileName);
+
+	if (extname !== ".md") return false;
+	if (baseName === "README.md") return true;
+	if (baseName === "index.md") return true;
+
+	const dirParts = path.dirname(fileName).split(path.sep);
+	if (dirParts[dirParts.length - 1] === path.basename(fileName, ".md"))
+		return true;
+
+	return false;
+};

package/lib/i18n/en.js

@@ -0,0 +1,91 @@
+export default {
+	buildStarting: "Creating miyagi build…",
+	buildDone: "Build done! Wrote {{count}} directories and files.",
+	commandNotFound: "Please run `miyagi --help` for all available commands.",
+	componentCouldNotBeRendered: "Component couldn't be rendered.",
+	customPropertyFileNotFound:
+		"Couldn't find file {{filePath}}. Is the 'assets.customProperties.files' in your configuration set correctly?",
+	dataGenerator: {
+		dataFileExists: "The mock file {{fileName}} exists already.",
+		done: "Done!",
+		noComponentFolderDefined: "No directory has been defined.",
+		noSchemaFile: "miyagi can't find or parse the schema file {{fileName}}.",
+		schemaFileCantBeParsed: "The schema file {{fileName}} can't be parsed.",
+		starting: "Creating mock file {{fileName}}…",
+	},
+	jsonFileHasInvalidFormat:
+		"It seems like the file {{filePath}} has an invalid format as miyagi was not able to parse it.",
+	checkShellForFurtherErrors:
+		"Please also check the messages printed by miyagi in your shell as there might be more information.",
+	fileNotFound:
+		"Couldn't find file {{filePath}}. Is the 'components.folder' in your configuration set correctly?",
+	fileNotFoundLinkIncorrect:
+		"Couldn't find mock data '{{filePath}}' referenced in {{component}}. Please check that it's linked correctly.",
+	generator: {
+		starting: "Creating component…",
+		done: "Done!",
+		noComponentNameDefined:
+			"Please specify a component name like this: miyagi new directoryName/componentName",
+		fileAlreadyExists: "The file {{name}} already exists.",
+		component: {
+			done: "Finished creating component {{component}}.",
+		},
+	},
+	linter: {
+		all: {
+			start: "Validating schema files and mock data for all components…",
+			valid: "All schema and mock data is valid!",
+			schema: {
+				invalid: {
+					one: "1 schema file is invalid!",
+					other: "{{amount}} schema files are invalid!",
+				},
+			},
+			mocks: {
+				invalid: {
+					one: "1 mock data file is invalid!",
+					other: "{{amount}} mock data files are invalid!",
+				},
+			},
+		},
+		component: {
+			start: "Validating schema file and mock data for {{component}}…",
+			valid: "Schema file and mock data is valid!",
+		},
+	},
+	manifestNotFound: "Manifest file {{manifest}} not found or unparseable.",
+	missingExtension:
+		"Please specify the file extension of your template files in your config file (key: 'files.templates.extension', type: String) or as a cli argument (--files.templates.extension=<extension>).",
+	noDataSetForVariation:
+		'No mock data defined for variation "{{variation}}" in {{file}}.',
+	noNameSetForVariation: "No name defined for variation {{i}} in {{file}}.",
+	portInUse: "Port {{port}} already in use, trying to find a free port…",
+	referencedMockFileNotFound: "Couldn't find referenced mock file.",
+	renderingTemplateFailed:
+		"Rendering {{filePath}} failed. Please check that it is linked correctly and that its content is correct syntax.",
+	scanningFiles: "Scanning and analyzing files…",
+	validator: {
+		mocks: {
+			valid: "Mock data matches schema.",
+			invalid: "Mock data does not match schema file.",
+			noSchemaFound:
+				"No schema file found or the schema file could not be parsed as valid JSON.",
+		},
+	},
+	serverStarted: "Running miyagi server at http://localhost:{{port}}",
+	serverStarting: "Starting miyagi server in {{node_env}} mode…",
+	settingEngineFailed:
+		"Setting the template engine failed. Are you sure the engine defined in your config file is correct?",
+	srcFolderNotFound:
+		"The specified {{type}} directory '{{directory}}' does not seem to exist. You can specify this in your config file (key: '{{config}}', type: String) or as a cli argument (--{{config}}=<String>). If you do not have any {{type}}, you can also set the value to null.",
+	templateDoesNotExist: "The template '{{template}}' can't be found.",
+	updatingDone: "Updating done!",
+	updatingConfiguration: "Updating configuration…",
+	updatingConfigurationDone: "Reloading browser window!",
+	updatingStarted: "A file has been changed, miyagi is updating the state.",
+	userConfigUnparseable:
+		"miyagi wasn't able to find or parse your config file. If you created a .miyagi.js or .miyagi.mjs, please check if its syntax is correct.",
+	variationNotFound: 'Variation "{{variation}}" not found in {{fileName}}.',
+	watchingFilesFailed: "Watching files failed.",
+	wrongFileType: "{{fileName}} does not have the correct file type.",
+};

package/lib/i18n/index.js

@@ -0,0 +1,17 @@
+import en from "./en.js";
+
+export const t = function (key) {
+	const translations = {
+		en,
+	};
+
+	let object = translations[global.config?.ui?.lang];
+
+	if (!object) {
+		object = translations.en;
+	}
+
+	return key.split(".").reduce((o, i) => o[i], object);
+};
+
+export const available = ["en"];

package/lib/index.js

@@ -0,0 +1,166 @@
+/**
+ * The miyagi module
+ * @module index
+ */
+
+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 } from "./cli/index.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");
+}
+
+/**
+ * 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>}
+ */
+async function initApi(config) {
+	return await apiApp(config);
+}
+
+/**
+ * Requires the user config and initializes and calls correct modules based on command
+ * @param {string} cmd
+ * @param {object} [options]
+ * @param {boolean} [options.isBuild]
+ * @returns {Promise}
+ */
+export default async function Miyagi(cmd, { isBuild: isApiBuild } = {}) {
+	if (cmd === "api") {
+		process.env.NODE_ENV = "development";
+
+		global.config = await getConfig(null, isApiBuild);
+
+		return await initApi(global.config);
+	}
+
+	let args;
+	let isServer;
+	let isBuild;
+	let isComponentGenerator;
+	let isMockGenerator;
+	let isLinter;
+
+	if (cmd) {
+		isBuild = cmd === "build";
+	} else {
+		args = yargs.argv;
+		isServer = argsIncludeServer(args);
+		isBuild = argsIncludeBuild(args);
+		isComponentGenerator = argsIncludeComponentGenerator(args);
+		isMockGenerator = argsIncludeMockGenerator(args);
+		isLinter = argsIncludeLint(args);
+	}
+
+	if (args.verbose) {
+		process.env.VERBOSE = args.verbose;
+	}
+
+	if (isLinter) {
+		return lint(args);
+	}
+
+	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);
+}