@griddo/cx 11.7.10 → 11.7.12-rc.0

package/exporter/adapters/gatsby/actions/data.ts

@@ -0,0 +1,25 @@
+import type { RenderContext } from "../shared/context";
+
+import { createStore } from "../../../services/store";
+import { createAPICacheDir } from "../../../utils/cache";
+
+export async function dataAction(context: RenderContext) {
+	const {
+		domain,
+		renderMode,
+		renderMetadata: { griddoVersion },
+		paths: { __root },
+	} = context;
+
+	await createAPICacheDir({ basePath: __root });
+
+	const { pagesToCreate, pagesToDelete } = await createStore({
+		domain,
+		renderMode,
+		griddoVersion,
+		basePath: __root,
+	});
+
+	context.pagesToCreate = pagesToCreate;
+	context.pagesToDelete = pagesToDelete;
+}

package/exporter/adapters/gatsby/actions/healthCheck.ts

@@ -0,0 +1,10 @@
+import type { RenderContext } from "../shared/context";
+
+import { assertRenderIsValid, markRenderAsCompleted } from "../../../utils/render";
+
+export async function healthCheckAction(context: RenderContext) {
+	const { domain } = context;
+
+	await assertRenderIsValid(domain);
+	await markRenderAsCompleted(domain);
+}

package/exporter/adapters/gatsby/actions/init.ts

@@ -0,0 +1,26 @@
+import type { RenderContext } from "../shared/context";
+
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { infoLog } from "../../../utils/loggin";
+import { markRenderAsStarted } from "../../../utils/render";
+
+export async function initAction(context: RenderContext) {
+	const {
+		domain,
+		paths: { __root, __cache, __exports },
+		renderMode,
+	} = context;
+
+	if (renderMode === "FROM_SCRATCH") {
+		infoLog("Removing old files...\n");
+
+		fsp.rm(__cache, { force: true, recursive: true });
+		fsp.rm(path.join(__exports, "dist"), { force: true, recursive: true });
+		fsp.rm(path.join(__exports, "assets"), { force: true, recursive: true });
+		fsp.rm(path.join(__exports, domain), { force: true, recursive: true }); // only clocal
+	}
+
+	await markRenderAsStarted({ basePath: __root, domain });
+}

package/exporter/adapters/gatsby/actions/logs.ts

@@ -0,0 +1,10 @@
+import type { RenderContext } from "../shared/context";
+import type { SSG } from "../shared/types";
+
+import { saveDetailRenderLog } from "../../../utils/core-utils";
+
+export async function logsAction(context: RenderContext<SSG>) {
+	const { domain } = context;
+
+	await saveDetailRenderLog(domain);
+}

package/exporter/adapters/gatsby/actions/meta.ts

@@ -0,0 +1,16 @@
+import type { RenderContext } from "../shared/context";
+
+import { RobotsService } from "../../../services/robots";
+import { generateBuildReport } from "../../../utils/render";
+import { generateSitemaps } from "../../../utils/sitemaps";
+
+export async function metaAction(context: RenderContext) {
+	const {
+		domain,
+		paths: { __root },
+	} = context;
+
+	await generateBuildReport(domain);
+	await generateSitemaps(domain);
+	await RobotsService.writeFiles(domain);
+}

package/exporter/adapters/gatsby/actions/prepare.ts

@@ -0,0 +1,9 @@
+import type { RenderContext } from "../shared/context";
+
+import { createDirs } from "../../../utils/folders";
+
+export async function prepareAction(context: RenderContext) {
+	const { cxArtifacts } = context;
+
+	await createDirs(cxArtifacts.initials);
+}

package/exporter/adapters/gatsby/actions/relocation.ts

@@ -0,0 +1,15 @@
+import type { RenderContext } from "../shared/context";
+
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+export async function relocationAction(context: RenderContext) {
+	const {
+		paths: { __root, __ssg },
+	} = context;
+
+	const src = path.join(__ssg, "public");
+	const dst = path.join(__root, "dist");
+
+	await fsp.rename(src, dst);
+}

package/exporter/adapters/gatsby/actions/restore.ts

@@ -0,0 +1,36 @@
+import type { RenderContext } from "../shared/context";
+import type { SSG } from "../shared/types";
+
+import path from "node:path";
+
+import { RENDER_MODE } from "../../../types/render";
+import { copyDirs, moveDirs, removeDirs, renamePath } from "../../../utils/folders";
+
+export async function restoreAction(context: RenderContext<SSG>) {
+	const {
+		renderMode,
+		ssg: { ssgArtifacts },
+		cxArtifacts,
+		paths: { __components, __root, __cache, __exports, __ssg },
+	} = context;
+
+	await copyDirs(__components, __ssg, ["static"]);
+
+	if (renderMode === RENDER_MODE.FROM_SCRATCH) {
+		// NO RESTAURAMOS NADA!
+		// De hecho hay que borrar los cacheables
+		await removeDirs(
+			cxArtifacts.cacheables.map((artifactName) => path.join(__cache, artifactName)),
+		);
+		await removeDirs(
+			ssgArtifacts.cacheables.map((artifactName) => path.join(__cache, artifactName)),
+		);
+	}
+
+	if (renderMode === RENDER_MODE.INCREMENTAL) {
+		await moveDirs(__cache, __ssg, ssgArtifacts.cacheables);
+		await moveDirs(__cache, __root, cxArtifacts.cacheables);
+		await copyDirs(__exports, __root, cxArtifacts.restaurable);
+		await renamePath(path.join(__root, "dist"), path.join(__root, "dist-restored"));
+	}
+}

package/exporter/adapters/gatsby/actions/ssg.ts

@@ -0,0 +1,12 @@
+import type { RenderContext } from "../shared/context";
+import type { SSG } from "../shared/types";
+
+import { gatsbyBuild } from "../shared/gatsby-build";
+
+export async function ssgAction(context: RenderContext<SSG>) {
+	const {
+		ssg: { assetPrefix },
+	} = context;
+
+	await gatsbyBuild(assetPrefix);
+}

package/exporter/adapters/gatsby/actions/sync.ts

@@ -0,0 +1,71 @@
+import type { RenderContext } from "../shared/context";
+import type { SSG } from "../shared/types";
+
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { RENDER_MODE } from "../../../types/render";
+import {
+	deleteDisposableSiteDirs,
+	deleteEmptyDirectories,
+	moveDirs,
+	removeVirtualPages,
+} from "../../../utils/folders";
+import { extractAssetsFromDist } from "../shared/extract-assets";
+import { SyncRender } from "../shared/sync-render";
+
+export async function syncAction(context: RenderContext<SSG>) {
+	const {
+		renderMode,
+		cxArtifacts,
+		domain,
+		pagesToCreate,
+		pagesToDelete,
+		paths: { __root, __ssg, __cache, __exports },
+		ssg: { ssgArtifacts, assetPrefix },
+	} = context;
+
+	const needsAssetPrefix = !!assetPrefix && assetPrefix !== "";
+	const distDir = path.join(__root, "dist");
+	const distRestoredDir = path.join(__root, "dist-restored");
+	const storeDir = path.join(__root, "store");
+
+	// ESTO YA NO TIENE SENTIDO??? EL STORE???
+	await removeVirtualPages(storeDir);
+	// caching...
+	await moveDirs(__root, __cache, cxArtifacts.cacheables);
+	await moveDirs(__ssg, __cache, ssgArtifacts.cacheables);
+
+	if (renderMode === RENDER_MODE.FROM_SCRATCH) {
+		await deleteDisposableSiteDirs(distDir);
+	}
+
+	if (renderMode === RENDER_MODE.INCREMENTAL) {
+		await deleteDisposableSiteDirs(distRestoredDir);
+
+		const syncRender = new SyncRender({
+			src: distDir,
+			dst: distRestoredDir,
+			pagesToCreate,
+			pagesToDelete,
+			artifactsToCopyToExports: ["build-report.json"],
+		});
+
+		await syncRender.execute();
+
+		// elimina el dist recién creado, ya no hace falta porque lo hemos utilizado en syncRender.execute()
+		await fsp.rm(distDir, { force: true, recursive: true });
+		// renombra el nuevo dist-temporal que es el que aglutina todos los cambios -> dist
+		await fsp.rename(distRestoredDir, distDir);
+		await deleteEmptyDirectories(distDir);
+	}
+
+	if (needsAssetPrefix) {
+		await extractAssetsFromDist(domain);
+	}
+
+	// archiving...
+	await moveDirs(__root, __exports, cxArtifacts.archivables, {
+		withBackup: true,
+	});
+}

package/exporter/adapters/gatsby/index.ts

@@ -1,162 +1,82 @@
-import type {
-	Artifacts,
-	LifeCyclesNames,
-	LifeCycleSteps,
-} from "../../types/global";
+import type { SSG } from "./shared/types";
 
 import path from "node:path";
 
-import {
-	createDistFromGatsbyPublic,
-	getGatsbyAssetPrefixWithDomain,
-	runGatsbyBuildCommand,
-} from "./utils";
-import getCxArtifacts from "../../artifacts";
-import { AuthService } from "../../services/auth";
-import {
-	createDomainMetadata,
-	doLifeCycle,
-	getConfig,
-	saveBuildEndLogs,
-} from "../../utils/core-utils";
-import { createDomainRenderData } from "../../utils/create-build-data";
-import {
-	copyArtifacts,
-	createArtifacts,
-	deleteDisposableSiteDirs,
-	moveArtifacts,
-	removeArtifacts,
-	removeVirtualPagesFromStore,
-	renameArtifact,
-} from "../../utils/folders";
+import { GRIDDO_ASSET_PREFIX } from "../../constants/envs";
+import { getCxArtifacts } from "../../utils/artifacts";
+import { doLifeCycle } from "../../utils/core-utils";
+import { pathExists } from "../../utils/folders";
 import { infoLog } from "../../utils/loggin";
-import {
-	createSentinelRenderFile,
-	deleteSentinelRenderFile,
-	isValidRender,
-} from "../../utils/render";
+import { getRenderMetadataFromDB, getRenderMode, getRenderPathsFromDB } from "../../utils/render";
+import { cleanAction } from "./actions/clean";
+import { closeAction } from "./actions/close";
+import { dataAction } from "./actions/data";
+import { healthCheckAction } from "./actions/healthCheck";
+import { initAction } from "./actions/init";
+import { logsAction } from "./actions/logs";
+import { metaAction } from "./actions/meta";
+import { prepareAction } from "./actions/prepare";
+import { relocationAction } from "./actions/relocation";
+import { restoreAction } from "./actions/restore";
+import { ssgAction } from "./actions/ssg";
+import { syncAction } from "./actions/sync";
+import { getGatsbyArtifacts } from "./shared/artifacts";
+import { RenderContext } from "./shared/context";
 
 /**
- * Render every instance domain with the Gatsby adapter.
+ * Executes a complete Gatsby render process for a given domain.
+ *
+ * The render process consists of multiple lifecycle steps that handle cleaning,
+ * preparing, building and syncing the site. It can run in two modes:
+ * - FROM_SCRATCH: Performs a complete rebuild of the site
+ * - INCREMENTAL: Only rebuilds changed pages while preserving the rest
  */
-export async function renderDomainsWithGatsbyAdapter(domain: string) {
-	await AuthService.login();
-	const config = getConfig();
-
-	infoLog(`Initializing render for the domain ${domain}\n`);
-
-	const {
-		//
-		__ssg,
-		__exports,
-		__cache,
-		__cx,
-		__components,
-	} = config.paths(domain);
-
-	// Griddo artifacts
-	const cxArtifacts = getCxArtifacts(domain);
-
-	// Gatsby artifacts
-	const gatsbyArtifacts: Pick<Artifacts, "disposables" | "cacheables"> = {
-		disposables: [
-			path.join(__ssg, "public"),
-			path.join(__ssg, "static"),
-			path.join(__ssg, ".cache"),
-		],
-		cacheables: [".cache"],
-	};
-
-	// These variables are involved in the build for create the dist directory
-	// from public and pass to the gatsby-build command via spawnSync.
-	const assetPrefix = getGatsbyAssetPrefixWithDomain(domain);
-	const needsAssetPrefix = !!assetPrefix && assetPrefix !== "";
-
-	// Compose artifacts
-	const disposableArtifacts = [
-		...cxArtifacts.disposables,
-		...gatsbyArtifacts.disposables,
-	];
-
-	// LifeCycles
-
-	const allLifeCycles: Array<{
-		name: LifeCyclesNames;
-		steps: LifeCycleSteps;
-	}> = [
-		{
-			name: "Init",
-			steps: [() => createSentinelRenderFile()],
-		},
-
-		{
-			name: "Clean",
-			steps: [() => removeArtifacts(disposableArtifacts)],
-		},
-
-		{
-			name: "Prepare",
-			steps: [() => createArtifacts(cxArtifacts.initials)],
-		},
-
-		{
-			name: "Restore",
-			steps: [
-				() => copyArtifacts(__components, __ssg, ["static"]),
-				() => copyArtifacts(__exports, __cx, cxArtifacts.archivables),
-				() =>
-					renameArtifact(path.join(__cx, "dist"), path.join(__ssg, "public")),
-				() => moveArtifacts(__cache, __cx, cxArtifacts.cacheables),
-				() => moveArtifacts(__cache, __ssg, gatsbyArtifacts.cacheables),
-			],
-		},
-
-		{
-			name: "Data",
-			steps: [() => createDomainRenderData(domain)],
-		},
-
-		{
-			name: "SSG",
-			steps: [() => runGatsbyBuildCommand(assetPrefix)],
-		},
-
-		{
-			name: "Relocation",
-			steps: [() => createDistFromGatsbyPublic(domain, needsAssetPrefix)],
-		},
-
-		{
-			name: "Meta",
-			steps: [() => createDomainMetadata(domain), () => saveBuildEndLogs()],
-		},
-
-		{
-			name: "Archive",
-			steps: [
-				() => removeVirtualPagesFromStore(),
-				() => deleteDisposableSiteDirs(),
-				() =>
-					moveArtifacts(__cx, __exports, cxArtifacts.archivables, {
-						withBackup: true,
-					}),
-				() => moveArtifacts(__cx, __cache, cxArtifacts.cacheables),
-				() => moveArtifacts(__ssg, __cache, gatsbyArtifacts.cacheables),
-			],
-		},
-
-		{
-			name: "Close",
-			steps: [() => removeArtifacts(disposableArtifacts)],
-		},
-
-		{
-			name: "HealthCheck",
-			steps: [() => isValidRender(), () => deleteSentinelRenderFile()],
-		},
-	];
-
-	for (const { name, steps } of allLifeCycles) {
-		await doLifeCycle(name, steps);
+export async function gatsbyRenderDomain(domain: string) {
+	// Render data
+	const { renderMode, reason } = await getRenderMode(domain);
+	const renderMetadata = await getRenderMetadataFromDB();
+	const paths = await getRenderPathsFromDB({ domain });
+
+	// Artifacts
+	const cxArtifacts = await getCxArtifacts(domain);
+	const ssgArtifacts = await getGatsbyArtifacts(domain);
+
+	// Gatsby assetPrefix
+	const isProDomain = domain.startsWith(renderMetadata.proDomainPrefix);
+	const assetPrefix = GRIDDO_ASSET_PREFIX && isProDomain ? `${GRIDDO_ASSET_PREFIX}/${domain}` : "";
+
+	// Previous render error management
+	const domainSentinelFile = await pathExists(path.join(paths.__ssg, `.render-sentinel-${domain}`));
+	const currentRenderMode = domainSentinelFile ? "FROM_SCRATCH" : renderMode;
+	const currentReason = domainSentinelFile ? "previous render error" : reason;
+
+	if (renderMode === "IDLE" && currentRenderMode === "IDLE") {
+		return;
 	}
+
+	const renderReason = currentReason ? ` <${currentReason}>` : "";
+	infoLog(`Init render (${currentRenderMode})${renderReason} for domain ${domain}\n`);
+
+	// Render context
+	const context = new RenderContext<SSG>({
+		domain,
+		renderMode: currentRenderMode,
+		paths,
+		renderMetadata,
+		cxArtifacts,
+		ssg: { assetPrefix, ssgArtifacts },
+	});
+
+	await doLifeCycle("Init", async () => initAction(context));
+	await doLifeCycle("Clean", async () => cleanAction(context));
+	await doLifeCycle("Prepare", async () => prepareAction(context));
+	await doLifeCycle("Restore", async () => restoreAction(context));
+	await doLifeCycle("Data", async () => dataAction(context));
+	await doLifeCycle("SSG", async () => ssgAction(context));
+	await doLifeCycle("Relocation", async () => relocationAction(context));
+	await doLifeCycle("Meta", async () => metaAction(context));
+	await doLifeCycle("Sync", async () => syncAction(context));
+	await doLifeCycle("HealthCheck", async () => healthCheckAction(context));
+	await doLifeCycle("Logs", async () => logsAction(context));
+	await doLifeCycle("Close", async () => closeAction(context));
 }

package/exporter/adapters/gatsby/shared/artifacts.ts

@@ -0,0 +1,16 @@
+import path from "node:path";
+
+import { getRenderPathsFromDB } from "../../../utils/render";
+
+export async function getGatsbyArtifacts(domain: string) {
+	const { __ssg } = await getRenderPathsFromDB({ domain });
+
+	return {
+		disposables: [
+			path.join(__ssg, "public"),
+			path.join(__ssg, "static"),
+			path.join(__ssg, ".cache"),
+		],
+		cacheables: [".cache"],
+	};
+}

package/exporter/adapters/gatsby/shared/context.ts

@@ -0,0 +1,50 @@
+import type { Artifacts, PlaceholderPath } from "../../../types/global";
+import type { RenderMode } from "../../../types/render";
+
+interface RenderContextProps<T> {
+	domain: string;
+	renderMode: RenderMode;
+	paths: Record<string, string>;
+	ssg: T;
+	renderMetadata: {
+		proDomainPrefix: string;
+		griddoVersion: string;
+		buildReportFileName: string;
+	};
+	cxArtifacts: Artifacts;
+}
+
+/**
+ * Encapsulates the state, configuration, and artifacts for a single SSG
+ * render process.
+ *
+ * This class is instantiated at the beginning of a render and passed through
+ * each lifecycle step, providing a centralized and consistent context for all
+ * operations. It is agnostic to the specific SSG being used.
+ */
+export class RenderContext<T = unknown> {
+	readonly domain: string;
+	readonly renderMode: RenderMode;
+	readonly paths: Record<PlaceholderPath, string>;
+	pagesToCreate: number[] = [];
+	pagesToDelete: number[] = [];
+	ssg: T;
+	renderMetadata: { proDomainPrefix: string; griddoVersion: string; buildReportFileName: string };
+	cxArtifacts: Artifacts;
+
+	constructor({
+		domain,
+		renderMode,
+		ssg,
+		paths,
+		renderMetadata,
+		cxArtifacts,
+	}: RenderContextProps<T>) {
+		this.domain = domain;
+		this.renderMode = renderMode;
+		this.paths = paths;
+		this.renderMetadata = renderMetadata;
+		this.cxArtifacts = cxArtifacts;
+		this.ssg = ssg;
+	}
+}

package/exporter/adapters/gatsby/shared/diff-assets.ts

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+import fsp from "node:fs/promises";
+import { join } from "node:path";
+
+// Lista de patrones de los ficheros de assets más importantes.
+// Si estos no cambian, el webpackCompilationHash no debería cambiar.
+const _KEY_ASSET_PATTERNS = [/^app-.*\.js$/, /^framework-.*\.js$/, /^webpack-runtime-.*\.js$/];
+
+const KEY_ASSET_PATTERNS = [/\.js$/];
+
+/**
+ * Calcula los hashes SHA256 del contenido de los assets clave en un directorio.
+ * @param dir La ruta al directorio (ej. './public')
+ * @returns Un Map donde la clave es el nombre del fichero y el valor es su hash.
+ */
+async function getAssetHashes(dir: string): Promise<Map<string, string>> {
+	const assetHashes = new Map<string, string>();
+
+	try {
+		const allFiles = await fsp.readdir(dir);
+		const keyAssetFiles = allFiles.filter((fileName) =>
+			KEY_ASSET_PATTERNS.some((pattern) => pattern.test(fileName)),
+		);
+
+		for (const fileName of keyAssetFiles) {
+			const filePath = join(dir, fileName);
+			const fileContent = await fsp.readFile(filePath);
+			const hash = createHash("sha256").update(fileContent).digest("hex");
+			assetHashes.set(fileName, hash);
+		}
+	} catch (error) {
+		console.error(`Error procesando el directorio ${dir}:`, error);
+		// Si un directorio no existe (ej. el de producción la primera vez),
+		// lo tratamos como si no tuviera assets.
+	}
+
+	return assetHashes;
+}
+
+/**
+ * Compara los assets clave entre dos directorios de build de Gatsby.
+ * @param dir1 Ruta al primer directorio (ej. el de producción)
+ * @param dir2 Ruta al segundo directorio (ej. el del nuevo build)
+ * @returns `true` si hay diferencias, `false` si son idénticos.
+ */
+export async function getAssetsDiffBetweenRenders(dir1: string, dir2: string): Promise<boolean> {
+	const [hashes1, hashes2] = await Promise.all([getAssetHashes(dir1), getAssetHashes(dir2)]);
+
+	// Si el número de assets clave es diferente, hay cambios.
+	if (hashes1.size !== hashes2.size) {
+		return true;
+	}
+
+	// Comparamos los hashes de cada fichero.
+	for (const [fileName, hash1] of hashes1.entries()) {
+		const hash2 = hashes2.get(fileName);
+
+		// Si un fichero existe en el primero pero no en el segundo, hay cambios.
+		if (!hash2) {
+			return true;
+		}
+
+		// Si el contenido (hash) de un fichero ha cambiado.
+		if (hash1 !== hash2) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Actualiza el webpackCompilationHash en un único fichero HTML.
+ * @param filePath Ruta al fichero HTML.
+ * @param newHash El nuevo hash a insertar.
+ */
+export async function patchHtmlFile(filePath: string, newHash: string): Promise<void> {
+	try {
+		const content = await fsp.readFile(filePath, "utf-8");
+
+		// Esta expresión regular captura tres grupos:
+		// 1. La parte ANTES del hash (window.___webpackCompilationHash=")
+		// 2. El hash ANTIGUO ([^"]*)
+		// 3. La parte DESPUÉS del hash (";</script>)
+		const regex = /(window\.___webpackCompilationHash=")([^"]*)(";<\/script>)/;
+
+		// Solo reemplazamos el segundo grupo (el hash)
+		const newContent = content.replace(regex, `$1${newHash}$3`);
+
+		if (content === newContent) {
+			console.warn(`WARN: No se encontró el hash en ${filePath}. El fichero no fue modificado.`);
+			return;
+		}
+
+		await fsp.writeFile(filePath, newContent, "utf-8");
+	} catch (error) {
+		console.error(`ERROR: Fallo al procesar el fichero ${filePath}:`, error);
+	}
+}
+
+// --- Ejemplo de uso ---
+// async function miScriptDeDeploy() {
+//   const dirProduccion = '/ruta/a/produccion/public';
+//   const dirNuevoBuild = './public';
+
+//   const hayDiferencias = await getAssetsDiffBetweenRenders(dirProduccion, dirNuevoBuild);
+
+//   if (hayDiferencias) {
+//     // Lógica para el CAMINO A (cambio de código)
+//   } else {
+//     // Lógica para el CAMINO B (solo contenido)
+//   }
+// }