@griddo/cx 10.3.13 → 10.3.15

package/exporter/adapters/astro/index.ts

@@ -0,0 +1,37 @@
+import { getInstanceDomains } from "@exporter/utils/domains";
+import { downloadBuildData } from "@exporter/utils/download-build-data";
+import { printExporterLogo } from "@exporter/utils/shared";
+
+import { getAstroDomainRunner } from "./utils";
+
+/**
+ * Astro adapter for Griddo.
+ */
+async function runAstroAdapter() {
+	printExporterLogo("astro");
+
+	const domains = await getInstanceDomains();
+
+	for (const domain of domains) {
+		const runner = getAstroDomainRunner(domain);
+		// ---------------------------------------------------------------------- //
+		// Init the render, restore Gatsby /.cache and /public folders            //
+		// ---------------------------------------------------------------------- //
+		runner.init();
+		// runner.whatEverAction();
+		// runner.otherAstroRelatedFunction();
+
+		// ---------------------------------------------------------------------- //
+		// Download domain build data (sites, pages, etc) and generator a folder  //
+		// called `store` where all the domain render data is saved.              //
+		// ---------------------------------------------------------------------- //
+		await downloadBuildData();
+
+		// ---------------------------------------------------------------------- //
+		// Call the `astro build` command.                                        //
+		// ---------------------------------------------------------------------- //
+		runner.runAstroBuild();
+	}
+}
+
+export { runAstroAdapter };

package/exporter/adapters/astro/utils.ts

@@ -0,0 +1,29 @@
+import { getEnvRunner } from "@exporter/utils/runners";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+/**
+ * Return a runner, a serie of functions to manage the Astro render artifacts.
+ */
+function getAstroDomainRunner(domain: string) {
+	const run = getEnvRunner({
+		DOMAIN: domain,
+		GRIDDO_RENDERID: new Date().valueOf(),
+	});
+
+	const init = () => {
+		console.info(`Initializing exporter for the domain ${domain}`);
+	};
+
+	const runAstroBuild = () => {
+		run("yarn astro-build");
+	};
+
+	return {
+		init,
+		runAstroBuild,
+	};
+}
+
+export { getAstroDomainRunner };

package/exporter/adapters/gatsby/index.ts

@@ -0,0 +1,86 @@
+import { getInstanceDomains } from "@exporter/utils/domains";
+import { downloadBuildData } from "@exporter/utils/download-build-data";
+import {
+	measureExecutionTime,
+	printExporterLogo,
+} from "@exporter/utils/shared";
+
+import { getGatsbyDomainRunner } from "./utils";
+
+/**
+ * Gatsby adapter for Griddo.
+ */
+async function runGatsbyAdapter() {
+	printExporterLogo("gatsby");
+
+	let exeTime = 0;
+	const domains = await getInstanceDomains();
+
+	for (const domain of domains) {
+		const runner = getGatsbyDomainRunner(domain);
+
+		/*
+		 * Init the render, restore Gatsby `.cache` and `public` folders.
+		 */
+		exeTime = await measureExecutionTime(
+			runner.init,
+			runner.restoreArtifacts,
+			runner.restoreCacheArtifacts
+		).catch((err) => {
+			console.error(
+				"Error in init() || restoreArtifacts() || restoreCacheArtifacts() :",
+				err?.stdout?.toString() || err
+			);
+			process.exit(1);
+		});
+
+		console.info(`success restore ${domain} - ${exeTime}s`);
+
+		/*
+		 * Download domain build data (sites, pages, etc) and generator a folder
+		 * called `store` where all the domain render data is saved.
+		 */
+		exeTime = await measureExecutionTime(downloadBuildData).catch((err) => {
+			console.error(
+				"Error in downloadBuildData() :",
+				err?.stdout?.toString() || err
+			);
+			process.exit(1);
+		});
+		console.info(`success download ${domain} - ${exeTime}s`);
+
+		/*
+		 * Call the `gatsby build` command.
+		 * Gatsby will use the downloaded data and create the static build.
+		 * `gatsby-node.ts` is the main file where the stati generation happens.
+		 */
+		exeTime = await measureExecutionTime(runner.runGatsbyBuild).catch((err) => {
+			console.error(
+				"Error in runGatsbyBuild() :",
+				err?.stdout?.toString() || err
+			);
+			process.exit(1);
+		});
+
+		console.info(`success gatsby build command - ${exeTime}s`);
+
+		/*
+		 * When Gatsby ends, remove disposable artifacts and save .cache and
+		 * public foler to use in the next render.
+		 */
+		exeTime = await measureExecutionTime(
+			runner.removeDisposableArtifacts,
+			runner.archiveArtifacts,
+			runner.archiveCacheArtifacts
+		).catch((err) => {
+			console.error(
+				"Error in removeDisposableArtifacts() || archiveArtifacts()|| archiveCacheArtifacts() :",
+				err?.stdout?.toString() || err
+			);
+			process.exit(1);
+		});
+		console.info(`success archive ${domain} - ${exeTime}s`);
+	}
+}
+
+export { runGatsbyAdapter };

package/exporter/adapters/gatsby/utils.ts

@@ -0,0 +1,352 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { getEnvRunner } from "@exporter/utils/runners";
+import { CXRootFolder, instanceRootFolder } from "@exporter/utils/shared";
+import chalk from "chalk";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+/**
+ * Return a runner, a serie of functions to manage the Gatsby render artifacts.
+ */
+function getGatsbyDomainRunner(domain: string) {
+	// Artifacts to preserve between CX installs
+	const artifactsArchivable = ["dist", "assets"];
+
+	// Artifacts to remove after export
+	// if STRIP_DOMAIN_FROM_PATH is false `.cache` will be added.
+	const artifactsDisposable = ["public", "store"];
+
+	// Artifacts to make exports faster
+	// if STRIP_DOMAIN_FROM_PATH is true `.cache` will be added.
+	const artifactsCache = ["apiCache" /* , ".cache" */];
+
+	// TODO: Remove STRIP_DOMAIN_FROM_PATH behaviour when all instances are over 1.75.219
+	const STRIP_DOMAIN_FROM_PATH = JSON.parse(
+		process.env.GRIDDO_EXPORT_STRIP_DOMAIN_FROM_PATH || "false"
+	);
+
+	if (STRIP_DOMAIN_FROM_PATH) {
+		artifactsCache.push(".cache");
+	} else {
+		artifactsDisposable.push(".cache");
+	}
+
+	// Where we are going to find archived exports
+	const exportArchiveBasePath = path.resolve(
+		instanceRootFolder,
+		"exports/sites"
+	);
+	const exportCachesArchivePath = path.resolve(__dirname, "../caches");
+
+	const assetPrefix = getGatsbyAssetPrefixSlug(domain);
+
+	const run = getEnvRunner({
+		DOMAIN: domain,
+		GRIDDO_ASSET_PREFIX: assetPrefix,
+		NEEDS_ASSET_DOMAIN_PREFIX: assetPrefix && assetPrefix !== "",
+		GRIDDO_RENDERID: new Date().valueOf(),
+	});
+
+	/**
+	 * Initialize exporter clearing artifacts data from a unsuccessful build and
+	 * creating necesary folders to store a new build.
+	 */
+	const init = () => {
+		console.info(`Initializing exporter for the domain ${domain}`);
+		cleanDirtyArtifactPaths();
+		createBaseExportPaths();
+	};
+
+	/**
+	 * Restore Gatsby artifacts from a previous render to improve performance.
+	 */
+	const restoreArtifacts = () => {
+		for (const artifact of artifactsArchivable) {
+			const { currentExportArchivePath, currentExportWorkingPath } =
+				getArtifactPaths(artifact);
+
+			if (fs.existsSync(currentExportArchivePath)) {
+				console.log(`️Restoring ${chalk.gray(currentExportArchivePath)}`);
+				run(`cp -R ${currentExportArchivePath} ${currentExportWorkingPath}`);
+			}
+		}
+
+		moveDistToPublic();
+	};
+
+	const getArtifactPaths = (artifact = "") => {
+		if (artifact === "/")
+			throw new Error(`Artifact path cannot be root: ${artifact}`);
+
+		// Archives
+		const domainExportArchiveBasePath = path.resolve(
+			exportArchiveBasePath,
+			domain
+		);
+		const currentExportArchivePath = path.resolve(
+			domainExportArchiveBasePath,
+			artifact
+		);
+		const currentExportArchivePathInDomain = path.resolve(
+			currentExportArchivePath,
+			domain
+		);
+
+		// Cachés
+		const domainCacheArchiveBasePath = path.resolve(
+			exportCachesArchivePath,
+			domain
+		);
+		const currentExportArchiveCachePath = path.resolve(
+			domainCacheArchiveBasePath,
+			artifact
+		);
+		const currentExportArchiveCachePathInDomain = path.resolve(
+			currentExportArchiveCachePath,
+			domain
+		);
+
+		const currentExportBackupPath = `${currentExportArchivePath}-BACKUP`;
+		const currentExportWorkingPath = path.resolve(CXRootFolder, artifact);
+
+		return {
+			domainExportArchiveBasePath,
+			currentExportArchivePath,
+			currentExportBackupPath,
+			currentExportWorkingPath,
+			currentExportArchivePathInDomain,
+			domainCacheArchiveBasePath,
+			currentExportArchiveCachePath,
+			currentExportArchiveCachePathInDomain,
+		};
+	};
+
+	/**
+	 * Remove artifacts probably from a unsuccessful build.
+	 */
+	const cleanDirtyArtifactPaths = () => {
+		for (const artifact of [
+			...artifactsArchivable,
+			...artifactsDisposable,
+			...artifactsCache,
+		]) {
+			const { currentExportWorkingPath } = getArtifactPaths(artifact);
+
+			if (fs.existsSync(currentExportWorkingPath)) {
+				console.log(`Cleanup dirty ${chalk.gray(currentExportWorkingPath)}`);
+				run(`rm -rf ${currentExportWorkingPath}`);
+			}
+		}
+	};
+
+	/**
+	 * Creates necesary folders.
+	 */
+	const createBaseExportPaths = () => {
+		const { domainExportArchiveBasePath, domainCacheArchiveBasePath } =
+			getArtifactPaths();
+
+		for (const _path of [
+			domainExportArchiveBasePath,
+			domainCacheArchiveBasePath,
+		]) {
+			if (!fs.existsSync(_path)) {
+				console.info(`Creating ${_path}`);
+				run(`mkdir -p ${_path}`);
+			}
+		}
+	};
+
+	const archiveExportArtifact = (artifact: string) => {
+		const { currentExportArchivePath, currentExportWorkingPath } =
+			getArtifactPaths(artifact);
+
+		console.info(
+			`Moving files from ${chalk.gray(
+				currentExportWorkingPath
+			)} to ${chalk.gray(currentExportArchivePath)}`
+		);
+		run(`mv ${currentExportWorkingPath} ${currentExportArchivePath}`);
+	};
+
+	/** Archive archivable artifacts to reuse them in the next render */
+	const archiveArtifacts = () => {
+		for (const artifact of artifactsArchivable) {
+			const { currentExportWorkingPath, currentExportArchivePath } =
+				getArtifactPaths(artifact);
+
+			if (!fs.existsSync(currentExportWorkingPath)) {
+				console.log(
+					"Source directory has not been created:",
+					currentExportWorkingPath
+				);
+				continue;
+			}
+
+			try {
+				createArtifactBackup(artifact);
+				archiveExportArtifact(artifact);
+				deleteArtifactBackup(artifact);
+			} catch (error) {
+				console.log(
+					`Error moving files to ${currentExportArchivePath}`,
+					(error as Error).message
+				);
+				restoreArtifactBackup(artifact);
+				continue;
+			}
+		}
+	};
+
+	const createArtifactBackup = (artifact: string) => {
+		const { currentExportArchivePath, currentExportBackupPath } =
+			getArtifactPaths(artifact);
+
+		if (fs.existsSync(currentExportArchivePath)) {
+			console.info(
+				`Creating backup of ${chalk.gray(currentExportArchivePath)}`
+			);
+			run(`mv ${currentExportArchivePath} ${currentExportBackupPath}`);
+		}
+	};
+
+	const restoreArtifactBackup = (artifact: string) => {
+		const { currentExportArchivePath, currentExportBackupPath } =
+			getArtifactPaths(artifact);
+
+		if (fs.existsSync(currentExportBackupPath)) {
+			console.log(`️Restoring backup ${chalk.gray(currentExportArchivePath)}`);
+			run(`mv ${currentExportBackupPath} ${currentExportArchivePath}`);
+		}
+	};
+
+	const deleteArtifactBackup = (artifact: string) => {
+		const { currentExportArchivePath, currentExportBackupPath } =
+			getArtifactPaths(artifact);
+
+		console.log(`️Removing backup ${chalk.gray(currentExportArchivePath)}`);
+		run(`rm -rf ${currentExportBackupPath}`);
+	};
+
+	/** Archive archivable cache artifacts to reuse them in the next render */
+	const archiveCacheArtifacts = () => {
+		for (const artifact of artifactsCache) {
+			const { currentExportArchiveCachePath, currentExportWorkingPath } =
+				getArtifactPaths(artifact);
+
+			if (fs.existsSync(currentExportWorkingPath)) {
+				console.info(
+					`Moving files from ${chalk.gray(
+						currentExportWorkingPath
+					)} to ${chalk.gray(currentExportArchiveCachePath)}`
+				);
+				run(`mv ${currentExportWorkingPath} ${currentExportArchiveCachePath}`);
+			} else {
+				throw new Error(
+					`Error moving files from ${currentExportWorkingPath}: Path does not exist.`
+				);
+			}
+		}
+	};
+
+	/**
+	 * Restore Gatsby cache artifacts from a previous render to improve
+	 * performance.
+	 */
+	const restoreCacheArtifacts = () => {
+		for (const artifact of artifactsCache) {
+			const { currentExportArchiveCachePath, currentExportWorkingPath } =
+				getArtifactPaths(artifact);
+
+			if (fs.existsSync(currentExportArchiveCachePath)) {
+				console.log(`️Restoring ${chalk.gray(currentExportArchiveCachePath)}`);
+				run(`mv ${currentExportArchiveCachePath} ${currentExportWorkingPath}`);
+			}
+		}
+	};
+
+	/**
+	 * Call the gatsby build command.
+	 * This start the `yarn gatsby-build` command that will use the data downloaded.
+	 */
+	const runGatsbyBuild = () => {
+		run("yarn gatsby-build");
+	};
+
+	// TODO: Hacer que infra tire de `public` en vez de `dist` y quitar esto
+	const moveDistToPublic = () => {
+		const { currentExportWorkingPath: distPath } = getArtifactPaths("dist");
+		const { currentExportWorkingPath: publicPath } = getArtifactPaths("public");
+
+		if (fs.existsSync(distPath)) {
+			console.log(
+				`Moving ${chalk.gray(distPath)} to ${chalk.gray(publicPath)}`
+			);
+			run(`mv ${distPath} ${publicPath}`);
+		}
+	};
+
+	// TODO: Esto no debería hacerse desde infra
+	// const movePublicToDist = () => {
+	// 	const { currentExportWorkingPath: publicPath } = getArtifactPaths("public");
+	// 	const { currentExportWorkingPath: distPath } = getArtifactPaths("dist");
+
+	// 	if (fs.existsSync(publicPath)) {
+	// 		console.log(`Moving ${publicPath} to ${distPath}`);
+	// 		run(`mv ${publicPath} ${distPath}`);
+	// 	}
+	// };
+
+	/**
+	 * Delete disposable artifacts between renders.
+	 */
+	const removeDisposableArtifacts = () => {
+		for (const artifact of artifactsDisposable) {
+			const { currentExportWorkingPath: artifactPath } =
+				getArtifactPaths(artifact);
+
+			if (fs.existsSync(artifactPath)) {
+				console.log(`️Removing ${chalk.gray(artifactPath)}`);
+				run(`rm -rf ${artifactPath}`);
+			}
+		}
+	};
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	const cleanAfterFail = () => {
+		cleanDirtyArtifactPaths();
+	};
+
+	return {
+		init,
+		getArtifactPaths,
+		archiveExportArtifact,
+		archiveArtifacts,
+		restoreArtifacts,
+		createArtifactBackup,
+		restoreArtifactBackup,
+		deleteArtifactBackup,
+		archiveCacheArtifacts,
+		restoreCacheArtifacts,
+		runGatsbyBuild,
+		removeDisposableArtifacts,
+	};
+}
+
+/**
+ * Return the assetPrefix url `assetPrefix/domain`
+ */
+function getGatsbyAssetPrefixSlug(domain: string) {
+	const assetPrefix =
+		process.env.GRIDDO_ASSET_PREFIX || process.env.ASSET_PREFIX;
+
+	if (!assetPrefix || !domain) return "";
+	if (!domain.startsWith("pro-")) return "";
+
+	return `${assetPrefix}/${domain}`;
+}
+
+export { getGatsbyDomainRunner };

package/exporter/adapters/index.ts

@@ -0,0 +1,5 @@
+import { runAstroAdapter } from "./astro";
+import { runGatsbyAdapter } from "./gatsby";
+
+export type Adapters = "gatsby" | "astro";
+export { runAstroAdapter, runGatsbyAdapter };

package/{scripts → exporter}/build-complete.ts

@@ -1,11 +1,10 @@
-import fs from "fs";
-import path from "path";
+import fs from "node:fs";
+import path from "node:path";
 
 import pkgDir from "pkg-dir";
 
-import { AuthService } from "../src/services/auth";
-import { SitesService } from "../src/services/sites";
-import { logInfo } from "../src/utils/shared";
+import { AuthService } from "./services/auth";
+import { SitesService } from "./services/sites";
 
 // Where we are going to find export folders
 const execBasePath = pkgDir.sync(path.resolve(__dirname, "../.."))!;
@@ -21,12 +20,12 @@ type Report = {
 				lang?: string | undefined;
 		  }
 		| undefined;
-	sites: {
+	sites: Array<{
 		siteId: number;
-		publishHashes: string[];
+		publishHashes: Array<string>;
 		siteHash: string | null;
-		unpublishHashes: string[];
-	}[];
+		unpublishHashes: Array<string>;
+	}>;
 };
 
 export async function buildComplete(report: Report) {
@@ -35,14 +34,14 @@ export async function buildComplete(report: Report) {
 	const promises = report.sites.map((site) => {
 		const { siteId, ...body } = site;
 
-		logInfo(`Deploying ending call to site ${siteId}:`);
+		console.info(`Deploying ending call to site ${siteId}:`);
 
 		return SitesService.endSiteRender(siteId, body);
 	});
 
 	await Promise.all(promises);
 
-	logInfo(`Build end signal sent for ${report.sites.length} site(s)`);
+	console.info(`Build end's signal sent for ${report.sites.length} site(s)`);
 }
 
 function getExportedDomains() {
@@ -51,7 +50,7 @@ function getExportedDomains() {
 	return domains;
 }
 
-function getBuildReports(domains: string[]) {
+function getBuildReports(domains: Array<string>) {
 	const reports = [];
 
 	for (const domain of domains) {
@@ -63,7 +62,7 @@ function getBuildReports(domains: string[]) {
 		);
 
 		if (!fs.existsSync(buildReportFile)) {
-			console.log(`Build report "${buildReportFile}" not found.`);
+			console.info(`Build report file "${buildReportFile}" not found.`);
 			continue;
 		}
 
@@ -84,4 +83,7 @@ async function main() {
 	}
 }
 
-main();
+main().catch((err) => {
+	console.error("Error", err?.stdout?.toString() || err);
+	process.exit(1);
+});

package/exporter/download-data.ts

@@ -0,0 +1,6 @@
+import { downloadBuildData } from "./utils/download-build-data";
+
+downloadBuildData().catch((err) => {
+	console.error("Error", err?.stdout?.toString() || err);
+	process.exit(1);
+});

package/exporter/index-width-adapter.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/* eslint-disable node/shebang */
+import { Adapters, runGatsbyAdapter } from "./adapters";
+
+const adapter = process.env.GRIDDO_CX_ADAPTER as Adapters;
+
+async function main(adapter: Adapters) {
+	if (adapter === "gatsby") {
+		await runGatsbyAdapter();
+		process.exit(0);
+	}
+
+	// if (adapter === "astro") {
+	// 	await runAstroAdapter();
+	// 	process.exit(0);
+	// }
+
+	throw new Error("Adapter not configured correctly");
+}
+
+// Go render, go!
+main(adapter).catch((err) => {
+	console.error("Error in main():", err?.stdout?.toString() || err);
+	process.exit(1);
+});

package/exporter/index.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/* eslint-disable node/shebang */
+
+import { runGatsbyAdapter } from "./adapters";
+
+async function main() {
+	await runGatsbyAdapter();
+}
+
+// Go render, go!
+main().catch((err) => {
+	console.error("Error in main():", err?.stdout?.toString() || err);
+	process.exit(1);
+});

package/exporter/reset-render.ts

@@ -0,0 +1,12 @@
+import { AuthService } from "./services/auth";
+import { SettingsService } from "./services/settings";
+
+async function main() {
+	await AuthService.login();
+	await SettingsService.resetRender();
+}
+
+main().catch((err) => {
+	console.error("Error", err?.stdout?.toString() || err);
+	process.exit(1);
+});

package/{src → exporter}/services/auth.ts

@@ -43,8 +43,6 @@ class AuthService {
 			}
 
 			return this.headers;
-
-			console.log("👋 Login\n");
 		} catch (e) {
 			console.error(
 				chalk.red(`

package/{src → exporter}/services/distributors.ts

@@ -64,7 +64,7 @@ class DistributorService {
 		}
 
 		console.log(
-			`ERROR: Distribuidor mode: ${mode} is not recognized on page ${page?.id}.`
+			`Error: Distribuidor mode: ${mode} is not recognized on page ${page?.id}.`
 		);
 
 		return data;
@@ -95,6 +95,15 @@ class DistributorService {
 			return [];
 		}
 
+		// Avoid fetch distributors with empty `data.sources`
+		if (Array.isArray(data.sources) && data.sources.length < 1) {
+			logBox(
+				`Warning: Page with id: ${page.id} has a ReferenceField with empty \`data.sources\``
+			);
+
+			return [];
+		}
+
 		const { site, lang } = data;
 		const body = this.getBody(data, page);
 		const response = await SitesService.getDistributorData(