@schalkneethling/miyagi-core 4.0.2

package/lib/init/args.js

@@ -0,0 +1,55 @@
+/**
+ * Module for printing and parsing CLI arguments
+ * @module initArgs
+ */
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import pkgJson from "../../package.json" with { type: "json" };
+
+export default yargs(hideBin(process.argv))
+	.command("start", "Starts the miyagi server", {
+		verbose: {
+			description:
+				"Logging additional information — helpful mainly in case of errors.",
+			type: "boolean",
+		},
+	})
+	.command("build", "Creates a static build of all your components", {
+		folder: {
+			description: "The folder where your static build files will be saved",
+			type: "string",
+		},
+	})
+	.command(
+		"new",
+		"Creates a new component folder (including template, CSS, JS, documentation, mocks, and schema files)",
+		{
+			skip: {
+				description:
+					"files that will not be created\n(space separated list of tpl, css, js, docs, mocks, schema)",
+				type: "array",
+			},
+			only: {
+				description:
+					"tells miyagi to only created the passes file types\n(space separated list of tpl, css, js, docs, mocks, schema)",
+				type: "array",
+			},
+		},
+	)
+	.command(
+		"mocks",
+		"Creates a mock data file with dummy content based on the schema file",
+	)
+	.command(
+		"lint",
+		"Validates if the component's mock data matches its JSON schema",
+	)
+	.help()
+	.version(pkgJson.version)
+	.alias("help", "h")
+	.alias("verbose", "v")
+	.demandCommand()
+	.epilogue(
+		"Please check https://docs.miyagi.dev/configuration/options/ for all options",
+	);

package/lib/init/config.js

@@ -0,0 +1,330 @@
+/**
+ * Module for sanitizing the user configuration and merging it with the default configuration
+ * @module initConfig
+ */
+
+import deepMerge from "deepmerge";
+import log from "../logger.js";
+import appConfig from "../default-config.js";
+import { t, available as langAvailable } from "../i18n/index.js";
+import fs from "fs";
+import path from "path";
+
+const { defaultUserConfig } = appConfig;
+
+/**
+ * @param {string} path - unsanitized directory or file path
+ * @returns {string} the given path sanitized
+ */
+function sanitizePath(path) {
+	if (path === null) return path;
+
+	let sanitizedPath = path;
+
+	if (sanitizedPath.startsWith("./")) {
+		sanitizedPath = sanitizedPath.slice(2);
+	} else if (sanitizedPath.startsWith("/")) {
+		sanitizedPath = sanitizedPath.slice(1);
+	}
+
+	if (sanitizedPath === "." || sanitizedPath === "/") {
+		sanitizedPath = "";
+	}
+
+	if (sanitizedPath.endsWith("/")) {
+		sanitizedPath = sanitizedPath.slice(0, -1);
+	}
+
+	return sanitizedPath;
+}
+
+/**
+ * @param {string|Array} strOrArr - file path or array of file paths
+ * @returns {Array} the given file path in an array or simply the given array
+ */
+function arrayfy(strOrArr) {
+	return Array.isArray(strOrArr) ? strOrArr : [strOrArr];
+}
+
+/**
+ *
+ * @param {object} root0
+ * @param {string} root0.src
+ * @param {boolean} [root0.defer]
+ * @param {boolean} [root0.async]
+ * @param {string} [root0.type]
+ * @param {string} [root0.position]
+ * @returns {object}
+ */
+function getJsFileObject({ src, defer, async, type, position = "head" }) {
+	return {
+		src,
+		defer,
+		async,
+		type,
+		position,
+	};
+}
+
+/**
+ * @param {string|Array|object} strOrArrOrObj - user assets files, either one file as string, an array of files or an object with strings or array for each NODE_ENV
+ * @param {object} manifest - manifest object
+ * @param {string} [manifest.file] - manifest file path
+ * @param {object} [manifest.content] - parsed json content of manifest file
+ * @param {string} root
+ * @returns {string[]} converts the given object to an array of asset file path strings
+ */
+function getJsFilesArray(strOrArrOrObj, manifest, root) {
+	if (!Array.isArray(strOrArrOrObj)) {
+		log("warn", "config.assets.js is not an array.");
+		return [];
+	}
+
+	let files = strOrArrOrObj.map((entry) =>
+		typeof entry === "string" ? getJsFileObject({ src: entry }) : entry,
+	);
+
+	if (files.length > 0 && manifest.file && manifest.content) {
+		files = files.map((file) => {
+			const manifestEntry = getPathFromManifest(file.src, manifest, root);
+
+			if (manifestEntry) {
+				return {
+					...file,
+					src: path.join(path.dirname(manifest.file), manifestEntry),
+				};
+			} else {
+				return file;
+			}
+		});
+	}
+
+	return files
+		.filter((file) => typeof file.src === "string")
+		.map((file) => ({
+			...file,
+			src: sanitizePath(file.src),
+		}));
+}
+
+/**
+ * @param {string|Array|object} strOrArrOrObj - user assets files, either one file as string, an array of files or an object with strings or array for each NODE_ENV
+ * @param {object} manifest - manifest object
+ * @param {string|null} [manifest.file] - manifest file path
+ * @param {object} [manifest.content] - parsed json content of manifest file
+ * @param {string} root
+ * @returns {string[]} converts the given object to an array of asset file path strings
+ */
+function getCssFilesArray(strOrArrOrObj, manifest, root) {
+	if (!Array.isArray(strOrArrOrObj)) {
+		log("warn", "config.assets.css is not an array.");
+		return [];
+	}
+
+	let files = strOrArrOrObj.filter((entry) => typeof entry === "string");
+
+	if (files.length > 0 && manifest.content && manifest.file) {
+		files = files.map((file) => {
+			const manifestEntry = getPathFromManifest(file, manifest, root);
+
+			if (manifestEntry) {
+				return path.join(path.dirname(manifest.file), manifestEntry);
+			} else {
+				return file;
+			}
+		});
+	}
+
+	return files.map(sanitizePath);
+}
+
+/**
+ * @param {string|Array|object} strOrArrOrObj
+ * @returns {string[]} the given param converted to an array of asset file path strings
+ */
+function getAssetFoldersArray(strOrArrOrObj) {
+	if (!Array.isArray(strOrArrOrObj)) {
+		log("warn", "config.assets.folder is not an array.");
+		return [];
+	}
+
+	return strOrArrOrObj
+		.filter((entry) => typeof entry === "string")
+		.map(sanitizePath);
+}
+
+/**
+ * @param {object} [userConfig] the unmerged user configuration
+ * @returns {object} the user configuration merged with the default configuration
+ */
+export default (userConfig = {}) => {
+	const config = { ...userConfig };
+
+	if (config.build) {
+		if (config.build.basePath) {
+			if (!config.build.basePath.startsWith("/")) {
+				config.build.basePath = `/${config.build.basePath}`;
+			}
+
+			if (!config.build.basePath.endsWith("/")) {
+				config.build.basePath = `${config.build.basePath}/`;
+			}
+		}
+	}
+
+	if (config.assets) {
+		let manifest = {};
+
+		if (config.assets.manifest) {
+			try {
+				const manifestContent = fs.readFileSync(
+					path.resolve(
+						path.join(config.assets.root || "", config.assets.manifest),
+					),
+					{ encoding: "utf8" },
+				);
+
+				manifest.file = config.assets.manifest;
+				manifest.content = JSON.parse(manifestContent);
+
+				// eslint-disable-next-line no-unused-vars
+			} catch (e) {
+				log(
+					"warn",
+					t("manifestNotFound").replace("{{manifest}}", config.assets.manifest),
+				);
+			}
+		}
+
+		if (config.assets.folder) {
+			config.assets.folder = getAssetFoldersArray(config.assets.folder);
+		}
+
+		if (config.assets.css) {
+			config.assets.css = getCssFilesArray(
+				config.assets.css,
+				manifest,
+				config.assets.root,
+			);
+		}
+
+		if (config.assets.js) {
+			config.assets.js = getJsFilesArray(
+				config.assets.js,
+				manifest,
+				config.assets.root,
+			);
+		}
+
+		if (!config.assets.customProperties) {
+			config.assets.customProperties = {};
+		}
+
+		if (Array.isArray(config.assets.customProperties.files)) {
+			config.assets.customProperties.files =
+				config.assets.customProperties.files.filter(
+					(entry) => typeof entry === "string",
+				);
+
+			if (manifest?.content) {
+				config.assets.customProperties.files =
+					config.assets.customProperties.files.map((file) => {
+						const manifestEntry = getPathFromManifest(
+							file,
+							manifest,
+							config.assets.root,
+						);
+
+						if (manifestEntry) {
+							return path.join(path.dirname(manifest.file), manifestEntry);
+						} else {
+							return file;
+						}
+					});
+			}
+		} else {
+			log("warn", "config.assets.customProperties.files is not an array.");
+
+			config.assets.customProperties.files = [];
+		}
+	}
+
+	if (config.components) {
+		if (config.components.ignores) {
+			config.components.ignores = arrayfy(config.components.ignores).map(
+				sanitizePath,
+			);
+		}
+	}
+
+	if (!config.ui) config.ui = {};
+	if (!config.ui.theme) config.ui.theme = {};
+	if (!config.ui.theme.light) config.ui.theme.light = {};
+	if (!config.ui.theme.dark) config.ui.theme.dark = {};
+
+	if (config.ui.theme.logo) {
+		if (typeof config.ui.theme.logo === "string") {
+			const { logo } = config.ui.theme;
+
+			config.ui.theme.logo = {
+				light: logo,
+				dark: logo,
+			};
+		} else {
+			if (config.ui.theme.logo.light && !config.ui.theme.logo.dark) {
+				config.ui.theme.logo.dark = config.ui.theme.logo.light;
+			} else if (config.ui.theme.logo.dark && !config.ui.theme.logo.light) {
+				config.ui.theme.logo.light = config.ui.theme.logo.dark;
+			}
+		}
+
+		if (config.ui.theme.logo.light) {
+			config.ui.theme.logo.light = sanitizePath(config.ui.theme.logo.light);
+		}
+		if (config.ui.theme.logo.dark) {
+			config.ui.theme.logo.dark = sanitizePath(config.ui.theme.logo.dark);
+		}
+	}
+
+	const merged = deepMerge(defaultUserConfig, config);
+
+	merged.components.folder = sanitizePath(merged.components.folder);
+
+	// do this later as otherwise the deepMerge would do concatenation which we do not want
+	if (config.files) {
+		if (config.files.mocks) {
+			if (config.files.mocks.extension) {
+				merged.files.mocks.extension = arrayfy(config.files.mocks.extension);
+
+				if (merged.files.mocks.extension.length === 1) {
+					merged.files.mocks.extension.push(
+						defaultUserConfig.files.mocks.extension[1],
+					);
+				}
+			}
+		}
+	}
+
+	if (!langAvailable.includes(merged.ui.lang)) {
+		merged.ui.lang = "en";
+	}
+
+	return merged;
+};
+
+/**
+ * @param {string} file
+ * @param {object} manifest
+ * @param {string} root
+ * @returns {string|null}
+ */
+function getPathFromManifest(file, manifest, root = "") {
+	const entry = Object.entries(manifest.content).find(([key]) => {
+		return (
+			path.resolve(root, path.dirname(manifest.file), sanitizePath(key)) ===
+			path.resolve(root, sanitizePath(file))
+		);
+	});
+
+	return entry ? entry[1] : null;
+}

package/lib/init/engines.js

@@ -0,0 +1,65 @@
+import path from "path";
+import {
+	createSynchronousEnvironment,
+	createSynchronousFilesystemLoader,
+} from "twing";
+import fs from "fs";
+import { t } from "../i18n/index.js";
+import log from "../logger.js";
+import * as helpers from "../helpers.js";
+import TwingCache from "./twing/cache.js";
+import * as twingFunctions from "./twing/functions.js";
+
+/**
+ * @returns {void}
+ */
+function setMiyagiEngine() {
+	const loader = createSynchronousFilesystemLoader(fs);
+	const twing = createSynchronousEnvironment(loader, {
+		cache: new TwingCache(),
+	});
+
+	loader.addPath(
+		path.join(import.meta.dirname, "../../frontend/views"),
+		"@miyagi",
+	);
+
+	Object.values(twingFunctions).forEach((twingFunction) => {
+		twing.addFunction(twingFunction);
+	});
+
+	global.app.engine("miyagi", async (str, options, cb) =>
+		cb(await twing.render(str, options)),
+	);
+}
+
+/**
+ * @returns {Promise<void>}
+ */
+async function setUserEngine() {
+	const { extension } = global.config.files.templates;
+	const { engine } = global.config;
+
+	if (!engine.render) {
+		log("error", "No render function has beend defined.");
+		process.exit(1);
+	}
+
+	try {
+		global.app.engine(
+			helpers.getSingleFileExtension(extension),
+			async (name, context, cb) => await engine.render({ name, context, cb }),
+		);
+	} catch (e) {
+		log("error", t("settingEngineFailed"), e);
+		process.exit(1);
+	}
+}
+
+/**
+ * @returns {Promise<void>}
+ */
+export default async function initEngines() {
+	await setUserEngine();
+	setMiyagiEngine();
+}

package/lib/init/index.js

@@ -0,0 +1,102 @@
+/**
+ * Module for initializing miyagi
+ * @module init
+ */
+
+import express from "express";
+// deepcode ignore HttpToHttps: local server only
+import http from "http";
+import cookieParser from "cookie-parser";
+
+import appConfig from "../default-config.js";
+import { t } from "../i18n/index.js";
+import build from "../build/index.js";
+import log from "../logger.js";
+import setEngines from "./engines.js";
+import setRouter from "./router.js";
+import setState from "../state/index.js";
+import setStatic from "./static.js";
+import setViews from "./views.js";
+import setWatcher from "./watcher.js";
+
+/**
+ * @param {object} mergedConfig
+ * @returns {Promise<object>}
+ */
+export default async function init(mergedConfig) {
+	// deepcode ignore UseCsurfForExpress: local server only, deepcode ignore DisablePoweredBy: local server only
+	global.app = express();
+	global.app.use(cookieParser());
+	global.config = mergedConfig;
+	global.app.set("view cache", global.config.isBuild);
+	global.app.set("cache", global.config.isBuild);
+
+	await setEngines();
+
+	const port = process.env.PORT || appConfig.defaultPort;
+
+	global.app.set("port", port);
+
+	await setState({
+		sourceTree: true,
+		menu: true,
+		partials: true,
+		fileContents: true,
+		css: true,
+	});
+
+	setStatic();
+	setRouter();
+	setViews();
+
+	if (global.config.isBuild) {
+		return build()
+			.then((message) => {
+				log("success", message);
+				process.exit(0);
+			})
+			.catch((error) => {
+				log("error", error);
+				process.exit(1);
+			});
+	}
+
+	const { server, port: actualPort } = await startServer(
+		global.app.get("port"),
+	);
+
+	setWatcher(server);
+
+	log("success", `${t("serverStarted").replace("{{port}}", actualPort)}\n`);
+
+	return server;
+}
+
+/**
+ * @param {number} port - the port that should be used
+ * @returns {Promise} gets resolved with the server instance and the actual port
+ */
+function startServer(port) {
+	const server = http.createServer(global.app);
+
+	return new Promise((resolve) => {
+		server
+			.listen(port, function () {
+				resolve({ server, port });
+			})
+			.on("error", (error) => {
+				if (error["code"] === "EADDRINUSE") {
+					log(
+						"error",
+						t("portInUse").replace("{{port}}", port),
+						error.toString(),
+					);
+					server.close(async function () {
+						const response = await startServer(port + 1);
+
+						resolve(response);
+					});
+				}
+			});
+	});
+}

package/lib/init/rendering.js

@@ -0,0 +1,12 @@
+import init from "./index.js";
+
+/**
+ * Runs the renderer to either start the server or create a build
+ * @param {object} config - the user configuration object
+ * @returns {Promise<object>}
+ */
+export default async function initRendering(config) {
+	if (config) {
+		return await init(config);
+	}
+}