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

package/exporter/adapters/gatsby/shared/sync-render.ts

@@ -1,27 +1,50 @@
-import fs from "node:fs";
+import fsp from "node:fs/promises";
 import path from "node:path";
 
+import { BundlesInconsistencyError } from "../../../constants/errors";
+import { throwError } from "../../../utils/errors";
+import { findFilesBySuffix } from "../../../utils/folders";
 import { verboseLog } from "../../../utils/loggin";
+import { getAssetsDiffBetweenRenders, patchHtmlFile } from "./diff-assets";
 
-type SyncRenderConfig = {
+interface SyncRenderConfig {
 	src: string;
 	dst: string;
 	pagesToCreate: Array<number>;
 	pagesToDelete: Array<number>;
 	artifactsToCopyToExports: Array<string>;
-};
-
-type CopyFilePath = {
+}
+interface CopyFilePath {
 	from: string;
 	to: string;
-};
-
-type SyncState = {
+}
+interface SyncState {
 	htmlToAdd: Array<CopyFilePath>;
 	jsonToAdd: Array<CopyFilePath>;
 	htmlToDelete: Array<string>;
 	jsonToDelete: Array<string>;
-};
+}
+interface PageInfo {
+	id: number;
+	composePath: string; // p.ej. '/about-us' o '/'
+	htmlPath: string; // p.ej. '/path/to/public/about-us/index.html'
+	jsonPath: string; // p.ej. '/path/to/public/page-data/about-us/page-data.json'
+}
+interface GatsbyPageData {
+	result: {
+		pageContext: {
+			id: number;
+			fullPath: {
+				site: string;
+				domain: string;
+				domainUrl: string;
+				language: string;
+				page: string;
+				compose: string;
+			};
+		};
+	};
+}
 
 class SyncRender {
 	private bundleDir: string;
@@ -45,43 +68,42 @@ class SyncRender {
 		this.assetArtifacts = config.artifactsToCopyToExports;
 	}
 
-	// Se basa en los paths encontrados en page-data.json y no en recorrer físicamente el file-system
-	setPagesToDelete() {
-		// El set de ids están tanto las páginas que se van a crear como borrar.
-		// El por qué poner las que se van a crear es porque necesitamos quitar esas páginas con esos ids por si las que se van a crear tienen otro slug.
-		// Por ejemplo si se va crear la página id3 con slug /page-with-new-slug
-		// pero existía antes con el slug /page se borrará /page del sistema de
-		// ficheros y después se creará /page-with-new-slug ya que solo puede
-		// existir una página con el mismo id salvo que sea Multi-Page o
-		// Listado-Estático.
-		const idSet = new Set<number>([...this.pagesToDelete, ...this.pagesToCreate]);
-		const composePaths = this.getPageComposePaths(this.bundleDir);
-
-		for (const compose of composePaths) {
-			const normalizedCompose = compose === "/" ? "index" : compose;
-			const json = JSON.parse(
-				fs.readFileSync(
-					path.join(this.bundleDir, "page-data", normalizedCompose, "page-data.json"),
-					"utf8",
-				),
-			);
-			const id = json.result.pageContext.id;
-			const pagePath = json.result.pageContext.fullPath.compose as string;
-			// si el id de la página está en los ids para borrar (idSet) se añade
-			if (idSet.has(id)) {
-				try {
-					this.state.htmlToDelete.push(path.join(this.bundleDir, pagePath, "index.html"));
-					this.state.jsonToDelete.push(
-						path.join(
-							this.bundleDir,
-							"page-data",
-							pagePath === "/" ? "index" : pagePath,
-							"page-data.json",
-						),
-					);
-				} catch (e) {
-					console.log(e);
-				}
+	public async execute() {
+		await this.setPagesToDelete();
+		await this.setPagesToAdd();
+		await this.sync();
+		await this.assertAssetsAreValid();
+	}
+
+	private async assertAssetsAreValid() {
+		const isDifferent = await getAssetsDiffBetweenRenders(this.currentRenderDir, this.bundleDir);
+		console.log("Comparando assets...");
+		console.log("-", this.currentRenderDir);
+		console.log("-", this.bundleDir);
+		if (isDifferent) {
+			throwError(BundlesInconsistencyError);
+		}
+	}
+
+	private async setPagesToDelete() {
+		// ¿Por qué se incluyen this.pagesToCreate en las candidatas para borrarse?
+		// El set de ids incluye tanto las páginas a borrar como las que se van
+		// a crear para manejar correctamente por ejemplo los cambios de slug.
+		// Si la página `id=3` tiene slug `slug=about` y despues viene con
+		// `slug=about-us` borramos la página `id=3` en el render previo y la
+		// volvemos a crear.
+		// Resumido lo que pasará es que las páginas que se van a crear se
+		// borran previamente por si ha cambiado el slug. Porque el slug hace
+		// que se guarden en otro directorio.
+		// ¿Qué pasaría si no la borrásemos? que tendríamos las dos páginas
+		// `/about/index.html` y `/about-us/index.html`
+		const candidateIdsToDelete = new Set<number>([...this.pagesToDelete, ...this.pagesToCreate]);
+		const existingPreviousPages = await this.scanPages(this.bundleDir);
+
+		for (const page of existingPreviousPages) {
+			if (candidateIdsToDelete.has(page.id)) {
+				this.state.htmlToDelete.push(page.htmlPath);
+				this.state.jsonToDelete.push(page.jsonPath);
 			}
 		}
 
@@ -89,205 +111,166 @@ class SyncRender {
 		verboseLog(`${this.state.jsonToDelete.length} pages JSON to delete`);
 	}
 
-	// Se basa en los paths encontrados en page-data.json y no en recorrer físicamente el file-system
-	// Cuando añadimos una página con id 3 (p.e.), hay que buscar todas las
-	// páginas con ese id en el bundle y borrar sus html/json. Esto va a pasar
-	// por ejemplo si cambiamos el slug de la página 3. Eso hará que se guarde
-	// en distintas carpetas pero no es una página que venga en "pagesToDelete"
-	setPagesToAdd() {
-		const idSet = new Set<number>(this.pagesToCreate);
-		const composePaths = this.getPageComposePaths(this.currentRenderDir);
-
-		for (const compose of composePaths) {
-			// 1 - leemos el page-data.json de la página para añadir
-			// Gatsby crea un directorio `index` para la página raíz `/`
-			const normalizedCompose = compose === "/" ? "index" : compose;
-			const json = JSON.parse(
-				fs.readFileSync(
-					path.join(this.currentRenderDir, "page-data", normalizedCompose, "page-data.json"),
-					"utf8",
-				),
-			);
-			// 2 - sacamos el id
-			const id = json.result.pageContext.id;
-
-			// 3 - obtenemos el src y dst del HTML
-			const htmlFrom = path.join(this.currentRenderDir, compose, "index.html");
-			const htmlTo = path.join(this.bundleDir, compose, "index.html");
-			// 4 - obtenemos el src/dst del JSON
-			const jsonFrom = path.join(
-				this.currentRenderDir,
-				"page-data",
-				normalizedCompose,
-				"page-data.json",
-			);
-			const jsonTo = path.join(this.bundleDir, "page-data", normalizedCompose, "page-data.json");
-
-			// Solo actuamos en la página si su id está en pagesToCreate
-			if (idSet.has(id)) {
-				try {
-					this.state.htmlToAdd.push({ from: htmlFrom, to: htmlTo });
-					this.state.jsonToAdd.push({ from: jsonFrom, to: jsonTo });
-				} catch (e) {
-					console.log(e);
-				}
-			}
+	private async setPagesToAdd() {
+		const candidateIdsToCreate = new Set<number>(this.pagesToCreate);
+		const newPages = await this.scanPages(this.currentRenderDir);
+
+		for (const page of newPages) {
+			if (candidateIdsToCreate.has(page.id)) {
+				const htmlTo = path.join(this.bundleDir, page.composePath, "index.html");
+				const normalizedCompose = page.composePath === "/" ? "index" : page.composePath;
+				const jsonTo = path.join(this.bundleDir, "page-data", normalizedCompose, "page-data.json");
 
-			verboseLog(`${this.state.htmlToAdd.length} pages HTML to create`);
-			verboseLog(`${this.state.jsonToAdd.length} pages JSON to create`);
+				this.state.htmlToAdd.push({ from: page.htmlPath, to: htmlTo });
+				this.state.jsonToAdd.push({ from: page.jsonPath, to: jsonTo });
+			}
 		}
+
+		verboseLog(`${this.state.htmlToAdd.length} pages HTML to create`);
+		verboseLog(`${this.state.jsonToAdd.length} pages JSON to create`);
 	}
 
-	/**
-	 * Realiza la sincronización de los archivos HTML y JSON entre el directorio
-	 * actual de renderizado y el directorio de exportación.
-	 */
-	sync() {
-		// remove html's
-		for (const html of this.state.htmlToDelete) {
+	private async sync() {
+		// Delete...
+		const allFilesToDelete = [...this.state.htmlToDelete, ...this.state.jsonToDelete];
+		for (const file of allFilesToDelete) {
 			try {
-				fs.rmSync(html);
-				verboseLog(`Sync (remove) : ${html}`);
+				// Usar `force: true` para no fallar si el archivo ya no existe.
+				await fsp.rm(file, { force: true });
+				verboseLog(`Sync (remove) : ${file}`);
 			} catch (e) {
-				console.log(`Does not exist ${html}`, e);
+				// El error solo se registraría si es un problema de permisos, etc.
+				console.error(`Failed to remove ${file}:`, e);
 			}
 		}
 
-		// remove json's
-		for (const json of this.state.jsonToDelete) {
+		await this.restoreWebpackCompilationHash();
+
+		// Copy...
+		const allFilesToAdd = [...this.state.htmlToAdd, ...this.state.jsonToAdd];
+		for (const file of allFilesToAdd) {
 			try {
-				fs.rmSync(json);
-				verboseLog(`Sync (remove) : ${json}`);
+				await fsp.mkdir(path.dirname(file.to), { recursive: true });
+				await fsp.copyFile(file.from, file.to);
+				verboseLog(`Sync (copy) : ${file.from} -> ${file.to}`);
 			} catch (e) {
-				console.log(`Does not exist ${json}`, e);
+				console.error(`Failed to copy ${file.from} to ${file.to}:`, e);
 			}
 		}
 
-		// copy html's
-		for (const html of this.state.htmlToAdd) {
-			fs.mkdirSync(path.dirname(html.to), { recursive: true });
-			fs.copyFileSync(html.from, html.to);
-			verboseLog(`Sync (copy) : ${html.from} -> ${html.to}`);
-		}
-
-		// copy json's
-		for (const json of this.state.jsonToAdd) {
-			fs.mkdirSync(path.dirname(json.to), { recursive: true });
-			fs.copyFileSync(json.from, json.to);
-			verboseLog(`Sync (copy) : ${json.from} -> ${json.to}`);
-		}
-
-		// update app-data.json (update the webpackCompilationHash)
-		this.copyAppDataJsonFile();
-
-		// copy artifacts
-		this.copyDirs();
-
-		// copy sitemaps
-		this.copySitemaps();
+		// AVOID TO RESTORE webpackCompilationHash
+		// await this.copyAppDataJsonFile();
+		await this.copyAssetArtifacts();
+		await this.copySitemaps();
 	}
 
-	/**
-	 * Busca archivos por extensión de forma recursiva en un directorio.
-	 * @param dir Directorio base.
-	 * @param extension Extensión a buscar (ej: ".ts", ".js").
-	 * @returns Lista de rutas absolutas de archivos encontrados.
-	 */
-	private findFilesByExtension(dir: string, extension: string): Array<string> {
-		let results: Array<string> = [];
-
-		if (!fs.existsSync(dir)) {
-			return [];
-		}
-
-		const list = fs.readdirSync(dir, { withFileTypes: true });
+	private async restoreWebpackCompilationHash() {
+		const appDataJson = path.join(this.bundleDir, "page-data", "app-data.json");
+		const webpackCompilationHash = JSON.parse(
+			await fsp.readFile(appDataJson, "utf8"),
+		).webpackCompilationHash;
+		console.log(
+			"Leyendo el webpackCompilationHash desde",
+			appDataJson,
+			"=",
+			webpackCompilationHash,
+		);
 
-		for (const item of list) {
-			const fullPath = path.join(dir, item.name);
+		const changedHtmlFilePaths = this.state.htmlToAdd.map(({ from }) => from);
 
-			if (item.isDirectory()) {
-				results = results.concat(this.findFilesByExtension(fullPath, extension));
-			} else if (item.isFile() && fullPath.endsWith(extension)) {
-				results.push(fullPath);
-			}
+		for (const htmlFilePath of changedHtmlFilePaths) {
+			await patchHtmlFile(htmlFilePath, webpackCompilationHash);
 		}
-
-		return results;
 	}
 
-	private findAllPageDataJsons(dir: string) {
-		return this.findFilesByExtension(dir, ".json").filter((n) => n.endsWith("page-data.json"));
-	}
-
-	private getPageComposePaths(src: string) {
-		// [page-data/foo/bar/page-data.json, ...]
-		const allPageDataJson = this.findAllPageDataJsons(src);
-
-		// Array de fullPaths
-		// Entre ellos un fullPath puede ser: "/" (El root de la instancia)
-
-		// No sé si hacer esto en este momento...
-		// fullPath: "/foo/bar" => "foo/bar"
-		// fullPath: "/" => "index"
-		return allPageDataJson.map(
-			(p) => JSON.parse(fs.readFileSync(p, "utf-8")).result.pageContext.fullPath.compose,
-		);
-	}
-
-	private copyAppDataJsonFile() {
-		fs.copyFileSync(
-			path.join(this.currentRenderDir, "page-data", "app-data.json"),
-			path.join(this.bundleDir, "page-data", "app-data.json"),
-		);
-		verboseLog("Copied app-data.json");
-	}
-
-	private copyDirs() {
+	// private async copyAppDataJsonFile() {
+	// 	try {
+	// 		const src = path.join(this.currentRenderDir, "page-data", "app-data.json");
+	// 		const dst = path.join(this.bundleDir, "page-data", "app-data.json");
+	// 		await fsp.copyFile(src, dst);
+	// 		verboseLog("Copied app-data.json");
+	// 	} catch (e) {
+	// 		console.error("Failed to copy app-data.json:", e);
+	// 	}
+	// }
+
+	private async copyAssetArtifacts() {
 		for (const assetArtifact of this.assetArtifacts) {
-			fs.copyFileSync(
-				path.join(this.currentRenderDir, assetArtifact),
-				path.join(this.bundleDir, assetArtifact),
-			);
-			verboseLog(
-				`Copied ${path.join(this.currentRenderDir, assetArtifact)} -> to -> ${path.join(
-					this.bundleDir,
-					assetArtifact,
-				)}`,
-			);
+			const src = path.join(this.currentRenderDir, assetArtifact);
+			const dst = path.join(this.bundleDir, assetArtifact);
+			try {
+				await fsp.mkdir(path.dirname(dst), { recursive: true });
+				await fsp.copyFile(src, dst);
+				verboseLog(`Copied artifact: ${assetArtifact}`);
+			} catch (e) {
+				console.error(`Failed to copy artifact ${src} to ${dst}:`, e);
+			}
 		}
 	}
 
-	private copySitemaps() {
-		/*
-		1. buscar directorios que tengan como hijo un `sitemap.xml`
-		2. copiar todos los sitemap.xml y sitemap-* a /exports/sites/<domain>/<site>/ borrando previamente los .xmls que existan
-		*/
+	private async copySitemaps() {
 		const renderSrc = path.resolve(this.currentRenderDir);
 		const renderDst = path.resolve(this.bundleDir);
-		const xmlFilesInSrc = this.findFilesByExtension(renderSrc, ".xml");
-		const xmlFilesInDst = this.findFilesByExtension(renderDst, ".xml");
-
-		// Eliminar los sitemaps de griddo que existan en el destino, se van a
-		// crear todos nuevos en la fase Meta.
-		for (const xmlFile of xmlFilesInDst) {
-			if (
-				path.basename(xmlFile).startsWith("sitemap-") ||
-				path.basename(xmlFile) === "sitemap.xml"
-			) {
-				fs.rmSync(xmlFile, { force: true });
+
+		// Primero, elimina los sitemaps existentes en el destino
+		const xmlFilesInDst = findFilesBySuffix(renderDst, ".xml");
+		for await (const xmlFile of xmlFilesInDst) {
+			const basename = path.basename(xmlFile);
+			if (basename.startsWith("sitemap-") || basename === "sitemap.xml") {
+				await fsp.rm(xmlFile, { force: true });
 			}
 		}
 
-		for (const xmlFile of xmlFilesInSrc) {
-			const src = xmlFile;
-			// cambia la ruta, de src -> dst
-			const dst = xmlFile.replace(renderSrc, renderDst);
+		// Segundo, copia los nuevos sitemaps desde el origen
+		const xmlFilesInSrc = findFilesBySuffix(renderSrc, ".xml");
+		for await (const src of xmlFilesInSrc) {
+			// Reconstruye la ruta de destino de forma más robusta
+			const relativePath = path.relative(renderSrc, src);
+			const dst = path.join(renderDst, relativePath);
+
+			try {
+				await fsp.mkdir(path.dirname(dst), { recursive: true });
+				await fsp.copyFile(src, dst);
+			} catch (e) {
+				console.error(`Failed to copy sitemap ${src} to ${dst}:`, e);
+			}
+		}
 
-			if (!fs.existsSync(path.dirname(dst))) {
-				fs.mkdirSync(path.dirname(dst), { recursive: true });
+		verboseLog(`Copied sitemap files.`);
+	}
+
+	/**
+	 * Escanea un directorio de build de Gatsby y extrae la información esencial de cada página.
+	 * Lee cada page-data.json una sola vez para optimizar el rendimiento.
+	 * @param dir Directorio a escanear (src o dst).
+	 * @returns Un array con la información de cada página encontrada.
+	 */
+	private async scanPages(dir: string): Promise<Array<PageInfo>> {
+		// Array de paths de page-data.json
+		const gatsbyPageDataFiles = findFilesBySuffix(path.join(dir, "page-data"), "page-data.json");
+		const pagesFound: Array<PageInfo> = [];
+
+		for await (const jsonFile of gatsbyPageDataFiles) {
+			try {
+				const content = JSON.parse(await fsp.readFile(jsonFile, "utf-8")) as GatsbyPageData;
+				const id = content.result.pageContext.id;
+				const composePath = content.result.pageContext.fullPath.compose;
+				// Esto es necesario porque Gatsby convierte la ruta "/" en un
+				// directorio llamado "index" en lo que archivos page-data.json
+				// se refiere.
+				const normalizedCompose = composePath === "/" ? "index" : composePath;
+
+				pagesFound.push({
+					id,
+					composePath,
+					htmlPath: path.join(dir, composePath, "index.html"),
+					jsonPath: path.join(dir, "page-data", normalizedCompose, "page-data.json"),
+				});
+			} catch (e) {
+				console.error(`Error reading or parsing page data from ${jsonFile}:`, e);
 			}
-			fs.copyFileSync(src, dst);
 		}
+		return pagesFound;
 	}
 }
 

package/exporter/build.sh

@@ -1,6 +1,5 @@
 #!/usr/bin/env bash
 
 echo "📦 Compiling CX..."
-rm -rf ./build
-tsc --project tsconfig.commands.json
-tsc --emitDeclarationOnly --declaration --outDir build --project tsconfig.exporter.json
+tsgo --project tsconfig.commands.json
+# tsgo --emitDeclarationOnly --declaration --outDir build --project tsconfig.exporter.json

package/exporter/commands/end-render.ts

@@ -8,12 +8,14 @@ import path from "node:path";
 import { ArtifactError } from "../constants/errors";
 import { AuthService } from "../services/auth";
 import { endSiteRender } from "../services/sites";
-import { doLifeCycle } from "../utils/core-utils";
+import { getInstanceDomains } from "../utils/domains";
 import { throwError } from "../utils/errors";
 import { pathExists } from "../utils/folders";
 import { infoLog } from "../utils/loggin";
 import { getRenderMetadataFromDB, getRenderMode, getRenderPathsFromDB } from "../utils/render";
 
+const renderByDomains = !!process.env.GRIDDO_RENDER_BY_DOMAINS;
+
 async function getRenderReport(options: {
 	domain: string;
 	exportsSiteDir: string;
@@ -40,38 +42,65 @@ const sendEndSiteRender = async (report: Report) => {
 	}
 };
 
-async function endRenderAction() {
+async function endRender() {
 	const { buildReportFileName } = await getRenderMetadataFromDB();
 	const { __sites } = await getRenderPathsFromDB();
 
-	const [domain] = process.argv.slice(2);
-	const { renderMode } = await getRenderMode(domain);
-
-	if (renderMode === "IDLE") {
-		infoLog(`Skipping build-end for domain ${domain} as it is marked as IDLE.`);
-		return;
-	}
-
 	await AuthService.login();
-
-	const report = await getRenderReport({
-		domain,
-		exportsSiteDir: __sites,
-		buildReportFileName,
-	});
-
-	infoLog(`Sending ending call to ${domain} sites`);
-
-	for (const site of report.sites) {
-		site.publishHashes = [...new Set(site.publishHashes)];
-		site.unpublishHashes = [...new Set(site.unpublishHashes)];
+	if (renderByDomains) {
+		const [domain] = process.argv.slice(2);
+		const { renderMode } = await getRenderMode(domain);
+
+		if (renderMode === "IDLE") {
+			infoLog(`Skipping build-end for domain ${domain} as it is marked as IDLE.`);
+			return;
+		}
+
+		const report = await getRenderReport({
+			domain,
+			exportsSiteDir: __sites,
+			buildReportFileName,
+		});
+
+		infoLog(`Sending ending call to ${domain} sites`);
+
+		for (const site of report.sites) {
+			site.publishHashes = [...new Set(site.publishHashes)];
+			site.unpublishHashes = [...new Set(site.unpublishHashes)];
+		}
+
+		await sendEndSiteRender(report);
+	} else {
+		console.log("- LEGACY RENDER MODE -");
+		const domains = await getInstanceDomains();
+		for (const domain of domains) {
+			const { renderMode } = await getRenderMode(domain);
+
+			if (renderMode === "IDLE") {
+				infoLog(`Skipping build-end for domain ${domain} as it is marked as IDLE.`);
+				return;
+			}
+
+			const report = await getRenderReport({
+				domain,
+				exportsSiteDir: __sites,
+				buildReportFileName,
+			});
+
+			infoLog(`Sending ending call to ${domain} sites`);
+
+			for (const site of report.sites) {
+				site.publishHashes = [...new Set(site.publishHashes)];
+				site.unpublishHashes = [...new Set(site.unpublishHashes)];
+			}
+
+			await sendEndSiteRender(report);
+		}
 	}
-
-	await sendEndSiteRender(report);
 }
 
 async function main() {
-	await doLifeCycle("EndRender", endRenderAction);
+	await endRender();
 }
 
 main().catch((err) => {

package/exporter/commands/prepare-assets-directory.ts

@@ -3,11 +3,11 @@
 import childProcess from "node:child_process";
 import path from "node:path";
 
-import { doLifeCycle } from "../utils/core-utils";
 import { pathExists } from "../utils/folders";
+import { localLog } from "../utils/loggin";
 import { getRenderPathsFromDB } from "../utils/render";
 
-async function prepareAssetsAction() {
+async function prepareAssetsDir() {
 	const [domain] = process.argv.slice(2);
 
 	const { __exports } = await getRenderPathsFromDB({ domain });
@@ -19,12 +19,12 @@ async function prepareAssetsAction() {
 		childProcess.execSync(`rm -rf ${domainAssetsDir}`);
 		childProcess.execSync(`mv ${assetsDir} ${domainAssetsDir}`);
 	} else {
-		console.log("Assets directory not found");
+		localLog("Assets directory not found");
 	}
 }
 
 async function main() {
-	await doLifeCycle("PrepareAssets(Internal)", prepareAssetsAction);
+	await prepareAssetsDir();
 }
 
 main().catch((err) => {