@griddo/cx 11.9.9-rc.0 → 11.9.9-rc.2

package/exporter/utils/folders.ts

@@ -0,0 +1,320 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import fsx, { type MakeDirectoryOptions } from "fs-extra";
+
+import { throwError } from "../errors";
+import { getConfig, walkStore } from "./core-utils";
+import { verboseLog } from "./loggin";
+import { ArtifactError } from "../errors/errors-data";
+
+const config = getConfig();
+
+/**
+ * Remove an empty directory from the basePath recursively.
+ * If the directory has only .xml files it will handle as empty too (empty site)
+ *
+ * @param baseDir - The base directory.
+ */
+function deleteDisposableSiteDirs() {
+	const { __cx } = config.paths();
+	const baseDir = path.join(__cx, "dist");
+
+	if (!fs.existsSync(baseDir)) {
+		return;
+	}
+
+	const sitesDirs = fs
+		.readdirSync(baseDir, { withFileTypes: true })
+		.filter((file) => file.isDirectory());
+
+	for (const siteDir of sitesDirs) {
+		const sitePath = path.join(baseDir, siteDir.name);
+		if (siteIsEmpty(sitePath)) {
+			fs.rmSync(sitePath, { recursive: true });
+		}
+	}
+}
+
+/**
+ * Creates multiple directories.
+ *
+ * @param dirs - An array of directory paths.
+ * @param options - Same option as `fs.mkdirSync()`
+ */
+function createArtifacts(dirs: Array<string>, options?: MakeDirectoryOptions) {
+	for (const dir of dirs) {
+		try {
+			if (!fs.existsSync(dir)) {
+				fs.mkdirSync(dir, { recursive: true, ...options });
+				verboseLog(`create directory: ${dir}`);
+			}
+		} catch (error) {
+			throwError(ArtifactError, error);
+		}
+	}
+}
+
+function renameArtifact(src: string, dst: string) {
+	try {
+		if (fs.existsSync(src)) {
+			fs.renameSync(src, dst);
+			verboseLog(`rename ${src} to ${dst}`);
+		}
+	} catch (error) {
+		throwError(ArtifactError, error);
+	}
+}
+
+/**
+ * Copy multiple directories with backup option.
+ *
+ * @param src - Source directory.
+ * @param dst - Destination directory.
+ * @param dirs - Directories to copy.
+ * @param options.withBackup - Create a previous backup before copy.
+ */
+function copyArtifacts(
+	src: string,
+	dst: string,
+	dirs: Array<string>,
+	options = {
+		withBackup: false,
+	},
+) {
+	const { withBackup } = options;
+	for (const dir of dirs) {
+		const srcCompose = path.join(src, dir);
+		const dstCompose = path.join(dst, dir);
+
+		// The dir we want to copy, doesn't exist.
+		if (!fsx.existsSync(srcCompose)) {
+			console.log(
+				`(Maybe first render) Source directory does not exist: ${srcCompose}`,
+			);
+			continue;
+		}
+
+		// Create the backup
+		if (withBackup) {
+			createBackup(dstCompose);
+			verboseLog(`create backup: ${dstCompose}`);
+		}
+
+		// Copy directory
+		try {
+			// First clean destination
+			if (fsx.existsSync(dstCompose)) {
+				fs.rmSync(dstCompose, { recursive: true, force: true });
+				verboseLog(`clean destination: ${dstCompose}`);
+			}
+
+			// Then copy src to dst
+			fs.cpSync(srcCompose, dstCompose, {
+				recursive: true,
+				preserveTimestamps: true,
+			});
+			verboseLog(`copy: ${srcCompose} to ${dstCompose}`);
+
+			if (withBackup) {
+				deleteBackup(dstCompose);
+				verboseLog(`delete backup: ${dstCompose}`);
+			}
+		} catch (error) {
+			if (withBackup) {
+				restoreBackup(dstCompose);
+				console.log("Backup has been restored.");
+			}
+
+			throwError(ArtifactError, error);
+		}
+	}
+}
+
+/**
+ * Move artifacts between cx-paths
+ *
+ * @param src - Source directory.
+ * @param dst - Destination directory.
+ * @param dirs - Directories to move.
+ * @param options - Options.
+ */
+function moveArtifacts(
+	src: string,
+	dst: string,
+	dirs: Array<string>,
+	options?: { withBackup?: boolean; override?: boolean },
+) {
+	const { override, withBackup } = options || {};
+
+	for (const dir of dirs) {
+		const srcCompose = path.join(src, dir);
+		const dstCompose = path.join(dst, dir);
+
+		if (!fsx.existsSync(srcCompose)) {
+			continue;
+		}
+
+		if (withBackup) {
+			createBackup(dstCompose);
+		}
+
+		try {
+			// Clean destination
+			if (override && fsx.existsSync(dstCompose)) {
+				fs.rmSync(dstCompose, { recursive: true, force: true });
+			}
+
+			fs.renameSync(srcCompose, dstCompose);
+			verboseLog(`moved: ${srcCompose} to ${dstCompose}`);
+
+			if (withBackup) {
+				deleteBackup(dstCompose);
+			}
+		} catch (error) {
+			if (withBackup) {
+				restoreBackup(dstCompose);
+				console.log("Backup has been restored.");
+			}
+
+			throwError(ArtifactError, error);
+		}
+	}
+}
+
+/**
+ * Removes multiple artifact directories.
+ *
+ * @param artifacts - An array of artifact directory paths.
+ */
+function removeArtifacts(artifacts: Array<string>) {
+	for (const dir of artifacts) {
+		if (!dir) {
+			continue;
+		}
+
+		try {
+			if (fsx.existsSync(dir)) {
+				const kind = fs.statSync(dir).isDirectory() ? "dir" : "file";
+				fs.rmSync(dir, { recursive: true, force: true });
+				verboseLog(`artifact (${kind}) removed: ${dir}`);
+			}
+		} catch (error) {
+			throwError(ArtifactError, error);
+		}
+	}
+}
+
+function restoreBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+	try {
+		fs.renameSync(dst, src);
+		console.log(`Backup ${dst} has been restored`);
+	} catch (error) {
+		console.log(error);
+		throw new Error(`Error while delete ${dst} backup`);
+	}
+}
+
+function deleteBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+
+	if (!fsx.existsSync(dst)) {
+		return;
+	}
+
+	try {
+		fs.rmSync(dst, { recursive: true, force: true });
+		console.log(`Backup ${dst} has been deleted`);
+	} catch (error) {
+		console.log(error);
+		throw new Error(`Error while delete ${dst} backup`);
+	}
+}
+
+function createBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+
+	if (!fsx.existsSync(src)) {
+		return;
+	}
+
+	if (fsx.existsSync(dst)) {
+		console.log(`Destination ${dst} already exists`);
+		return;
+	}
+
+	try {
+		fs.renameSync(src, dst);
+		console.log(`Backup of ${src} has been created in ${dst}`);
+	} catch (error) {
+		console.log(`Error while coping ${src} to ${dst} backup`);
+		throwError(ArtifactError, error);
+	}
+}
+
+/**
+ * Elimina todas las páginas del store (de todos los sites) cuyo nombre empiece con un guión "-".
+ * Estas páginas son "virtuales" y no tienen ids desde API por lo que mantenerlas en el store es un problema cuando se hacen modificaciones en la página "madre".
+ * La solución por ahora es borrarlas del store y rehacerlas en todos los renders.
+ */
+async function removeVirtualPagesFromStore() {
+	const { __cx } = config.paths();
+	const storePath = path.join(__cx, "store");
+
+	try {
+		const allJsonPageFilesPath = walkStore(storePath);
+
+		for (const filePath of allJsonPageFilesPath) {
+			if (path.basename(filePath).startsWith("-")) {
+				fs.unlinkSync(filePath);
+			}
+		}
+	} catch (error) {
+		console.info(
+			"`store` folder does not exist. Skipping multipage or static list template cleaning.",
+			error,
+		);
+	}
+}
+
+/**
+ * Return true if the site folder is empty or only has xml files. (Recursively)
+ */
+function siteIsEmpty(sitePath: string) {
+	const siteFiles = fs
+		.readdirSync(sitePath, {
+			withFileTypes: true,
+			recursive: true,
+		})
+		.filter(
+			(file) => file.isFile() && !path.basename(file.name).startsWith("."),
+		);
+
+	const xmlFiles = siteFiles.filter((file) => file.name.endsWith(".xml"));
+
+	if (siteFiles.length === xmlFiles.length) {
+		return true;
+	}
+}
+
+function prependFileSync(filePath: string, content: string) {
+	let currentContent = "";
+
+	if (fs.existsSync(filePath)) {
+		currentContent = fs.readFileSync(filePath, "utf8");
+	}
+
+	fs.writeFileSync(filePath, content + currentContent, "utf8");
+}
+
+export {
+	copyArtifacts,
+	createArtifacts,
+	deleteDisposableSiteDirs,
+	moveArtifacts,
+	prependFileSync,
+	removeArtifacts,
+	removeVirtualPagesFromStore,
+	renameArtifact,
+};

package/exporter/utils/health-checks.ts

@@ -0,0 +1,64 @@
+import { boxLog } from "./loggin";
+import { envs } from "../constants";
+
+const GRIDDO_ENVS_VARS: ReadonlyArray<string> = [];
+
+/**
+ * Check if the environment is secure to launch a render.
+ * If something fails then log an error message and exit from the process.
+ * Otherwise just return true.
+ */
+function checkRenderHealthOrExit() {
+	// Bypass the check using this env var, handy for local renders.
+	if (envs.GRIDDO_SKIP_BUILD_CHECKS) {
+		console.info("Build health check skipped");
+
+		return true;
+	}
+
+	// Checklist
+	const envsVars = checkEnvsVars(GRIDDO_ENVS_VARS);
+
+	// Render is safe if...
+	const renderingIsSave = envsVars;
+
+	// The environment is suitable for a build-render
+	if (renderingIsSave) {
+		console.info("Build health check passed");
+
+		return true;
+	}
+
+	// Error
+	boxLog(
+		"Error. The environment is not suitable for a build.",
+		"Not valid environment",
+	);
+	process.exit(1);
+}
+
+/**
+ * Check if a list of environments variables exist with any value.
+ *
+ * @todo Also check the value.
+ * @param envs An array of environments variables
+ * @returns exists with (1) if there are missing envs vars
+ */
+function checkEnvsVars(envs: ReadonlyArray<string>) {
+	const missingEnvs = envs.filter((envName) => {
+		return !process.env[envName];
+	});
+
+	if (missingEnvs.length) {
+		const missingEnvsMsg = missingEnvs.join("\n");
+		console.error(
+			`Env check failed. These envs vars are missing: \n\n${missingEnvsMsg}`,
+		);
+
+		return false;
+	}
+
+	return true;
+}
+
+export { checkRenderHealthOrExit };

package/exporter/{core → utils}/images.ts

@@ -13,7 +13,12 @@ import type { Fields } from "@griddo/core";
  * formatImage("https://images.griddo.io/tree", 300, 200, "jpg")
  * // https://images.griddo.io/tree/w/300/h/200/f/jpg
  */
-function formatImage(image: Fields.Image | string, width: number, height: number, format = "jpg") {
+function formatImage(
+	image: Fields.Image | string,
+	width: number,
+	height: number,
+	format = "jpg",
+) {
 	const url = typeof image === "string" ? image : image?.url;
 
 	if (!url) {

package/exporter/{core → utils}/instance.ts

@@ -1,9 +1,10 @@
 import path from "node:path";
 
-import { NoJSConfigFileFound } from "../shared/errors";
-import { findUpSync } from "../shared/npm-modules/find-up-simple";
-import { pkgDirSync } from "../shared/npm-modules/pkg-dir";
-import { throwError } from "./errors";
+import findUp from "find-up";
+import pkgDir from "pkg-dir";
+
+import { throwError } from "../errors";
+import { NoJSConfigFileFound } from "../errors/errors-data";
 
 // Consts
 const isComponentLibrary = __dirname.includes("node_modules");
@@ -16,18 +17,22 @@ const componentLibraryPathAlias = getComponentsLibAliases();
  */
 function resolveComponentsPath(customPath = "") {
 	return isComponentLibrary
-		? path.resolve(pkgDirSync({ cwd: __dirname }) as string, "../../../", customPath)
-		: path.resolve(pkgDirSync({ cwd: __dirname }) as string, "../griddo-components", customPath);
+		? path.resolve(pkgDir.sync(__dirname) as string, "../../../", customPath)
+		: path.resolve(
+				pkgDir.sync(__dirname) as string,
+				"../griddo-components",
+				customPath,
+			);
 }
 
 /**
  * Return the instance or monorepo components {t|j}sconfig.json file.
  */
 function getComponentsJSConfig() {
-	const jsConfigPath = findUpSync("jsconfig.json", {
+	const jsConfigPath = findUp.sync("jsconfig.json", {
 		cwd: resolveComponentsPath(),
 	});
-	const tsConfigPath = findUpSync("tsconfig.json", {
+	const tsConfigPath = findUp.sync("tsconfig.json", {
 		cwd: resolveComponentsPath(),
 	});
 
@@ -52,7 +57,6 @@ function getComponentsLibAliases() {
 			const absolutePath = resolveComponentsPath(relativePathToDir);
 
 			return {
-				// biome-ignore lint/performance/noAccumulatingSpread: to be fixed
 				...currentAlias,
 				[aliasKey]: absolutePath,
 			};

package/exporter/utils/loggin.ts

@@ -0,0 +1,184 @@
+import type { Site } from "../types/sites";
+
+import kleur from "kleur";
+
+import { envs } from "../constants";
+import { getConfig } from "./core-utils";
+
+/**
+ * Custom basic logging function controlled by a environment variable.
+ *
+ * @param str The string to be logged.
+ */
+function verboseLog(str: string) {
+	if (envs.GRIDDO_VERBOSE_LOGS) {
+		console.log(
+			kleur.yellow("verbose"),
+			kleur.dim(str.replace(/(\s)\s+/g, "$1").trim()),
+		);
+	}
+}
+
+/**
+ * Custom log inside a line-box.
+ *
+ * @param stringValue The string to be logged.
+ * @param paddingInline The number of white spaces inside the box at left and right.
+ * @param paddingBlock The number of white spaces inside the box at top and bottom.
+ */
+function boxLog(
+	stringValue: string,
+	title = "",
+	paddingInline = 1,
+	paddingBlock = 1,
+) {
+	const lines = stringValue
+		.split("\n") // lines
+		.map((line) => line.trim()); // remove extra spaces
+	const windowTitle = title ? ` ${title} ` : "";
+	const windowTitleLength = title ? windowTitle.length : 0;
+	const longerContent =
+		Math.max(...lines.map((l) => l.length)) + paddingInline * 2;
+	const longerLine = Math.max(longerContent, windowTitleLength);
+	const paddingBlockString = `│${" ".repeat(longerLine)}│\n`.repeat(
+		paddingBlock,
+	);
+	const minWidth = longerLine;
+	const borderTop = `╭${windowTitle}${"─".repeat(
+		minWidth - windowTitleLength,
+	)}╮\n`;
+	const borderBottom = `╰${"─".repeat(minWidth)}╯`;
+	const content = lines
+		.map((l) => {
+			const mr = " ".repeat(longerLine - l.length - paddingInline);
+			return `│${" ".repeat(paddingInline)}${l}${mr}│\n`;
+		})
+		.join("");
+
+	console.log(
+		`${borderTop}${paddingBlockString}${content}${paddingBlockString}${borderBottom}`,
+	);
+}
+
+/**
+ * Custom basic logging function controlled by a environment variable.
+ * Strip double spaces.
+ *
+ * @param str The string to be logged.
+ */
+function buildLog(str: string) {
+	if (envs.GRIDDO_BUILD_LOGS) {
+		console.log(str.replace(/(\s)\s+/g, "$1").trim());
+	}
+}
+
+/**
+ * Console log with a blue color in the info prefix.
+ * @param str The string to be logged.
+ */
+function infoLog(str: string) {
+	console.log(`${kleur.blue("info")} ${str}`);
+}
+
+/**
+ * Console log with a green color in the success prefix.
+ * @param str The string to be logged.
+ */
+function successLog(str: string) {
+	console.log(`${kleur.green("success")} ${str}`);
+}
+
+/**
+ * Internal log
+ * @param values The values to be logged.
+ */
+function debugLog(...values: Array<unknown>) {
+	if (!envs.GRIDDO_DEBUG_LOGS) {
+		return;
+	}
+	console.log(...values);
+}
+
+/**
+ * Return a scale size colors with a number and a measure string (KB by default).
+ *
+ * @param size The page size in KB.
+ * @param measure The measure string to be added in the log.
+ */
+function pageSizeLog(size: number, measure = "KB") {
+	const sizeScale = {
+		low: 50,
+		mid: 80,
+		large: 130,
+		extraLarge: 210,
+	};
+
+	// Ternary pawa!
+	const color =
+		size > sizeScale.large
+			? "red"
+			: size > sizeScale.mid
+				? "magenta"
+				: size > sizeScale.low
+					? "blue"
+					: "green";
+
+	return kleur[color](kleur.bold(`${size}${measure}`));
+}
+
+/**
+ * Console log the Griddo exporter version.
+ */
+function showExporterVersion() {
+	console.clear();
+	const config = getConfig();
+	const { griddoVersion } = config;
+	const logo = `\n${kleur
+		.bgYellow()
+		.black()
+		.bold(" Griddo Exporter " + griddoVersion + " ")}\n`;
+
+	console.log(logo);
+}
+
+function listSitesLog(title: string, sites: Array<Site>) {
+	const maxline = Math.max(
+		...sites.map(
+			(s) =>
+				s.name.length + (s.shouldBeUpdated ? 1 : 0) + s.id.toString().length,
+		),
+	);
+
+	const sitesStr = sites.map((s) => {
+		const shouldBeUpdated = s.shouldBeUpdated ? "*" : "";
+		const lineLen =
+			s.name.length + shouldBeUpdated.length + s.id.toString().length;
+		const padding = " ".repeat(maxline - lineLen);
+		return `${kleur.bold(s.name)} ${kleur.dim("(" + s.id + ")")} ${shouldBeUpdated} ${padding}${kleur.dim("-")} ${kleur.dim(s.slug)}`;
+	});
+
+	const sitesOutput =
+		sitesStr.length > 0
+			? "\n\n" + sitesStr.join("\n")
+			: kleur.dim("--none--\n");
+
+	console.log(`
+${title} ${sitesOutput}`);
+}
+
+function errorLabelLog(msg: string) {
+	console.error("\n" + kleur.black().bgRed(" " + msg + " ") + "\n");
+}
+
+export {
+	boxLog,
+	buildLog,
+	debugLog,
+	errorLabelLog,
+	infoLog,
+	listSitesLog,
+	pageSizeLog,
+	showExporterVersion,
+	successLog,
+	verboseLog,
+};