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

package/exporter/core/fs.ts

@@ -1,385 +0,0 @@
-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/core/life-cycle.ts

@@ -1,73 +0,0 @@
-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 };

package/exporter/core/logger.ts

@@ -1,141 +0,0 @@
-import type { RenderDB } from "../shared/types/render";
-
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import {
-	GRIDDO_BUILD_LOGS,
-	GRIDDO_BUILD_LOGS_BUFFER_SIZE,
-	// GRIDDO_BUILD_LOGS_TO_FILE,
-} from "../shared/envs";
-import { readDB } from "./db";
-import { GriddoLog } from "./GriddoLog";
-
-const logBuffer: string[] = [];
-let logFilePath: string | null = null;
-let flushPromise: Promise<void> | null = null;
-const LOG_BUFFER_FLUSH_THRESHOLD = GRIDDO_BUILD_LOGS_BUFFER_SIZE;
-const LOG_FILENAME = "render-detail-log.txt";
-const LOG_TO_FILE_IS_DISABLED = !GRIDDO_BUILD_LOGS; // || !GRIDDO_BUILD_LOGS_TO_FILE;
-
-let dbData: RenderDB | null = null;
-
-// Universal data cache for this module...
-async function getDBData() {
-	if (!dbData) {
-		dbData = await readDB();
-	}
-	return dbData;
-}
-
-async function initializeLogFile() {
-	if (LOG_TO_FILE_IS_DISABLED) {
-		return;
-	}
-
-	const data = await getDBData();
-	logFilePath = path.join(data.paths.root, LOG_FILENAME);
-
-	await fsp.rm(logFilePath, { force: true });
-}
-
-function addLogToBuffer(lineContent: string) {
-	if (LOG_TO_FILE_IS_DISABLED) {
-		return;
-	}
-
-	logBuffer.push(lineContent.toString());
-
-	if (logBuffer.length >= LOG_BUFFER_FLUSH_THRESHOLD) {
-		// Fire-and-forget flush to avoid blocking the main thread.
-		flushLogsToFile().catch((error) => {
-			GriddoLog.error("Background log flush failed:", error);
-		});
-	}
-}
-
-/**
- * Vuelca el contenido del buffer de logs al archivo de logs en disco.
- * Si el buffer está vacío, ya se está volcando, o no hay ruta de archivo, no hace nada.
- * Si ocurre un error al escribir, los logs se reinsertan al buffer para reintentar en el siguiente flush.
- */
-async function flushLogsToFile() {
-	// Si ya hay un volcado en curso, espera a que termine.
-	if (flushPromise) {
-		await flushPromise;
-	}
-
-	if (logBuffer.length === 0 || !logFilePath) {
-		return;
-	}
-
-	const performFlush = async () => {
-		const logsToFlush = [...logBuffer];
-		logBuffer.length = 0;
-
-		try {
-			await fsp.appendFile(logFilePath!, `${logsToFlush.join("\n")}\n`);
-		} catch (error) {
-			logBuffer.unshift(...logsToFlush);
-			GriddoLog.error("Error flushing logs:", error);
-			// No relanzamos el error para no detener el "fire-and-forget"
-		}
-	};
-
-	flushPromise = performFlush();
-
-	try {
-		await flushPromise;
-	} finally {
-		flushPromise = null;
-	}
-}
-
-/**
- * Copia el archivo de log detallado de renderizado ("render-detail-log.txt")
- * desde el directorio raíz del proyecto al directorio de logs del dominio en exports,
- * usando una marca de tiempo en el nombre de destino.
- * Si el archivo no existe, ignora el error salvo que sea distinto de ENOENT.
- *
- * @param domain - Nombre del dominio para el que se guarda el log.
- */
-async function saveDetailRenderLog(domain: string) {
-	await flushLogsToFile();
-
-	const data = await getDBData();
-
-	const dateString = getFormattedDateTime();
-	const debugDir = path.join(data.paths.exportsDir, domain, "logs");
-
-	await fsp.mkdir(debugDir, { recursive: true });
-
-	const src = path.join(data.paths.root, LOG_FILENAME);
-	const dst = path.join(debugDir, `${dateString}-${LOG_FILENAME}`);
-
-	// Move log to exports
-	try {
-		await fsp.cp(src, dst);
-	} catch (error) {
-		// It's possible the file doesn't exist if GRIDDO_BUILD_LOGS is false
-		// or if no logs were ever added.
-		if (error instanceof Error && "code" in error && error.code !== "ENOENT") {
-			throw error;
-		}
-	}
-}
-
-function getFormattedDateTime() {
-	const now = new Date();
-	const year = now.getFullYear();
-	const month = String(now.getMonth() + 1).padStart(2, "0");
-	const day = String(now.getDate()).padStart(2, "0");
-
-	const hours = String(now.getHours()).padStart(2, "0");
-	const minutes = String(now.getMinutes()).padStart(2, "0");
-	const seconds = String(now.getSeconds()).padStart(2, "0");
-
-	// Formato recomendado para ordenación de archivos: YYYY-MM-DD_HH-mm-ss
-	return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}`;
-}
-
-export { addLogToBuffer, flushLogsToFile, initializeLogFile, saveDetailRenderLog };

package/exporter/core/objects.ts

@@ -1,37 +0,0 @@
-/**
- * Busca de forma recursiva si ALGUNA de las claves de un array existe como propiedad propia
- * en un objeto anidado. La búsqueda se detiene en cuanto se encuentra la primera coincidencia.
- *
- * @param obj El objeto a inspeccionar.
- * @param keysToFind Un array de claves que se buscan.
- * @param visited Un WeakSet para evitar ciclos de referencia.
- * @returns Retorna `true` si al menos una de las claves se encuentra, de lo contrario `false`.
- */
-function hasAnyKeyDeep<T extends object>(
-	obj: T,
-	keysToFind: string[],
-	visited = new WeakSet<object>(),
-): boolean {
-	// 1. Casos base: no procesar no-objetos, si ya lo visitamos, o si el array de claves está vacío.
-	if (typeof obj !== "object" || obj === null || visited.has(obj)) {
-		return false;
-	}
-	if (keysToFind.length === 0) {
-		return false;
-	}
-	visited.add(obj);
-
-	// 2. Comprobar si ALGUNA de las claves buscadas es una propiedad propia del objeto actual.
-	// Usamos .some() porque se detiene en la primera coincidencia (eficiencia).
-	const foundKey = keysToFind.some((key) => Object.hasOwn(obj, key));
-	if (foundKey) {
-		return true;
-	}
-
-	// 3. Si no se encontró ninguna clave en este nivel, recorrer los valores y buscar recursivamente.
-	return Object.values(obj).some(
-		(value) => typeof value === "object" && hasAnyKeyDeep(value, keysToFind, visited),
-	);
-}
-
-export { hasAnyKeyDeep };

package/exporter/core/print-logos.ts

@@ -1,21 +0,0 @@
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { brush } from "../shared/npm-modules/brush";
-import { GriddoLog } from "./GriddoLog";
-
-/**
- * Console log the Griddo exporter version.
- */
-async function showExporterVersion() {
-	// console.clear();
-	const { version } = JSON.parse(
-		await fsp.readFile(path.resolve(__dirname, "../..", "package.json"), "utf-8"),
-	) as { version: string };
-	const logo = `\n${brush.yellow(`Griddo Exporter ${version}`)}
-${brush.dim(`Node ${process.version.slice(1)}`)}\n`;
-
-	GriddoLog.log(logo);
-}
-
-export { showExporterVersion };

package/exporter/react/DynamicScript/index.tsx

@@ -1,33 +0,0 @@
-import { useEffect } from "react";
-
-const DynamicScript = (props: { scriptContent: string }) => {
-	const { scriptContent } = props;
-
-	useEffect(() => {
-		if (!scriptContent) {
-			return;
-		}
-
-		const scriptText = scriptContent.replace(/<script>|<\/script>/g, "");
-		if (!scriptText.trim()) {
-			return;
-		}
-
-		const script = document.createElement("script");
-		script.innerHTML = scriptText;
-		script.async = true;
-
-		document.body.appendChild(script);
-
-		return () => {
-			// Hacemos un chequeo por si el script ya fue removido por otro proceso.
-			if (document.body.contains(script)) {
-				document.body.removeChild(script);
-			}
-		};
-	}, [scriptContent]);
-
-	return null;
-};
-
-export { DynamicScript };