@griddo/cx 11.7.10 → 11.7.12-rc.0

package/exporter/utils/folders.ts

@@ -1,14 +1,12 @@
-import fs from "node:fs";
-import path from "node:path";
+import type { MakeDirectoryOptions } from "node:fs";
 
-import fsx, { type MakeDirectoryOptions } from "fs-extra";
+import fsp from "node:fs/promises";
+import path from "node:path";
 
-import { throwError } from "../errors";
-import { getConfig, walkStore } from "./core-utils";
+import { ArtifactError } from "../constants/errors";
+import { walkStore } from "./core-utils";
+import { throwError } from "./errors";
 import { verboseLog } from "./loggin";
-import { ArtifactError } from "../errors/errors-data";
-
-const config = getConfig();
 
 /**
  * Remove an empty directory from the basePath recursively.
@@ -16,37 +14,34 @@ const config = getConfig();
  *
  * @param baseDir - The base directory.
  */
-function deleteDisposableSiteDirs() {
-	const { __cx } = config.paths();
-	const baseDir = path.join(__cx, "dist");
-
-	if (!fs.existsSync(baseDir)) {
+async function deleteDisposableSiteDirs(baseDir: string) {
+	if (!(await pathExists(baseDir))) {
 		return;
 	}
 
-	const sitesDirs = fs
-		.readdirSync(baseDir, { withFileTypes: true })
-		.filter((file) => file.isDirectory());
+	const sitesDirs = (await fsp.readdir(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 });
+		if (await siteIsEmpty(sitePath)) {
+			await fsp.rm(sitePath, { recursive: true });
 		}
 	}
 }
 
 /**
- * Creates multiple directories.
+ * Creates multiple artifact directories.
  *
  * @param dirs - An array of directory paths.
  * @param options - Same option as `fs.mkdirSync()`
  */
-function createArtifacts(dirs: Array<string>, options?: MakeDirectoryOptions) {
+async function createDirs(dirs: Array<string>, options?: MakeDirectoryOptions) {
 	for (const dir of dirs) {
 		try {
-			if (!fs.existsSync(dir)) {
-				fs.mkdirSync(dir, { recursive: true, ...options });
+			if (!(await pathExists(dir))) {
+				await fsp.mkdir(dir, { recursive: true, ...options });
 				verboseLog(`create directory: ${dir}`);
 			}
 		} catch (error) {
@@ -55,10 +50,10 @@ function createArtifacts(dirs: Array<string>, options?: MakeDirectoryOptions) {
 	}
 }
 
-function renameArtifact(src: string, dst: string) {
+async function renamePath(src: string, dst: string) {
 	try {
-		if (fs.existsSync(src)) {
-			fs.renameSync(src, dst);
+		if (await pathExists(src)) {
+			await fsp.rename(src, dst);
 			verboseLog(`rename ${src} to ${dst}`);
 		}
 	} catch (error) {
@@ -74,7 +69,7 @@ function renameArtifact(src: string, dst: string) {
  * @param dirs - Directories to copy.
  * @param options.withBackup - Create a previous backup before copy.
  */
-function copyArtifacts(
+async function copyDirs(
 	src: string,
 	dst: string,
 	dirs: Array<string>,
@@ -88,42 +83,40 @@ function copyArtifacts(
 		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}`,
-			);
+		if (!(await pathExists(srcCompose))) {
+			console.log(`(Maybe first render) Source directory does not exist: ${srcCompose}`);
 			continue;
 		}
 
 		// Create the backup
 		if (withBackup) {
-			createBackup(dstCompose);
+			await createBackup(dstCompose);
 			verboseLog(`create backup: ${dstCompose}`);
 		}
 
 		// Copy directory
 		try {
 			// First clean destination
-			if (fsx.existsSync(dstCompose)) {
-				fs.rmSync(dstCompose, { recursive: true, force: true });
+			if (await pathExists(dstCompose)) {
+				await fsp.rm(dstCompose, { recursive: true, force: true });
 				verboseLog(`clean destination: ${dstCompose}`);
 			}
 
 			// Then copy src to dst
-			fs.cpSync(srcCompose, dstCompose, {
+			await fsp.cp(srcCompose, dstCompose, {
 				recursive: true,
 				preserveTimestamps: true,
 			});
 			verboseLog(`copy: ${srcCompose} to ${dstCompose}`);
 
 			if (withBackup) {
-				deleteBackup(dstCompose);
+				await deleteBackup(dstCompose);
 				verboseLog(`delete backup: ${dstCompose}`);
 			}
 		} catch (error) {
 			if (withBackup) {
-				restoreBackup(dstCompose);
-				console.log("Backup has been restored.");
+				await restoreBackup(dstCompose);
+				verboseLog("Backup has been restored.");
 			}
 
 			throwError(ArtifactError, error);
@@ -139,7 +132,7 @@ function copyArtifacts(
  * @param dirs - Directories to move.
  * @param options - Options.
  */
-function moveArtifacts(
+async function moveDirs(
 	src: string,
 	dst: string,
 	dirs: Array<string>,
@@ -151,29 +144,29 @@ function moveArtifacts(
 		const srcCompose = path.join(src, dir);
 		const dstCompose = path.join(dst, dir);
 
-		if (!fsx.existsSync(srcCompose)) {
+		if (!(await pathExists(srcCompose))) {
 			continue;
 		}
 
 		if (withBackup) {
-			createBackup(dstCompose);
+			await createBackup(dstCompose);
 		}
 
 		try {
 			// Clean destination
-			if (override && fsx.existsSync(dstCompose)) {
-				fs.rmSync(dstCompose, { recursive: true, force: true });
+			if (override && (await pathExists(dstCompose))) {
+				await fsp.rm(dstCompose, { recursive: true, force: true });
 			}
 
-			fs.renameSync(srcCompose, dstCompose);
+			await fsp.rename(srcCompose, dstCompose);
 			verboseLog(`moved: ${srcCompose} to ${dstCompose}`);
 
 			if (withBackup) {
-				deleteBackup(dstCompose);
+				await deleteBackup(dstCompose);
 			}
 		} catch (error) {
 			if (withBackup) {
-				restoreBackup(dstCompose);
+				await restoreBackup(dstCompose);
 				console.log("Backup has been restored.");
 			}
 
@@ -185,30 +178,23 @@ function moveArtifacts(
 /**
  * Removes multiple artifact directories.
  *
- * @param artifacts - An array of artifact directory paths.
+ * @param dirs - An array of directory paths.
  */
-function removeArtifacts(artifacts: Array<string>) {
-	for (const dir of artifacts) {
-		if (!dir) {
-			continue;
-		}
-
+async function removeDirs(dirs: Array<string>) {
+	for (const dir of dirs) {
 		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}`);
-			}
+			await fsp.rm(dir, { recursive: true, force: true });
+			verboseLog(`artifact removed: ${dir}`);
 		} catch (error) {
 			throwError(ArtifactError, error);
 		}
 	}
 }
 
-function restoreBackup(src: string, suffix = "-BACKUP") {
+async function restoreBackup(src: string, suffix = "-BACKUP") {
 	const dst = src + suffix;
 	try {
-		fs.renameSync(dst, src);
+		await fsp.rename(dst, src);
 		console.log(`Backup ${dst} has been restored`);
 	} catch (error) {
 		console.log(error);
@@ -216,37 +202,37 @@ function restoreBackup(src: string, suffix = "-BACKUP") {
 	}
 }
 
-function deleteBackup(src: string, suffix = "-BACKUP") {
+async function deleteBackup(src: string, suffix = "-BACKUP") {
 	const dst = src + suffix;
 
-	if (!fsx.existsSync(dst)) {
+	if (!(await pathExists(dst))) {
 		return;
 	}
 
 	try {
-		fs.rmSync(dst, { recursive: true, force: true });
-		console.log(`Backup ${dst} has been deleted`);
+		await fsp.rm(dst, { recursive: true, force: true });
+		verboseLog(`Backup ${dst} has been deleted`);
 	} catch (error) {
 		console.log(error);
 		throw new Error(`Error while delete ${dst} backup`);
 	}
 }
 
-function createBackup(src: string, suffix = "-BACKUP") {
+async function createBackup(src: string, suffix = "-BACKUP") {
 	const dst = src + suffix;
 
-	if (!fsx.existsSync(src)) {
+	if (!(await pathExists(src))) {
 		return;
 	}
 
-	if (fsx.existsSync(dst)) {
+	if (await pathExists(dst)) {
 		console.log(`Destination ${dst} already exists`);
 		return;
 	}
 
 	try {
-		fs.renameSync(src, dst);
-		console.log(`Backup of ${src} has been created in ${dst}`);
+		await fsp.rename(src, dst);
+		verboseLog(`Backup of ${src} has been created in ${dst}`);
 	} catch (error) {
 		console.log(`Error while coping ${src} to ${dst} backup`);
 		throwError(ArtifactError, error);
@@ -254,25 +240,23 @@ 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 removeVirtualPagesFromStore() {
-	const { __cx } = config.paths();
-	const storePath = path.join(__cx, "store");
-
+async function removeVirtualPages(dirPath: string) {
 	try {
-		const allJsonPageFilesPath = walkStore(storePath);
-
-		for (const filePath of allJsonPageFilesPath) {
+		// Procesamos archivos uno por uno para evitar cargar todos en memoria
+		for await (const filePath of walkStore(dirPath)) {
 			if (path.basename(filePath).startsWith("-")) {
-				fs.unlinkSync(filePath);
+				await fsp.unlink(filePath);
 			}
 		}
 	} catch (error) {
 		console.info(
-			"`store` folder does not exist. Skipping multipage or static list template cleaning.",
+			`${dirPath} folder does not exist. Skipping multipage or static list template cleaning.`,
 			error,
 		);
 	}
@@ -281,15 +265,13 @@ async function removeVirtualPagesFromStore() {
 /**
  * Return true if the site folder is empty or only has xml files. (Recursively)
  */
-function siteIsEmpty(sitePath: string) {
-	const siteFiles = fs
-		.readdirSync(sitePath, {
+async function siteIsEmpty(sitePath: string) {
+	const siteFiles = (
+		await fsp.readdir(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"));
 
@@ -298,23 +280,106 @@ function siteIsEmpty(sitePath: string) {
 	}
 }
 
-function prependFileSync(filePath: string, content: string) {
-	let currentContent = "";
+/**
+ * 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;
+		}
 
-	if (fs.existsSync(filePath)) {
-		currentContent = fs.readFileSync(filePath, "utf8");
+		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;
+		}
 	}
+}
 
-	fs.writeFileSync(filePath, content + currentContent, "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;
+		}
+	}
 }
 
 export {
-	copyArtifacts,
-	createArtifacts,
+	copyDirs,
+	createDirs,
 	deleteDisposableSiteDirs,
-	moveArtifacts,
-	prependFileSync,
-	removeArtifacts,
-	removeVirtualPagesFromStore,
-	renameArtifact,
+	deleteEmptyDirectories,
+	findFilesBySuffix,
+	moveDirs,
+	pathExists,
+	removeDirs,
+	removeVirtualPages,
+	renamePath,
 };

package/exporter/utils/images.ts

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