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

package/exporter/commands/prepare-domains-render.ts

@@ -8,7 +8,6 @@ import path from "node:path";
 import { version as griddoVersion } from "../../package.json";
 import { AuthService } from "../services/auth";
 import { readDB, writeDB } from "../services/db";
-import { doLifeCycle } from "../utils/core-utils";
 import { getInstanceDomains } from "../utils/domains";
 import { pathExists, pkgDir, removeDirs } from "../utils/folders";
 import { resolveComponentsPath } from "../utils/instance";
@@ -71,11 +70,11 @@ function getDomainsSortedByNumberOfPages(
 	return domainsInfo.map(({ domain }) => domain);
 }
 
-async function initRenderAction() {
+async function initRender() {
 	const root = (await pkgDir({ cwd: path.resolve(__dirname, "../../..") })) || "";
 	const cx = root;
 	const ssg = path.resolve((await pkgDir({ cwd: __dirname })) || "");
-	const cxCache = path.resolve(cx, ".cx-cache");
+	const cxCache = path.resolve(root, ".cx-cache");
 	const components = resolveComponentsPath();
 	const exportsDir = path.join(root, "exports/sites");
 
@@ -90,7 +89,7 @@ async function initRenderAction() {
 			cx,
 			cxCache,
 			exportsDir,
-			root: root,
+			root,
 			ssg,
 		},
 	};
@@ -103,24 +102,22 @@ async function initRenderAction() {
 	await writeDB(data);
 }
 
-async function prepareDomainsAction() {
+async function prepareDomains() {
 	await AuthService.login();
 
-	// read paths from db
-	const __ssg = (await readDB()).paths.ssg;
+	const db = await readDB();
 
+	const __ssg = db.paths.ssg;
 	const domains = await getInstanceDomains();
 	const domainsWithNumberOfPages = await getDomainsWithNumberOfPages(domains);
 	const domainSorted = getDomainsSortedByNumberOfPages(domainsWithNumberOfPages);
 
 	// @deprecated use db.json (only for infra)
 	await fsp.writeFile(path.join(__ssg, "domains.json"), JSON.stringify(domainSorted));
+	await fsp.writeFile(path.join(__ssg, "domains.txt"), domainSorted.join(","));
 
-	// new behavior
-	const db = await readDB();
 	db.sortedDomains = domainSorted;
 	db.domains = {};
-	await writeDB(db);
 
 	for (const { domain, totalPages } of domainsWithNumberOfPages) {
 		const shouldBeRendered = totalPages > 0;
@@ -129,20 +126,19 @@ async function prepareDomainsAction() {
 			shouldBeRendered,
 		});
 
-		// Update DB
-		const db = await readDB();
 		db.domains[domain] = db.domains[domain] || {};
 		db.domains[domain].renderMode = renderMode;
 		db.domains[domain].shouldBeRendered = shouldBeRendered;
 		db.domains[domain].renderModeReason = reason;
-		await writeDB(db);
 	}
+
+	await writeDB(db);
 }
 
-async function cleanAction() {
+async function clean() {
 	const db = await readDB();
-	const { cx: __cx } = db.paths;
-	await removeDirs([path.join(__cx, "apiCache")]);
+	const { root: __root } = db.paths;
+	await removeDirs([path.join(__root, "apiCache")]);
 }
 
 /**
@@ -152,10 +148,9 @@ async function cleanAction() {
  */
 async function main() {
 	await showExporterVersion();
-
-	await doLifeCycle("InitRender", initRenderAction);
-	await doLifeCycle("PrepareDomains", prepareDomainsAction);
-	await doLifeCycle("Clean", cleanAction);
+	await initRender();
+	await prepareDomains();
+	await clean();
 }
 
 main().catch((err) => {

package/exporter/commands/reset-render.ts

@@ -3,10 +3,8 @@
 import { RESET_RENDER } from "../constants/endpoints";
 import { AuthService } from "../services/auth";
 import { post } from "../utils/api";
-import { doLifeCycle } from "../utils/core-utils";
 
-async function resetRenderAction() {
-	await AuthService.login();
+async function resetRender() {
 	await post({
 		endpoint: RESET_RENDER,
 		useApiCacheDir: false,
@@ -14,7 +12,9 @@ async function resetRenderAction() {
 }
 
 async function main() {
-	await doLifeCycle("ResetRender", resetRenderAction);
+	await AuthService.login();
+	await resetRender();
+	console.log(`The render status has been reset.`);
 }
 
 main().catch((err) => {

package/exporter/commands/start-render.ts

@@ -2,35 +2,43 @@
 
 import { gatsbyRenderDomain } from "../adapters/gatsby";
 import { AuthService } from "../services/auth";
+import { brush } from "../utils/brush";
 import { checkHealth } from "../utils/check-health";
-import { doLifeCycle } from "../utils/core-utils";
+import { getInstanceDomains } from "../utils/domains";
 import { RenderError } from "../utils/errors";
-import { errorLabelLog } from "../utils/loggin";
 
-async function startRenderAction() {
-	checkHealth();
-
-	await AuthService.login();
+const renderByDomains = !!process.env.GRIDDO_RENDER_BY_DOMAINS;
 
+async function startRender() {
 	try {
-		const [domain] = process.argv.slice(2);
-		await gatsbyRenderDomain(domain);
+		if (renderByDomains) {
+			const [domain] = process.argv.slice(2);
+			await gatsbyRenderDomain(domain);
+		} else {
+			console.log("- LEGACY RENDER MODE -");
+			const domains = await getInstanceDomains();
+			for (const domain of domains) {
+				await gatsbyRenderDomain(domain);
+			}
+		}
 
 		return;
 	} catch (error) {
 		if (error instanceof RenderError) {
-			errorLabelLog("GRIDDO_ERROR InternalCXError");
+			console.log(brush.red("GRIDDO_ERROR InternalCXError"));
 			process.exit(1);
 		}
 
-		errorLabelLog("GRIDDO_ERROR UnknownError");
+		console.log(brush.red("GRIDDO_ERROR UnknownError"));
 		console.error(error);
 		process.exit(1);
 	}
 }
 
 async function main() {
-	await doLifeCycle("StartRender", startRenderAction);
+	checkHealth();
+	await AuthService.login();
+	await startRender();
 }
 
 main().catch((err) => {

package/exporter/commands/upload-search-content.ts

@@ -11,12 +11,11 @@ import { AI_EMBEDDINGS, SEARCH } from "../constants/endpoints";
 import { GRIDDO_AI_EMBEDDINGS, GRIDDO_SEARCH_FEATURE } from "../constants/envs";
 import { ReadFromStoreError, UploadSearchError } from "../constants/errors";
 import { AuthService } from "../services/auth";
-import { readDB } from "../services/db";
 import { post } from "../utils/api";
-import { doLifeCycle } from "../utils/core-utils";
+import { getInstanceDomains } from "../utils/domains";
 import { throwError } from "../utils/errors";
 import { pathExists } from "../utils/folders";
-import { getRenderMode, getRenderPathsFromDB } from "../utils/render";
+import { getRenderPathsFromDB } from "../utils/render";
 
 /**
  * Save in the BBDD the content of a page parsed without HTML tags.
@@ -180,11 +179,10 @@ async function getContentDirectories(domain: string) {
 }
 
 async function uploadSearchContent() {
-	const db = await readDB();
-	const domains = db.sortedDomains;
-	for (const domain of domains) {
-		const { renderMode } = await getRenderMode(domain);
-		if (renderMode !== "IDLE" && GRIDDO_SEARCH_FEATURE) {
+	if (GRIDDO_SEARCH_FEATURE) {
+		await AuthService.login();
+		const domains = await getInstanceDomains();
+		for (const domain of domains) {
 			const { htmlContentDir, jsonContentDir } = await getContentDirectories(domain);
 			await uploadRenderedSearchContentToAPI({
 				htmlContentDir,
@@ -194,18 +192,9 @@ async function uploadSearchContent() {
 	}
 }
 
-// async function uploadSearchContentByDomain(domain: string) {
-// 	const renderMode = await getRenderMode(domain);
-// 	if (renderMode !== "IDLE" && GRIDDO_SEARCH_FEATURE) {
-// 		const { htmlContentDir, jsonContentDir } = await getContentDirectories(domain);
-// 		await uploadRenderedSearchContentToAPI({ htmlContentDir, jsonContentDir });
-// 	}
-// }
-
-async function aiEmbeddingsAction() {
+async function aiEmbeddings() {
 	if (GRIDDO_SEARCH_FEATURE && GRIDDO_AI_EMBEDDINGS) {
 		await AuthService.login();
-
 		await post<AIEmbeddingsResponse>({
 			endpoint: AI_EMBEDDINGS,
 			useApiCacheDir: false,
@@ -214,8 +203,8 @@ async function aiEmbeddingsAction() {
 }
 
 async function main() {
-	await doLifeCycle("UploadSearch", () => uploadSearchContent());
-	await doLifeCycle("AIEmbeddings", aiEmbeddingsAction);
+	await uploadSearchContent();
+	await aiEmbeddings();
 }
 
 main().catch((err) => {

package/exporter/constants/envs.ts

@@ -64,10 +64,6 @@ const GRIDDO_ARCHIVE_LIFECYCLE_MAX_ATTEMPTS = Number.parseInt(
 	process.env.GRIDDO_ARCHIVE_LIFECYCLE_MAX_ATTEMPTS || "1",
 );
 
-// Testing
-const GRIDDO_FIXTURES_DOMAIN_NAMES = process.env.GRIDDO_CX_FIXTURES_DOMAIN_NAMES;
-const GRIDDO_FIXTURES_SITE_NAMES = process.env.GRIDDO_CX_FIXTURES_SITE_NAMES;
-
 export {
 	GRIDDO_AI_EMBEDDINGS,
 	GRIDDO_API_CONCURRENCY_COUNT,
@@ -81,8 +77,6 @@ export {
 	GRIDDO_CLOSE_LIFECYCLE_MAX_ATTEMPTS,
 	GRIDDO_DATA_LIFECYCLE_MAX_ATTEMPTS,
 	GRIDDO_DEBUG_LOGS,
-	GRIDDO_FIXTURES_DOMAIN_NAMES,
-	GRIDDO_FIXTURES_SITE_NAMES,
 	GRIDDO_INIT_LIFECYCLE_MAX_ATTEMPTS,
 	GRIDDO_META_LIFECYCLE_MAX_ATTEMPTS,
 	GRIDDO_PREPARE_LIFECYCLE_MAX_ATTEMPTS,

package/exporter/constants/errors.ts

@@ -11,8 +11,9 @@ import type { SpawnSyncReturns } from "node:child_process";
 import type { ErrorData } from "../utils/errors";
 
 type ErrorsType =
-	| "UploadSearchError"
 	| "ArtifactError"
+	| "BundlesInconsistencyError"
+	| "CheckHealthError"
 	| "ErrorInSSGBuildProcess"
 	| "LifecycleExecutionError"
 	| "LoginError"
@@ -21,8 +22,8 @@ type ErrorsType =
 	| "ReadFromStoreError"
 	| "ReferenceFieldSourcesNotFoundError"
 	| "RenderUUIDError"
-	| "WriteToStoreError"
-	| "CheckHealthError";
+	| "UploadSearchError"
+	| "WriteToStoreError";
 
 const ArtifactError: ErrorData = {
 	error: "ArtifactError",
@@ -105,8 +106,16 @@ const CheckHealthError: ErrorData = {
 	hint: "Are the environment variables correctly set?",
 };
 
+const BundlesInconsistencyError: ErrorData = {
+	error: "BundlesInconsistencyError",
+	message: "There was a problem with the Javascript and CSS bundles diffs.",
+	expected: "The bundles must have the same files and content.",
+};
+
 export {
 	ArtifactError,
+	BundlesInconsistencyError,
+	CheckHealthError,
 	ErrorInSSGBuildProcess,
 	LifecycleExecutionError,
 	LoginError,
@@ -117,6 +126,5 @@ export {
 	RenderUUIDError,
 	UploadSearchError,
 	WriteToStoreError,
-	CheckHealthError,
 	type ErrorsType,
 };

package/exporter/services/db-class.ts

@@ -0,0 +1,54 @@
+import type { RenderDB } from "../types/render";
+
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { pkgDirSync } from "../utils/folders";
+
+// Interfaz para abstraer la DB
+export interface Database {
+	read(): Promise<RenderDB>;
+	write(renderDB: RenderDB): Promise<void>;
+}
+
+export class JsonDatabase implements Database {
+	private readonly dbFilePath: string;
+
+	constructor(customDBPath?: string) {
+		this.dbFilePath =
+			customDBPath ??
+			path.join(
+				pkgDirSync({ cwd: path.resolve(__dirname, "../../..") }) ?? "",
+				".cx-cache",
+				"db.json",
+			);
+	}
+
+	async read(customDBFilePath?: string): Promise<RenderDB> {
+		try {
+			const raw = await fsp.readFile(customDBFilePath || this.dbFilePath, "utf-8");
+			return JSON.parse(raw) as RenderDB;
+		} catch (error) {
+			if (error instanceof Error) {
+				console.error(`Error reading DB file at ${this.dbFilePath}:`, error.message);
+			} else {
+				console.error(`Unknown error reading DB file at ${this.dbFilePath}:`, error);
+			}
+			throw error;
+		}
+	}
+
+	async write(renderDB: RenderDB): Promise<void> {
+		try {
+			await fsp.mkdir(path.dirname(this.dbFilePath), { recursive: true });
+			await fsp.writeFile(this.dbFilePath, JSON.stringify(renderDB, null, 2));
+		} catch (error) {
+			if (error instanceof Error) {
+				console.error(`Error writing to DB file at ${this.dbFilePath}:`, error.message);
+			} else {
+				console.error(`Unknown error writing to DB file at ${this.dbFilePath}:`, error);
+			}
+			throw error;
+		}
+	}
+}

package/exporter/services/robots.ts

@@ -37,8 +37,8 @@ class RobotsService {
 	 * Write robots.txt files for the domain.
 	 */
 	async writeFiles(domain: string) {
-		const { __cx } = await getRenderPathsFromDB({ domain });
-		const distDirectory = path.join(__cx, "dist");
+		const { __root } = await getRenderPathsFromDB({ domain });
+		const distDirectory = path.join(__root, "dist");
 
 		await this.getRobots();
 

package/exporter/services/store.ts

@@ -8,7 +8,7 @@ import type {
 } from "../types/pages";
 import type { RenderMode } from "../types/render";
 
-import fs from "node:fs";
+import fsp from "node:fs/promises";
 import path from "node:path";
 
 import pLimit from "p-limit";
@@ -188,7 +188,7 @@ async function createStore(options: {
 			infoLog(`Getting pages from ${site.name} site`);
 
 			/// Creates the store directory for each site using the id
-			fs.mkdirSync(path.join(storeDir, siteDirName), {
+			await fsp.mkdir(path.join(storeDir, siteDirName), {
 				recursive: true,
 			});
 

package/exporter/types/global.ts

@@ -94,7 +94,6 @@ type PlaceholderPath =
 	| "__components"
 	| "__root"
 	| "__exports_dist"
-	| "__cx_dist"
 	| "__sites";
 
 interface CXConfig {

package/exporter/utils/artifacts.ts

@@ -8,22 +8,22 @@ import { getRenderPathsFromDB } from "./render";
  * Returns the artifacts of CX.
  */
 async function getCxArtifacts(domain: string): Promise<Artifacts> {
-	const { __cx, __exports, __cache } = await getRenderPathsFromDB({ domain });
+	const { __exports, __cache, __root } = await getRenderPathsFromDB({ domain });
 
 	return {
 		initials: [
-			__exports, // `/exports/<domain>`
-			__cache, // `__cx/.cx-cache/<domain>`
-			path.join(__cx, "store"),
-			path.join(__cx, "apiCache"),
+			__exports, // `<root>/exports/<domain>`
+			__cache, // `<root>/.cx-cache/<domain>`
+			path.join(__root, "store"),
+			path.join(__root, "apiCache"),
 		],
 		disposables: [
-			path.join(__cx, "store"),
-			path.join(__cx, "apiCache"),
-			path.join(__cx, "dist"),
-			path.join(__cx, "dist-restored"),
-			path.join(__cx, "debug"),
-			path.join(__cx, "assets"),
+			path.join(__root, "store"),
+			path.join(__root, "apiCache"),
+			path.join(__root, "dist"),
+			path.join(__root, "dist-restored"),
+			path.join(__root, "debug"),
+			path.join(__root, "assets"),
 		],
 		cacheables: [],
 		archivables: ["dist", "debug", "assets"],

package/exporter/utils/cache.ts

@@ -27,8 +27,8 @@ async function createAPICacheDir(options: { basePath: string }) {
  * @param petition An object
  */
 async function generateFilenameWithHash(petition: Petition) {
-	const { __cx } = await getRenderPathsFromDB();
-	const apiCacheDir = path.join(__cx, "apiCache");
+	const { __root } = await getRenderPathsFromDB();
+	const apiCacheDir = path.join(__root, "apiCache");
 
 	const hashSum = crypto.createHash("sha256");
 	hashSum.update(JSON.stringify(petition));
@@ -76,8 +76,8 @@ async function searchCacheData<T>(petition: Petition) {
  * Get site hashes from the file as an object
  */
 async function getHashSites(): Promise<HashSites> {
-	const { __cx } = await getRenderPathsFromDB();
-	const apiCacheDir = path.join(__cx, "apiCache");
+	const { __root } = await getRenderPathsFromDB();
+	const apiCacheDir = path.join(__root, "apiCache");
 	const siteHasFilename = `${apiCacheDir}/siteHash.json`;
 
 	try {
@@ -100,8 +100,8 @@ async function updatedSiteHash(siteId: number, siteHash: SiteHash) {
 	const lastHash = allHash[siteId];
 	const currentHash = siteHash || lastHash || Date.now();
 
-	const { __cx } = await getRenderPathsFromDB();
-	const apiCacheDir = path.join(__cx, "apiCache");
+	const { __root } = await getRenderPathsFromDB();
+	const apiCacheDir = path.join(__root, "apiCache");
 	const siteHasFilename = `${apiCacheDir}/siteHash.json`;
 
 	if (currentHash !== lastHash) {

package/exporter/utils/core-utils.ts

@@ -154,9 +154,14 @@ async function executeAndReturnExecutionTime<T>(func: () => T | Promise<T>) {
 async function doLifeCycle(
 	name: string,
 	action: LifeCycleAction,
-	options?: { maxRetrys?: number; spinner?: boolean },
+	options?: { maxRetrys?: number; spinner?: boolean; skip?: undefined | false | string },
 ) {
-	const { maxRetrys = 3 } = options || {};
+	const { maxRetrys = 3, skip } = options || {};
+
+	if (skip) {
+		console.log(`Skiping life-cycle. Reason: ${skip}`);
+		return;
+	}
 
 	let trysCount = 0;
 
@@ -195,8 +200,8 @@ async function doLifeCycle(
 }
 
 async function removeAllSiteDirsFromStore() {
-	const { __cx } = await getRenderPathsFromDB();
-	const storeDir = path.join(__cx, "store");
+	const { __root } = await getRenderPathsFromDB();
+	const storeDir = path.join(__root, "store");
 	const allDirs = await fsp.readdir(storeDir);
 
 	const allSiteDirs = allDirs.filter((dirname) => dirname !== "metadata");
@@ -282,6 +287,42 @@ const lifeCycleNames: Record<LifeCyclesNames, LifeCyclesNames> = {
 	SSG: "SSG",
 } as const;
 
+/**
+ * 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 {
 	delay,
 	doLifeCycle,
@@ -294,4 +335,5 @@ export {
 	removeProperties,
 	saveBuildEndLogs,
 	walkStore,
+	hasAnyKeyDeep,
 };

package/exporter/utils/folders.ts

@@ -118,7 +118,7 @@ async function copyDirs(
 		} catch (error) {
 			if (withBackup) {
 				await restoreBackup(dstCompose);
-				console.log("Backup has been restored.");
+				verboseLog("Backup has been restored.");
 			}
 
 			throwError(ArtifactError, error);
@@ -213,7 +213,7 @@ async function deleteBackup(src: string, suffix = "-BACKUP") {
 
 	try {
 		await fsp.rm(dst, { recursive: true, force: true });
-		console.log(`Backup ${dst} has been deleted`);
+		verboseLog(`Backup ${dst} has been deleted`);
 	} catch (error) {
 		console.log(error);
 		throw new Error(`Error while delete ${dst} backup`);
@@ -234,7 +234,7 @@ async function createBackup(src: string, suffix = "-BACKUP") {
 
 	try {
 		await fsp.rename(src, dst);
-		console.log(`Backup of ${src} has been created in ${dst}`);
+		verboseLog(`Backup of ${src} has been created in ${dst}`);
 	} catch (error) {
 		console.log(`Error while coping ${src} to ${dst} backup`);
 		throwError(ArtifactError, error);
@@ -310,7 +310,7 @@ async function deleteEmptyDirectories(dirPath: string) {
 		} catch (err: any) {
 			// Si el directorio no existe o no se puede leer (ej. permisos), lo saltamos.
 			if (err.code === "ENOENT") {
-				console.warn(`El directorio "${dirPath}" no existe. Se omite.`);
+				console.warn(`The directory "${dirPath}" does not exist, skipping it.`);
 				return;
 			}
 			console.error(`Error al leer el directorio "${dirPath}":`, err);
@@ -329,7 +329,7 @@ async function deleteEmptyDirectories(dirPath: string) {
 		if (remainingFiles.length === 0) {
 			try {
 				await fsp.rmdir(dirPath);
-				console.log(`Remove empty directory: ${dirPath}`);
+				verboseLog(`Remove empty directory: ${dirPath}`);
 			} catch (err: any) {
 				// Puede que haya habido un problema de concurrencia o permisos
 				if (err.code === "ENOENT") {
@@ -344,9 +344,9 @@ async function deleteEmptyDirectories(dirPath: string) {
 	} catch (err: any) {
 		if (err.code === "ENOENT") {
 			// El directorio ya no existe, no es un error para nosotros en este contexto
-			console.warn(`El directorio "${dirPath}" no existe o ya ha sido procesado.`);
+			console.warn(`The directory "${dirPath}" does not exist or has already been processed.`);
 		} else {
-			console.error(`Error general al procesar "${dirPath}":`, err);
+			console.error(`General error general while processing "${dirPath}":`, err);
 			throw err;
 		}
 	}
@@ -373,11 +373,34 @@ function pkgDirSync(options?: { readonly cwd?: string }) {
 	return filePath && path.dirname(filePath);
 }
 
+/**
+ * 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 {
 	copyDirs,
 	createDirs,
 	deleteDisposableSiteDirs,
 	deleteEmptyDirectories,
+	findFilesBySuffix,
 	moveDirs,
 	pathExists,
 	pkgDir,

package/exporter/utils/loggin.ts

@@ -103,16 +103,22 @@ function listSitesLog(title: string, sites: Array<Site>) {
 ${title} ${sitesOutput}`);
 }
 
-function errorLabelLog(msg: string) {
-	console.error(`\n${brush.black(` ${msg} `)}\n`);
+/**
+ * Console log with a blue color in the info prefix.
+ * @param str The string to be logged.
+ */
+function localLog(str: string) {
+	if (process.env.GRIDDO_IS_LOCAL_ENV) {
+		console.log(str);
+	}
 }
 
 export {
 	boxLog,
 	buildLog,
-	errorLabelLog,
 	infoLog,
 	listSitesLog,
+	localLog,
 	showExporterVersion,
 	successLog,
 	verboseLog,