@griddo/cx 11.9.17 → 11.10.0

package/exporter/core/errors.ts

@@ -0,0 +1,93 @@
+import type { ErrorsType } from "../shared/errors";
+
+import path from "node:path";
+
+import { brush } from "../shared/npm-modules/brush";
+import { RENDER_MODE } from "../shared/types/render";
+import { readDB, writeDB } from "./db";
+import { distRollback } from "./dist-rollback";
+import { GriddoLog } from "./GriddoLog";
+
+export type ErrorData = {
+	error: ErrorsType;
+	message: string;
+	expected?: string;
+	hint?: string;
+};
+
+export class RenderError extends Error {
+	constructor(originalError?: unknown) {
+		super(originalError instanceof Error ? originalError.message : String(originalError));
+
+		this.name = "InternalCXError";
+		this.stack = originalError instanceof Error ? originalError.stack : "";
+	}
+}
+
+/**
+ * Throws an error with the provided error message, expected value, and hint.
+ */
+function throwError(options: ErrorData, stack?: unknown): never {
+	const { error, message, expected, hint } = options;
+
+	const errorColor = GriddoLog.log(brush.red(`[ ${error} ]`));
+	const extraText = [expected, hint].filter(Boolean).join("\n");
+
+	GriddoLog.log(`
+${errorColor}
+${message}
+${extraText}
+
+${brush.red("stack")}
+${JSON.stringify(stack, null, 2)}`);
+
+	throw new RenderError(stack);
+}
+
+/**
+ * Executes the provided asynchronous function and handles errors that occur during execution.
+ *
+ * - If an error is thrown, attempts to log the error and, if necessary, rolls back the exports directory.
+ * - Updates the render database to set the domain's rendering state to "ERROR" if an error occurs.
+ *
+ * @param fn - The asynchronous function to execute within the error handler.
+ * @returns A promise that resolves when the function is executed successfully.
+ * @throws RenderError | unknown - Rethrows the original error after handling and database state update.
+ */
+async function withErrorHandler(fn: () => Promise<void>) {
+	try {
+		await fn();
+	} catch (error) {
+		if (error instanceof RenderError) {
+			GriddoLog.error("Internal Griddo RenderError");
+		} else if (error instanceof Error) {
+			GriddoLog.error(error.message);
+		} else {
+			GriddoLog.error(`An unexpected error occurred ${error}`);
+		}
+
+		// Try to rollback the exports directory if needed
+		try {
+			const data = await readDB();
+			const { root } = data.paths;
+			if (data.needsRollbackOnError) {
+				GriddoLog.info("Cleaning exports dir...");
+				GriddoLog.verbose(`Deleting ${path.join(root, "exports")}...`);
+
+				await distRollback(data.currentRenderingDomain!);
+			} else {
+				GriddoLog.info("No rollback needed, skipping...");
+			}
+		} catch (_e) {
+			GriddoLog.info("Early render stage, no db.json created yet...");
+		}
+
+		const data = await readDB();
+		data.domains[data.currentRenderingDomain!].isRendering = false;
+		data.domains[data.currentRenderingDomain!].renderMode = RENDER_MODE.ERROR;
+		await writeDB(data);
+		throw error;
+	}
+}
+
+export { throwError, withErrorHandler };

package/exporter/core/fs.ts

@@ -0,0 +1,385 @@
+import type { MakeDirectoryOptions } from "node:fs";
+
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { ArtifactError } from "../shared/errors";
+import { throwError } from "./errors";
+import { GriddoLog } from "./GriddoLog";
+
+/**
+ * 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.
+ */
+async function deleteDisposableSiteDirs(baseDir: string) {
+	if (!(await pathExists(baseDir))) {
+		return;
+	}
+
+	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 (await siteIsEmpty(sitePath)) {
+			await fsp.rm(sitePath, { recursive: true });
+		}
+	}
+}
+
+/**
+ * Creates multiple artifact directories.
+ *
+ * @param dirs - An array of directory paths.
+ * @param options - Same option as `fs.mkdirSync()`
+ */
+async function mkDirs(dirs: string[], options?: MakeDirectoryOptions) {
+	for (const dir of dirs) {
+		try {
+			if (!(await pathExists(dir))) {
+				await fsp.mkdir(dir, { recursive: true, ...options });
+				GriddoLog.verbose(`create directory: ${dir}`);
+			}
+		} catch (error) {
+			throwError(ArtifactError, error);
+		}
+	}
+}
+
+async function renamePath(src: string, dst: string) {
+	try {
+		if (await pathExists(src)) {
+			await fsp.rename(src, dst);
+			GriddoLog.verbose(`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.
+ */
+async function cpDirs(
+	src: string,
+	dst: string,
+	dirs: 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 (!(await pathExists(srcCompose))) {
+			GriddoLog.info(`(Maybe first render) Source directory does not exist: ${srcCompose}`);
+			continue;
+		}
+
+		// Create the backup
+		if (withBackup) {
+			await createBackup(dstCompose);
+			GriddoLog.verbose(`create backup: ${dstCompose}`);
+		}
+
+		// Copy directory
+		try {
+			// First clean destination
+			if (await pathExists(dstCompose)) {
+				await fsp.rm(dstCompose, { recursive: true, force: true });
+				GriddoLog.verbose(`clean destination: ${dstCompose}`);
+			}
+
+			// Then copy src to dst
+			await fsp.cp(srcCompose, dstCompose, {
+				recursive: true,
+				preserveTimestamps: true,
+			});
+			GriddoLog.verbose(`copy: ${srcCompose} to ${dstCompose}`);
+
+			if (withBackup) {
+				await deleteBackup(dstCompose);
+				GriddoLog.verbose(`delete backup: ${dstCompose}`);
+			}
+		} catch (error) {
+			if (withBackup) {
+				await restoreBackup(dstCompose);
+				GriddoLog.verbose("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.
+ */
+async function mvDirs(
+	src: string,
+	dst: string,
+	dirs: 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 (!(await pathExists(srcCompose))) {
+			continue;
+		}
+
+		if (withBackup) {
+			await createBackup(dstCompose);
+		}
+
+		try {
+			// Clean destination
+			if (override && (await pathExists(dstCompose))) {
+				await fsp.rm(dstCompose, { recursive: true, force: true });
+			}
+
+			await fsp.rename(srcCompose, dstCompose);
+			GriddoLog.verbose(`moved: ${srcCompose} to ${dstCompose}`);
+
+			if (withBackup) {
+				await deleteBackup(dstCompose);
+			}
+		} catch (error) {
+			if (withBackup) {
+				await restoreBackup(dstCompose);
+				GriddoLog.info("Backup has been restored.");
+			}
+
+			throwError(ArtifactError, error);
+		}
+	}
+}
+
+/**
+ * Removes multiple artifact directories.
+ *
+ * @param dirs - An array of directory paths.
+ */
+async function rmDirs(dirs: string[]) {
+	for (const dir of dirs) {
+		try {
+			await fsp.rm(dir, { recursive: true, force: true });
+			GriddoLog.verbose(`artifact removed: ${dir}`);
+		} catch (error) {
+			throwError(ArtifactError, error);
+		}
+	}
+}
+
+async function restoreBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+	try {
+		await fsp.rename(dst, src);
+		GriddoLog.info(`Backup ${dst} has been restored`);
+	} catch (_error) {
+		throw new Error(`Error while delete ${dst} backup`);
+	}
+}
+
+async function deleteBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+
+	if (!(await pathExists(dst))) {
+		return;
+	}
+
+	try {
+		await fsp.rm(dst, { recursive: true, force: true });
+		GriddoLog.verbose(`Backup ${dst} has been deleted`);
+	} catch (_error) {
+		throw new Error(`Error while delete ${dst} backup`);
+	}
+}
+
+async function createBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+
+	if (!(await pathExists(src))) {
+		return;
+	}
+
+	if (await pathExists(dst)) {
+		GriddoLog.warn(`Destination ${dst} already exists`);
+		return;
+	}
+
+	try {
+		await fsp.rename(src, dst);
+		GriddoLog.verbose(`Backup of ${src} has been created in ${dst}`);
+	} catch (error) {
+		GriddoLog.error(`Error while coping ${src} to ${dst} backup`);
+		throwError(ArtifactError, error);
+	}
+}
+
+/**
+ * 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, {
+			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;
+	}
+}
+
+/**
+ * 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;
+		}
+
+		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") {
+				GriddoLog.warn(`The directory "${dirPath}" does not exist, skipping it.`);
+				return;
+			}
+			GriddoLog.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);
+				GriddoLog.verbose(`Remove empty directory: ${dirPath}`);
+			} catch (err: any) {
+				// Puede que haya habido un problema de concurrencia o permisos
+				if (err.code === "ENOENT") {
+					GriddoLog.warn(
+						`El directorio "${dirPath}" ya no existe. Posiblemente fue borrado por otra operación.`,
+					);
+				} else {
+					GriddoLog.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
+			GriddoLog.warn(`The directory "${dirPath}" does not exist or has already been processed.`);
+		} else {
+			GriddoLog.error(`General error general while processing "${dirPath}":`, err);
+			throw err;
+		}
+	}
+}
+
+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;
+		}
+	}
+}
+
+/**
+ * Walk a directory and returns the JSON file absolute paths with one level of depth.
+ * /abs/.../sotre/331/158.json
+ * /abs/.../sotre/114/443.json
+ * /abs/.../sotre/131/217.json
+ * /abs/.../sotre/191/281.json
+ */
+async function* walkStore(storeDir: string): AsyncGenerator<string> {
+	const storeDirHandle = await fsp.opendir(storeDir);
+
+	for await (const siteDirent of storeDirHandle) {
+		if (siteDirent.isDirectory()) {
+			const siteDirPath = path.join(storeDir, siteDirent.name);
+			const siteDirHandle = await fsp.opendir(siteDirPath);
+
+			for await (const fileDirent of siteDirHandle) {
+				const filePath = path.join(siteDirPath, fileDirent.name);
+
+				if (fileDirent.isFile() && path.extname(filePath) === ".json") {
+					yield filePath;
+				}
+			}
+		}
+	}
+}
+
+export {
+	cpDirs,
+	deleteDisposableSiteDirs,
+	deleteEmptyDirectories,
+	findFilesBySuffix,
+	mkDirs,
+	mvDirs,
+	pathExists,
+	renamePath,
+	rmDirs,
+	walkStore,
+};

package/exporter/{utils → core}/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 → core}/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 "../shared/errors";
+import { findUpSync } from "../shared/npm-modules/find-up-simple";
+import { pkgDirSync } from "../shared/npm-modules/pkg-dir";
+import { throwError } from "./errors";
 
 // 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,
 			};

package/exporter/core/life-cycle.ts

@@ -0,0 +1,73 @@
+import type { LifeCycleAction } from "../shared/types/global";
+
+import { LifecycleExecutionError } from "../shared/errors";
+import { brush } from "../shared/npm-modules/brush";
+import { throwError } from "./errors";
+import { GriddoLog } from "./GriddoLog";
+
+/**
+ * Measures the execution time of a series of sync or async functions.
+ *
+ * @async
+ * @param functions - Functions to be executed to measure their execution time.
+ * @returns A promise that resolves with the total execution time in seconds.
+ */
+async function executeAndReturnExecutionTime<T>(func: () => T | Promise<T>): Promise<number> {
+	const start = process.hrtime.bigint();
+	await Promise.resolve(func());
+	const end = process.hrtime.bigint();
+	return Number((Number(end - start) / 1e9).toFixed(3));
+}
+
+/**
+ * Executes a life cycle process, which involves executing a callback
+ * function, printing to the console, and handling errors with optional retries.
+ *
+ * @async
+ * @param name - The name of the life cycle.
+ * @param action - A callback function to execute.
+ * @param options - Optional configuration for the life cycle process.
+ * @param options.maxRetrys - The maximum number of retries for the life cycle.
+ * @param options.enabled - Whether the life cycle process should be executed.
+ * @returns - A promise that resolves when the life cycle process is completed.
+ */
+async function doLifeCycle(
+	name: string,
+	action: LifeCycleAction,
+	options?: {
+		maxRetrys?: number;
+		skip?: undefined | false | string;
+	},
+) {
+	const { maxRetrys = 3, skip } = options || {};
+
+	if (skip) {
+		GriddoLog.info(`Skiping life-cycle ${name}. Reason: ${skip}\n`);
+		return;
+	}
+
+	let trysCount = 0;
+
+	while (trysCount < maxRetrys) {
+		try {
+			GriddoLog.info(`start ${name} life-cycle`);
+			const exeTime = await executeAndReturnExecutionTime(action);
+			GriddoLog.success(`${name} - ${exeTime}s\n`);
+			break;
+		} catch (error) {
+			const errorString = brush.red(` Error in ${name} LifeCycle `);
+			const attemptsString = brush.yellow(`Attempt (${trysCount + 1})`);
+			GriddoLog.log(`\n${errorString} ${attemptsString}\n`);
+			GriddoLog.log(error);
+			GriddoLog.log();
+
+			trysCount++;
+		}
+	}
+
+	if (trysCount === maxRetrys) {
+		throwError(LifecycleExecutionError(maxRetrys, name));
+	}
+}
+
+export { doLifeCycle, executeAndReturnExecutionTime };