@griddo/cx 11.7.12-rc.4 → 11.7.12

package/exporter/utils/folders.ts

@@ -1,12 +1,14 @@
-import type { MakeDirectoryOptions } from "node:fs";
-
-import fsp from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
 
-import { ArtifactError } from "../constants/errors";
-import { walkStore } from "./core-utils";
-import { throwError } from "./errors";
+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.
@@ -14,34 +16,37 @@ import { verboseLog } from "./loggin";
  *
  * @param baseDir - The base directory.
  */
-async function deleteDisposableSiteDirs(baseDir: string) {
-	if (!(await pathExists(baseDir))) {
+function deleteDisposableSiteDirs() {
+	const { __cx } = config.paths();
+	const baseDir = path.join(__cx, "dist");
+
+	if (!fs.existsSync(baseDir)) {
 		return;
 	}
 
-	const sitesDirs = (await fsp.readdir(baseDir, { withFileTypes: true })).filter((file) =>
-		file.isDirectory(),
-	);
+	const sitesDirs = fs
+		.readdirSync(baseDir, { withFileTypes: true })
+		.filter((file) => file.isDirectory());
 
 	for (const siteDir of sitesDirs) {
 		const sitePath = path.join(baseDir, siteDir.name);
-		if (await siteIsEmpty(sitePath)) {
-			await fsp.rm(sitePath, { recursive: true });
+		if (siteIsEmpty(sitePath)) {
+			fs.rmSync(sitePath, { recursive: true });
 		}
 	}
 }
 
 /**
- * Creates multiple artifact directories.
+ * Creates multiple directories.
  *
  * @param dirs - An array of directory paths.
  * @param options - Same option as `fs.mkdirSync()`
  */
-async function createDirs(dirs: Array<string>, options?: MakeDirectoryOptions) {
+function createArtifacts(dirs: Array<string>, options?: MakeDirectoryOptions) {
 	for (const dir of dirs) {
 		try {
-			if (!(await pathExists(dir))) {
-				await fsp.mkdir(dir, { recursive: true, ...options });
+			if (!fs.existsSync(dir)) {
+				fs.mkdirSync(dir, { recursive: true, ...options });
 				verboseLog(`create directory: ${dir}`);
 			}
 		} catch (error) {
@@ -50,10 +55,10 @@ async function createDirs(dirs: Array<string>, options?: MakeDirectoryOptions) {
 	}
 }
 
-async function renamePath(src: string, dst: string) {
+function renameArtifact(src: string, dst: string) {
 	try {
-		if (await pathExists(src)) {
-			await fsp.rename(src, dst);
+		if (fs.existsSync(src)) {
+			fs.renameSync(src, dst);
 			verboseLog(`rename ${src} to ${dst}`);
 		}
 	} catch (error) {
@@ -69,7 +74,7 @@ async function renamePath(src: string, dst: string) {
  * @param dirs - Directories to copy.
  * @param options.withBackup - Create a previous backup before copy.
  */
-async function copyDirs(
+function copyArtifacts(
 	src: string,
 	dst: string,
 	dirs: Array<string>,
@@ -83,40 +88,42 @@ async function copyDirs(
 		const dstCompose = path.join(dst, dir);
 
 		// The dir we want to copy, doesn't exist.
-		if (!(await pathExists(srcCompose))) {
-			console.log(`(Maybe first render) Source directory does not exist: ${srcCompose}`);
+		if (!fsx.existsSync(srcCompose)) {
+			console.log(
+				`(Maybe first render) Source directory does not exist: ${srcCompose}`,
+			);
 			continue;
 		}
 
 		// Create the backup
 		if (withBackup) {
-			await createBackup(dstCompose);
+			createBackup(dstCompose);
 			verboseLog(`create backup: ${dstCompose}`);
 		}
 
 		// Copy directory
 		try {
 			// First clean destination
-			if (await pathExists(dstCompose)) {
-				await fsp.rm(dstCompose, { recursive: true, force: true });
+			if (fsx.existsSync(dstCompose)) {
+				fs.rmSync(dstCompose, { recursive: true, force: true });
 				verboseLog(`clean destination: ${dstCompose}`);
 			}
 
 			// Then copy src to dst
-			await fsp.cp(srcCompose, dstCompose, {
+			fs.cpSync(srcCompose, dstCompose, {
 				recursive: true,
 				preserveTimestamps: true,
 			});
 			verboseLog(`copy: ${srcCompose} to ${dstCompose}`);
 
 			if (withBackup) {
-				await deleteBackup(dstCompose);
+				deleteBackup(dstCompose);
 				verboseLog(`delete backup: ${dstCompose}`);
 			}
 		} catch (error) {
 			if (withBackup) {
-				await restoreBackup(dstCompose);
-				verboseLog("Backup has been restored.");
+				restoreBackup(dstCompose);
+				console.log("Backup has been restored.");
 			}
 
 			throwError(ArtifactError, error);
@@ -132,7 +139,7 @@ async function copyDirs(
  * @param dirs - Directories to move.
  * @param options - Options.
  */
-async function moveDirs(
+function moveArtifacts(
 	src: string,
 	dst: string,
 	dirs: Array<string>,
@@ -144,29 +151,29 @@ async function moveDirs(
 		const srcCompose = path.join(src, dir);
 		const dstCompose = path.join(dst, dir);
 
-		if (!(await pathExists(srcCompose))) {
+		if (!fsx.existsSync(srcCompose)) {
 			continue;
 		}
 
 		if (withBackup) {
-			await createBackup(dstCompose);
+			createBackup(dstCompose);
 		}
 
 		try {
 			// Clean destination
-			if (override && (await pathExists(dstCompose))) {
-				await fsp.rm(dstCompose, { recursive: true, force: true });
+			if (override && fsx.existsSync(dstCompose)) {
+				fs.rmSync(dstCompose, { recursive: true, force: true });
 			}
 
-			await fsp.rename(srcCompose, dstCompose);
+			fs.renameSync(srcCompose, dstCompose);
 			verboseLog(`moved: ${srcCompose} to ${dstCompose}`);
 
 			if (withBackup) {
-				await deleteBackup(dstCompose);
+				deleteBackup(dstCompose);
 			}
 		} catch (error) {
 			if (withBackup) {
-				await restoreBackup(dstCompose);
+				restoreBackup(dstCompose);
 				console.log("Backup has been restored.");
 			}
 
@@ -178,23 +185,30 @@ async function moveDirs(
 /**
  * Removes multiple artifact directories.
  *
- * @param dirs - An array of directory paths.
+ * @param artifacts - An array of artifact directory paths.
  */
-async function removeDirs(dirs: Array<string>) {
-	for (const dir of dirs) {
+function removeArtifacts(artifacts: Array<string>) {
+	for (const dir of artifacts) {
+		if (!dir) {
+			continue;
+		}
+
 		try {
-			await fsp.rm(dir, { recursive: true, force: true });
-			verboseLog(`artifact removed: ${dir}`);
+			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);
 		}
 	}
 }
 
-async function restoreBackup(src: string, suffix = "-BACKUP") {
+function restoreBackup(src: string, suffix = "-BACKUP") {
 	const dst = src + suffix;
 	try {
-		await fsp.rename(dst, src);
+		fs.renameSync(dst, src);
 		console.log(`Backup ${dst} has been restored`);
 	} catch (error) {
 		console.log(error);
@@ -202,37 +216,37 @@ async function restoreBackup(src: string, suffix = "-BACKUP") {
 	}
 }
 
-async function deleteBackup(src: string, suffix = "-BACKUP") {
+function deleteBackup(src: string, suffix = "-BACKUP") {
 	const dst = src + suffix;
 
-	if (!(await pathExists(dst))) {
+	if (!fsx.existsSync(dst)) {
 		return;
 	}
 
 	try {
-		await fsp.rm(dst, { recursive: true, force: true });
-		verboseLog(`Backup ${dst} has been deleted`);
+		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`);
 	}
 }
 
-async function createBackup(src: string, suffix = "-BACKUP") {
+function createBackup(src: string, suffix = "-BACKUP") {
 	const dst = src + suffix;
 
-	if (!(await pathExists(src))) {
+	if (!fsx.existsSync(src)) {
 		return;
 	}
 
-	if (await pathExists(dst)) {
+	if (fsx.existsSync(dst)) {
 		console.log(`Destination ${dst} already exists`);
 		return;
 	}
 
 	try {
-		await fsp.rename(src, dst);
-		verboseLog(`Backup of ${src} has been created in ${dst}`);
+		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);
@@ -240,23 +254,25 @@ async function createBackup(src: string, suffix = "-BACKUP") {
 }
 
 /**
- * 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.
+ * 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 removeVirtualPages(dirPath: string) {
+async function removeVirtualPagesFromStore() {
+	const { __cx } = config.paths();
+	const storePath = path.join(__cx, "store");
+
 	try {
-		// Procesamos archivos uno por uno para evitar cargar todos en memoria
-		for await (const filePath of walkStore(dirPath)) {
+		const allJsonPageFilesPath = walkStore(storePath);
+
+		for (const filePath of allJsonPageFilesPath) {
 			if (path.basename(filePath).startsWith("-")) {
-				await fsp.unlink(filePath);
+				fs.unlinkSync(filePath);
 			}
 		}
 	} catch (error) {
 		console.info(
-			`${dirPath} folder does not exist. Skipping multipage or static list template cleaning.`,
+			"`store` folder does not exist. Skipping multipage or static list template cleaning.",
 			error,
 		);
 	}
@@ -265,13 +281,15 @@ async function removeVirtualPages(dirPath: string) {
 /**
  * Return true if the site folder is empty or only has xml files. (Recursively)
  */
-async function siteIsEmpty(sitePath: string) {
-	const siteFiles = (
-		await fsp.readdir(sitePath, {
+function siteIsEmpty(sitePath: string) {
+	const siteFiles = fs
+		.readdirSync(sitePath, {
 			withFileTypes: true,
 			recursive: true,
 		})
-	).filter((file) => file.isFile() && !path.basename(file.name).startsWith("."));
+		.filter(
+			(file) => file.isFile() && !path.basename(file.name).startsWith("."),
+		);
 
 	const xmlFiles = siteFiles.filter((file) => file.name.endsWith(".xml"));
 
@@ -280,106 +298,23 @@ async function siteIsEmpty(sitePath: string) {
 	}
 }
 
-/**
- * Delete empty directories from the given directory in a recursive way.
- */
-async function deleteEmptyDirectories(dirPath: string) {
-	try {
-		const stats = await fsp.stat(dirPath);
-
-		// Si no es un directorio, no hacemos nada
-		if (!stats.isDirectory()) {
-			return;
-		}
+function prependFileSync(filePath: string, content: string) {
+	let currentContent = "";
 
-		let filesInDirectory: string[];
-		try {
-			filesInDirectory = await fsp.readdir(dirPath);
-		} catch (err: any) {
-			// Si el directorio no existe o no se puede leer (ej. permisos), lo saltamos.
-			if (err.code === "ENOENT") {
-				console.warn(`The directory "${dirPath}" does not exist, skipping it.`);
-				return;
-			}
-			console.error(`Error al leer el directorio "${dirPath}":`, err);
-			throw err; // Re-lanza el error para que sea manejado por el llamador
-		}
-
-		// Recorrer los contenidos del directorio
-		for (const file of filesInDirectory) {
-			const fullPath = path.join(dirPath, file);
-			await deleteEmptyDirectories(fullPath); // Llamada recursiva síncrona
-		}
-
-		// Después de procesar todos los subdirectorios, verifica si el directorio actual está vacío
-		const remainingFiles = await fsp.readdir(dirPath);
-
-		if (remainingFiles.length === 0) {
-			try {
-				await fsp.rmdir(dirPath);
-				verboseLog(`Remove empty directory: ${dirPath}`);
-			} catch (err: any) {
-				// Puede que haya habido un problema de concurrencia o permisos
-				if (err.code === "ENOENT") {
-					console.warn(
-						`El directorio "${dirPath}" ya no existe. Posiblemente fue borrado por otra operación.`,
-					);
-				} else {
-					console.error(`Error al borrar el directorio "${dirPath}":`, err);
-				}
-			}
-		}
-	} catch (err: any) {
-		if (err.code === "ENOENT") {
-			// El directorio ya no existe, no es un error para nosotros en este contexto
-			console.warn(`The directory "${dirPath}" does not exist or has already been processed.`);
-		} else {
-			console.error(`General error general while processing "${dirPath}":`, err);
-			throw err;
-		}
+	if (fs.existsSync(filePath)) {
+		currentContent = fs.readFileSync(filePath, "utf8");
 	}
-}
 
-async function pathExists(dir: string) {
-	try {
-		await fsp.access(dir);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Busca recursivamente archivos que terminen con un sufijo específico dentro de un directorio.
- * Esta función es un generador asíncrono, lo que la hace muy eficiente en uso de memoria.
- *
- * @param dir El directorio base para comenzar la búsqueda.
- * @param suffix El sufijo con el que deben terminar los nombres de archivo (ej: 'page-data.json').
- * @returns Un generador asíncrono que produce la ruta completa de cada archivo encontrado.
- * @throws Si el directorio inicial `dir` no existe o no se puede leer.
- */
-async function* findFilesBySuffix(dir: string, suffix: string): AsyncGenerator<string> {
-	const dirHandle = await fsp.opendir(dir);
-	for await (const item of dirHandle) {
-		const fullPath = path.join(dir, item.name);
-		if (item.isDirectory()) {
-			// yield* para encadenar otro generator.
-			yield* findFilesBySuffix(fullPath, suffix);
-		} else if (item.isFile() && item.name.endsWith(suffix)) {
-			yield fullPath;
-		}
-	}
+	fs.writeFileSync(filePath, content + currentContent, "utf8");
 }
 
 export {
-	copyDirs,
-	createDirs,
+	copyArtifacts,
+	createArtifacts,
 	deleteDisposableSiteDirs,
-	deleteEmptyDirectories,
-	findFilesBySuffix,
-	moveDirs,
-	pathExists,
-	removeDirs,
-	removeVirtualPages,
-	renamePath,
+	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/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/utils/instance.ts

@@ -1,9 +1,10 @@
 import path from "node:path";
 
-import { NoJSConfigFileFound } from "../constants/errors";
-import { throwError } from "./errors";
-import { findUpSync } from "./npm-deps/find-up-simple";
-import { pkgDirSync } from "./npm-deps/pkg-dir";
+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,
 			};