@schalkneethling/miyagi-core 4.0.2

package/lib/mocks/resolve/ref.js

@@ -0,0 +1,484 @@
+import path from "path";
+import deepMerge from "deepmerge";
+
+import * as helpers from "../../helpers.js";
+import { t } from "../../i18n/index.js";
+import { mergeRootDataWithVariationData } from "../resolve.js";
+
+/**
+ * @param {object|Array|string|boolean} entry - a value from the mock data object
+ * @param {object} component
+ * @returns {Promise<object|Array|string|boolean>} the resolved value from the mock data object
+ */
+export const resolveRefs = async function (entry, component) {
+	const messages = [];
+
+	if (entry) {
+		if (
+			typeof entry === "string" ||
+			typeof entry === "number" ||
+			typeof entry === "boolean" ||
+			entry instanceof Map ||
+			entry === null
+		) {
+			return {
+				messages,
+				data: entry,
+			};
+		}
+
+		if (entry instanceof Array) {
+			const o = [];
+
+			for (const ent of entry) {
+				let newComponent = component;
+
+				if (ent.$ref) {
+					if (!ent.$ref.startsWith("#/$defs/")) {
+						if (ent.$ref.startsWith("/")) {
+							ent.$ref = ent.$ref.replace("/", "");
+						}
+						const path = ent.$ref.split("#")[0];
+						const { resolved, message } = resolveNamespace(path);
+
+						if (resolved) {
+							newComponent = global.state.routes.find(
+								(route) => route.paths.dir.short === resolved,
+							);
+						} else {
+							messages.push(message);
+						}
+					}
+				}
+
+				const json = await resolve(ent, newComponent);
+				const result = await resolveRefs(json.data, newComponent);
+
+				o.push(result.data);
+
+				for (const msg of [...json.messages, ...result.messages]) {
+					if (msg) {
+						messages.push(msg);
+					}
+				}
+			}
+
+			return {
+				messages,
+				data: o,
+			};
+		}
+
+		let o = entry;
+
+		for (const [key, value] of Object.entries({ ...entry })) {
+			if (key === "$ref") {
+				let newComponent;
+
+				if (value.startsWith("#/$defs/")) {
+					newComponent = component;
+				} else {
+					let path = value.split("#")[0];
+
+					if (path.startsWith("/")) {
+						path = path.replace("/", "");
+					}
+
+					const { resolved, message } = resolveNamespace(path);
+
+					if (resolved) {
+						newComponent = global.state.routes.find(
+							(route) => route.paths.dir.short === resolved,
+						);
+					} else {
+						messages.push(message);
+					}
+				}
+
+				let { message, data: resolvedValue } =
+					await getRootOrVariantDataOfReference(value, newComponent);
+
+				if (message) {
+					messages.push(message);
+				}
+
+				const json = await resolve(resolvedValue, newComponent);
+				const result = await resolveRefs(json.data, newComponent);
+
+				for (const msg of [...json.messages, ...result.messages]) {
+					if (msg) {
+						messages.push(msg);
+					}
+				}
+
+				o = { ...o, ...result.data };
+
+				delete o.$ref;
+			} else {
+				const json = await resolve(value, component);
+				const result = await resolveRefs(json.data, component);
+
+				o[key] = result.data;
+
+				for (const msg of [...json.messages, ...result.messages]) {
+					if (msg) {
+						messages.push(msg);
+					}
+				}
+			}
+		}
+
+		return {
+			messages,
+			data: o,
+		};
+	}
+
+	return {
+		messages,
+		data: entry,
+	};
+};
+
+/**
+ * @param {object|Array|string|boolean} entry - a value from the mock data object
+ * @param {object} component
+ * @returns {Promise<object|Array|string|boolean>} the resolved value from the mock data object
+ */
+async function resolve(entry, component) {
+	const messages = [];
+
+	if (entry !== null) {
+		if (Array.isArray(entry)) {
+			return {
+				messages,
+				data: entry,
+			};
+		}
+
+		if (
+			typeof entry === "string" ||
+			typeof entry === "number" ||
+			typeof entry === "boolean" ||
+			entry instanceof Map ||
+			entry === null
+		) {
+			return {
+				messages,
+				data: entry,
+			};
+		}
+
+		if (entry === undefined) {
+			return {
+				messages: [
+					...messages,
+					{
+						type: "warn",
+						text: t("referencedMockFileNotFound"),
+					},
+				],
+				data: entry,
+			};
+		}
+
+		if (entry.$ref) {
+			const customData = helpers.cloneDeep(entry);
+			delete customData.$ref;
+
+			let newComponent;
+
+			if (entry.$ref.startsWith("#/$defs/")) {
+				newComponent = component;
+			} else {
+				let path = entry.$ref.split("#")[0];
+
+				if (path.startsWith("/")) {
+					path = path.replace("/", "");
+				}
+
+				const { resolved, message } = resolveNamespace(path);
+
+				if (resolved) {
+					newComponent = global.state.routes.find(
+						(route) => route.paths.dir.short === resolved,
+					);
+
+					if (!newComponent) {
+						messages.push({
+							type: "warn",
+							text: `${resolved} not found`,
+						});
+					}
+				} else {
+					messages.push(message);
+				}
+			}
+
+			if (newComponent) {
+				const { message, data } = await getRootOrVariantDataOfReference(
+					entry.$ref,
+					newComponent,
+				);
+
+				return {
+					messages: [...messages, message],
+					data: deepMerge(data, customData),
+				};
+			} else {
+				return {
+					messages,
+					data: customData,
+				};
+			}
+		}
+	}
+
+	return {
+		messages,
+		data: entry,
+	};
+}
+
+/**
+ * @param {string} ref - the reference to another mock data
+ * @param {object} component
+ * @returns {Promise<object>} the resolved data object
+ */
+async function getRootOrVariantDataOfReference(ref, component) {
+	const { mocks } = global.config.files;
+
+	let [shortVal, variation] = ref.split("#");
+	let jsonFromData;
+	let mocksBaseName;
+	let fullPath;
+
+	if (ref.startsWith("#/$defs/")) {
+		const componentJson = helpers.cloneDeep(
+			global.state.fileContents[
+				component.paths.mocks.full(global.config.files.mocks.extension[0])
+			] ||
+				global.state.fileContents[
+					component.paths.mocks.full(global.config.files.mocks.extension[1])
+				],
+		);
+
+		mocksBaseName = ref;
+
+		const defRef = ref.replace("#/$defs/", "");
+		if ("$defs" in componentJson && defRef in componentJson.$defs) {
+			return {
+				data: componentJson.$defs[defRef],
+			};
+		}
+
+		return {
+			message: {
+				type: "warn",
+				text: t("fileNotFoundLinkIncorrect")
+					.replace("{{filePath}}", mocksBaseName)
+					.replace(
+						"{{component}}",
+						component.paths.mocks.short(
+							global.config.files.mocks.extension[0],
+						) ||
+							component.paths.mocks.short(
+								global.config.files.mocks.extension[1],
+							),
+					),
+			},
+			data: {},
+		};
+	}
+
+	if (ref.startsWith(`${global.config.files.mocks.name}/#/$defs/`)) {
+		const defaultFile = helpers.getFullPathFromShortPath(
+			`${global.config.files.mocks.name}.${global.config.files.mocks.extension[0]}`,
+		);
+		const jsFile = helpers.getFullPathFromShortPath(
+			`${global.config.files.mocks.name}.${global.config.files.mocks.extension[1]}`,
+		);
+		const globalData = {
+			...(global.state.fileContents[defaultFile] ||
+				global.state.fileContents[jsFile]),
+		};
+
+		const defRef = ref.replace(
+			`${global.config.files.mocks.name}/#/$defs/`,
+			"",
+		);
+
+		if (defRef in globalData.$defs) {
+			return {
+				data: globalData.$defs[defRef],
+			};
+		}
+
+		return {
+			message: {
+				type: "warn",
+				text: t("fileNotFoundLinkIncorrect")
+					.replace("{{filePath}}", ref)
+					.replace(
+						"{{component}}",
+						component.paths.mocks.short(
+							global.config.files.mocks.extension[0],
+						) ||
+							component.paths.mocks.short(
+								global.config.files.mocks.extension[1],
+							),
+					),
+			},
+			data: {},
+		};
+	}
+
+	if (shortVal.startsWith("@")) {
+		const namespace = shortVal.split("/")[0];
+		const resolvedNamespace = global.config.namespaces[namespace];
+
+		if (!resolvedNamespace) {
+			return {
+				message: {
+					type: "warn",
+					text: `Could not resolve namespace ${namespace}`,
+				},
+				data: null,
+			};
+		}
+
+		shortVal = path.relative(namespace, shortVal);
+		mocksBaseName = path.join(shortVal, mocks.name);
+		fullPath = path.join(
+			process.cwd(),
+			resolvedNamespace,
+			shortVal,
+			mocks.name,
+		);
+	} else {
+		mocksBaseName = path.join(shortVal, mocks.name);
+		fullPath = helpers.getFullPathFromShortPath(mocksBaseName);
+	}
+
+	jsonFromData =
+		global.state.fileContents[`${fullPath}.${mocks.extension[0]}`] ||
+		global.state.fileContents[`${fullPath}.${mocks.extension[1]}`];
+
+	if (jsonFromData) {
+		if (variation?.startsWith("/$defs/") && "$defs" in jsonFromData) {
+			const defRef = variation.replace("/$defs/", "");
+
+			if (defRef in jsonFromData.$defs) {
+				return {
+					data: jsonFromData.$defs[defRef],
+				};
+			}
+
+			return {
+				message: {
+					type: "warn",
+					text: t("fileNotFoundLinkIncorrect")
+						.replace("{{filePath}}", ref)
+						.replace(
+							"{{component}}",
+							component.paths.mocks.short(
+								global.config.files.mocks.extension[0],
+							) ||
+								component.paths.mocks.short(
+									global.config.files.mocks.extension[1],
+								),
+						),
+				},
+				data: {},
+			};
+		}
+
+		const embeddedJson = jsonFromData;
+		const rootJson = helpers.removeInternalKeys(embeddedJson);
+		let variantJson = {};
+		let message;
+
+		if (variation && embeddedJson.$variants && embeddedJson.$variants.length) {
+			const variant = embeddedJson.$variants.find((vari) => {
+				if (vari.$name) {
+					return (
+						helpers.normalizeString(vari.$name) ===
+						helpers.normalizeString(variation)
+					);
+				}
+				return false;
+			});
+
+			if (variant) {
+				variantJson = helpers.removeInternalKeys(variant);
+			} else {
+				message = {
+					type: "warn",
+					text: t("variationNotFound")
+						.replace("{{variation}}", variation)
+						.replace("{{fileName}}", mocksBaseName),
+				};
+			}
+		}
+
+		return {
+			message,
+			data: mergeRootDataWithVariationData(
+				helpers.cloneDeep(rootJson),
+				variantJson,
+			),
+		};
+	}
+
+	return {
+		message: {
+			type: "warn",
+			text: t("fileNotFoundLinkIncorrect")
+				.replace("{{filePath}}", mocksBaseName)
+				.replace(
+					"{{component}}",
+					component.paths.mocks.short(global.config.files.mocks.extension[0]) ||
+						component.paths.mocks.short(global.config.files.mocks.extension[1]),
+				),
+		},
+		data: {},
+	};
+}
+
+/**
+ * @param {string} namespacedPath
+ * @returns {object}
+ */
+function resolveNamespace(namespacedPath) {
+	if (
+		!Object.keys(global.config.namespaces).some((namespace) =>
+			namespacedPath.startsWith(namespace),
+		)
+	) {
+		return {
+			resolved: namespacedPath,
+		};
+	}
+
+	const namespace = namespacedPath.split("/")[0];
+	const resolvedNamespace = global.config.namespaces[namespace];
+
+	if (!resolvedNamespace) {
+		return {
+			message: {
+				type: "warn",
+				text: `Could not resolve namespace ${namespace}`,
+			},
+			resolved: null,
+		};
+	}
+
+	return {
+		resolved: namespacedPath.replace(
+			namespace,
+			helpers.getShortPathFromFullPath(
+				path.join(process.cwd(), resolvedNamespace),
+			),
+		),
+	};
+}

package/lib/mocks/resolve/tpl.js

@@ -0,0 +1,246 @@
+import fs from "fs";
+import path from "node:path";
+
+import * as helpers from "../../helpers.js";
+import { t } from "../../i18n/index.js";
+import { extendTemplateData } from "../../render/helpers.js";
+import { overwriteRenderKey } from "../resolve.js";
+
+/**
+ * @param {object|Array|string|boolean} entry - a value from the mock data object
+ * @returns {Promise<{ messages, data }>} the resolved value from the mock data object
+ */
+export const resolveTpls = async function (entry) {
+	const messages = [];
+
+	if (entry) {
+		if (
+			typeof entry === "string" ||
+			typeof entry === "number" ||
+			typeof entry === "boolean" ||
+			entry instanceof Map ||
+			entry === null
+		) {
+			return {
+				messages,
+				data: entry,
+			};
+		}
+
+		if (entry instanceof Array) {
+			const o = [];
+
+			for (const ent of entry) {
+				const json = await resolve(ent);
+				const result = await resolveTpls(json.data);
+
+				o.push(result.data);
+
+				for (const msg of [...json.messages, ...result.messages]) {
+					if (msg) {
+						messages.push(msg);
+					}
+				}
+			}
+
+			return {
+				messages,
+				data: o,
+			};
+		}
+
+		const o = { ...entry };
+
+		for (const key of Object.keys(o)) {
+			const tpl = await resolve(o[key]);
+			const tpls = await resolveTpls(tpl.data);
+
+			for (const msg of [...tpl.messages, ...tpls.messages]) {
+				if (msg) {
+					messages.push(msg);
+				}
+			}
+
+			o[key] = tpls.data;
+		}
+
+		return {
+			messages,
+			data: o,
+		};
+	}
+
+	return {
+		messages,
+		data: entry,
+	};
+};
+
+/**
+ * @param {object|Array|string|boolean} entry
+ * @returns {Promise<{ messages, data }>}
+ */
+async function resolve(entry) {
+	const messages = [];
+
+	if (entry !== null) {
+		if (Array.isArray(entry)) {
+			const arr = [];
+
+			for (const ent of entry) {
+				const result = await resolve(ent);
+
+				arr.push(result.data);
+
+				for (const msg of messages) {
+					if (msg) {
+						messages.push();
+					}
+				}
+			}
+
+			return {
+				messages,
+				data: arr,
+			};
+		}
+
+		if (
+			typeof entry === "string" ||
+			typeof entry === "number" ||
+			typeof entry === "boolean" ||
+			entry instanceof Map
+		) {
+			return {
+				messages,
+				data: entry,
+			};
+		}
+
+		let entries = { ...entry };
+
+		for (const [key, val] of Object.entries(entries)) {
+			if (key !== "$tpl") {
+				const result = await resolve(val);
+
+				entries[key] = result.data;
+			}
+		}
+
+		const result = await render(entries);
+
+		return {
+			messages: [...messages, ...result.messages],
+			data: result.data,
+		};
+	}
+
+	return {
+		messages,
+		data: entry,
+	};
+}
+
+/**
+ * @param {object|Array|string|boolean} entry
+ * @returns {Promise<{ messages, data }>}
+ */
+async function render(entry) {
+	const messages = [];
+
+	if (entry.$tpl) {
+		let data = { ...entry };
+		delete data.$tpl;
+		let filePath;
+		let shortPath;
+		let component;
+
+		if (entry.$tpl.startsWith("@")) {
+			const namespace = entry.$tpl.split("/")[0];
+			const resolvedNamespace = global.config.namespaces[namespace];
+
+			if (!resolvedNamespace) {
+				return {
+					messages: [
+						{
+							type: "warn",
+							text: `Could not resolve namespace ${namespace}`,
+						},
+					],
+					data: null,
+				};
+			}
+
+			shortPath = helpers.getShortPathFromFullPath(
+				path.join(
+					process.cwd(),
+					entry.$tpl.replace(namespace, resolvedNamespace),
+				),
+			);
+		} else {
+			shortPath = entry.$tpl;
+
+			if (shortPath.startsWith("/")) {
+				shortPath = shortPath.replace("/", "");
+			}
+		}
+
+		component = global.state.routes.find(
+			({ alias }) => alias === shortPath || `/${alias}` === shortPath,
+		);
+
+		if (!component) {
+			messages.push({
+				type: "error",
+				text: t("templateDoesNotExist").replace("{{template}}", entry.$tpl),
+			});
+
+			return {
+				messages,
+				data: null,
+			};
+		}
+
+		try {
+			fs.statSync(component.paths.tpl.full);
+
+			data = await extendTemplateData(global.config, data, component);
+
+			return new Promise((resolve1) => {
+				global.app.render(component.paths.tpl.full, data ?? {}, (err, html) => {
+					if (err) {
+						messages.push({
+							type: "warn",
+							text: t("renderingTemplateFailed").replace(
+								"{{filePath}}",
+								component.paths.tpl.short,
+							),
+						});
+					}
+
+					resolve1({
+						messages,
+						data: html,
+					});
+				});
+			});
+		} catch (err) {
+			if (err.code === "ENOENT") {
+				messages.push({
+					type: "error",
+					text: t("templateDoesNotExist").replace("{{template}}", filePath),
+					verbose: err,
+				});
+				return {
+					messages,
+					data: null,
+				};
+			}
+		}
+	} else {
+		return {
+			messages,
+			data: overwriteRenderKey(entry),
+		};
+	}
+}