@griddo/cx 10.4.2 → 10.4.4

package/exporter/utils/folders.ts

@@ -1,13 +1,26 @@
+import type { CXDir } from "../types/global";
 import type { Site } from "../types/sites";
 
+import { spawnSync } from "node:child_process";
 import path from "node:path";
 
 import fs from "fs-extra";
 
-import { CXRootFolder, logInfo } from "./shared";
+import { CXRootDir, instanceRootDir, logInfo } from "./shared";
+// eslint-disable-next-line node/no-unpublished-import
+import config from "../../cx.config";
+
+export const STORE_DIR = path.resolve(__dirname, "../store/");
+export const DIST_DIR = path.resolve(__dirname, "../dist/");
+
+export const gatsbyRootDir = path.resolve(__dirname, "../");
+export const exportArchiveBasePath = path.resolve(
+	instanceRootDir,
+	"exports/sites"
+);
 
 /**
- * Delete sites folders that will be updated from de file system.
+ * Delete sites dirs that will be updated from de file system.
  *
  * @param updateSites An array of sites to be updated.
  */
@@ -21,30 +34,30 @@ async function deleteSites(updatedSites: Array<Site>, DOMAIN: string) {
 				? domainFromSite.split(DOMAIN).join("")
 				: domainFromSite;
 
-			const siteFolder = path.resolve(__dirname, `../public${domainPath}`);
-			const pageDataFolder = path.resolve(
+			const siteDir = path.resolve(__dirname, `../public${domainPath}`);
+			const pageDataDir = path.resolve(
 				__dirname,
 				`../public/page-data${domainPath}`
 			);
 
-			logInfo(`Site dir ${siteFolder}`);
-			logInfo(`Page data dir ${pageDataFolder}`);
+			logInfo(`Site dir ${siteDir}`);
+			logInfo(`Page data dir ${pageDataDir}`);
 
 			// delete directory recursively
-			if (!fs.existsSync(siteFolder)) continue;
+			if (!fs.existsSync(siteDir)) continue;
 
 			try {
-				await fs.rm(siteFolder, { recursive: true });
-				logInfo(`${siteFolder} was deleted!`);
+				await fs.rm(siteDir, { recursive: true });
+				logInfo(`${siteDir} was deleted!`);
 			} catch (err) {
 				console.log(err);
 			}
 
-			if (!fs.existsSync(pageDataFolder)) continue;
+			if (!fs.existsSync(pageDataDir)) continue;
 
 			try {
-				await fs.rm(pageDataFolder, { recursive: true });
-				console.info(`${pageDataFolder} was deleted!`);
+				await fs.rm(pageDataDir, { recursive: true });
+				console.info(`${pageDataDir} was deleted!`);
 			} catch (err) {
 				console.log(err);
 			}
@@ -55,80 +68,260 @@ async function deleteSites(updatedSites: Array<Site>, DOMAIN: string) {
 /**
  * Remove empty site dirst (with or without sitemaps xmls)
  */
-const clearEmptyDirs = (baseFolder?: string) => {
-	const folder = baseFolder || path.resolve(CXRootFolder, "dist");
+const clearEmptyDirs = (baseDir?: string) => {
+	const dir = baseDir || path.resolve(CXRootDir, "dist");
 
-	const isDir = fs.statSync(folder).isDirectory();
+	const isDir = fs.statSync(dir).isDirectory();
 	if (!isDir) {
 		return;
 	}
 
-	// archivos o direvtorios dentro de `folder`
-	let children = fs.readdirSync(folder);
+	// archivos o direvtorios dentro de `dir`
+	let children = fs.readdirSync(dir);
 	// let children = childrenRaw.filter((file) => {
 	// 	return path.extname(file).toLowerCase() !== ".xml";
 	// });
-	const folderHasChildren = children.length > 0;
+	const dirHasChildren = children.length > 0;
 
 	// Por cada uno de ellos miramos si tiene hijos, enviamos cada uno de ellos
 	// a `clearEmptyDirsWithXML`
-	if (folderHasChildren) {
+	if (dirHasChildren) {
 		const childrenCount = children.length;
 		const xmlCount = children.filter((file) => {
 			return path.extname(file).toLowerCase() === ".xml";
 		}).length;
 
 		// Todos los hijos son archivos .xml
-		// Podemos borrarlos y dejar el folder vacío.
+		// Podemos borrarlos y dejar el dir vacío.
 		if (childrenCount === xmlCount) {
 			children.forEach(function (xmlFile) {
-				const fullPath = path.join(folder, xmlFile);
+				const fullPath = path.join(dir, xmlFile);
 				fs.rmSync(fullPath);
 			});
-			children = fs.readdirSync(folder);
+			children = fs.readdirSync(dir);
 		}
 
 		children.forEach(function (file) {
-			const fullPath = path.join(folder, file);
+			const fullPath = path.join(dir, file);
 			clearEmptyDirs(fullPath);
 		});
 
-		// re-evaluate files; after deleting subfolder we may have parent folder
+		// re-evaluate files; after deleting subdir we may have parent dir
 		// empty now...
-		children = fs.readdirSync(folder);
+		children = fs.readdirSync(dir);
 	}
 
 	// Si no tiene hijos, lo borramos
 	if (children.length === 0) {
-		fs.rmdirSync(folder);
+		fs.rmdirSync(dir);
 		return;
 	}
 };
 
-const _clearEmptyDirs = (baseFolder?: string) => {
-	const folder = baseFolder || path.resolve(CXRootFolder, "dist");
+/**
+ * Copy artifacts between CX valid directories.
+ *
+ * @param args.domain - The render domain
+ * @param args.from - Source dir
+ * @param args.to - Destination dir
+ * @param args.artifacts - Artifact names
+ * @param args.withBackup - Create a previous backup
+ */
+async function copyArtifacts(args: {
+	domain: string;
+	from: CXDir;
+	to: CXDir;
+	artifacts: Array<string>;
+	withBackup?: boolean;
+}) {
+	const { artifacts, domain, from, to, withBackup } = args;
+
+	const dirs = config.dirs(domain);
 
-	const isDir = fs.statSync(folder).isDirectory();
-	if (!isDir) {
+	for (const artifact of artifacts) {
+		const src = path.join(dirs[from], artifact);
+		const dest = path.join(dirs[to], artifact);
+
+		// The dir we want to copy, doesn't exist.
+		if (!fs.existsSync(src)) {
+			console.log(`Source directory does not exist: ${src}`);
+			continue;
+		}
+
+		// Create the backup
+		if (withBackup) {
+			createBackup(dest);
+		}
+
+		// Copy artifact
+		try {
+			// First clean destination
+			if (fs.existsSync(dest)) {
+				spawnSync("rm", ["-rf", dest]);
+			}
+			spawnSync("cp", ["-Rp", src, dest]);
+			if (withBackup) {
+				deleteBackup(dest);
+			}
+		} catch (e) {
+			console.log("Copy failed!");
+			if (withBackup) {
+				restoreBackup(dest);
+				console.log("Backup has been restored.");
+			}
+		}
+	}
+}
+
+/**
+ * Move artifacts between CX valid directories.
+ *
+ * @param domain - The render domain
+ * @param from - Source dir
+ * @param to - Destination dir
+ * @param artifacts - Artifact names
+ *
+ * @example
+ * // normal
+ * moveArtifacts({domain: domain, from: "__cx", to: "__ssg", ["dist"]})
+ * // renaming
+ * moveArtifacts({
+ *
+ * 	domain: domain,
+ *  from: "__cx",
+ *	to: "__ssg",
+ * 	["foo", "taz", "bar"],
+ * 	["foo", "taz", "bar-renamed"]
+ *
+ * })
+ * // with backup
+ * moveArtifacts({domain: domain, from: "__cx", to: "__ssg", ["dist"]})
+ */
+function moveArtifacts(args: {
+	domain: string;
+	from: CXDir;
+	to: CXDir;
+	artifacts: Array<string>;
+	withBackup?: boolean;
+}) {
+	const { artifacts, domain, from, to, withBackup } = args;
+
+	const dirs = config.dirs(domain);
+
+	for (const artifact of artifacts) {
+		const src = path.join(dirs[from], artifact);
+		const dest = path.join(dirs[to], artifact);
+
+		// The dir we want to move, doesn't exist.
+		if (!fs.existsSync(src)) {
+			console.log(`Source directory does not exist: ${src}`);
+			continue;
+		}
+
+		if (withBackup) {
+			createBackup(dest);
+		}
+
+		try {
+			// First clean destination
+			if (fs.existsSync(dest)) {
+				spawnSync("rm", ["-rf", dest]);
+			}
+			spawnSync("mv", [src, dest]);
+			if (withBackup) {
+				deleteBackup(dest);
+			}
+		} catch (e) {
+			console.log("Move failed!");
+			if (withBackup) {
+				restoreBackup(dest);
+				console.log("Backup has been restored.");
+			}
+		}
+	}
+}
+
+/**
+ * Remove artifacts from CX valid directories.
+ *
+ * @param domain - The render domain
+ * @param from - Source dir
+ * @param to - Destination dir
+ * @param artifacts - Artifact names
+ *
+ * @example
+ * removeArtifacts(domain, "__cx", "__ssg", ["dist"], ["public"])
+ */
+function removeArtifacts(args: {
+	domain: string;
+	from: CXDir;
+	artifacts: Array<string>;
+}) {
+	const { artifacts, domain, from } = args;
+
+	const dirs = config.dirs(domain);
+
+	for (const artifact of artifacts) {
+		if (artifact) {
+			const src = path.join(dirs[from], artifact);
+			if (fs.existsSync(src)) {
+				spawnSync("rm", ["-rf", src]);
+			}
+		}
+	}
+}
+
+function restoreBackup(src: string, suffix = "-BACKUP") {
+	const dest = src + suffix;
+	try {
+		spawnSync("mv", [dest, src]);
+		console.log(`Backup ${dest} has been restored`);
+	} catch (e) {
+		console.log(`Error while delete ${dest} backup`);
+	}
+}
+
+function deleteBackup(src: string, suffix = "-BACKUP") {
+	const dest = src + suffix;
+
+	if (!fs.existsSync(dest)) {
+		console.log(`Source ${dest} does not exist`);
 		return;
 	}
 
-	let files = fs.readdirSync(folder);
-	if (files.length > 0) {
-		files.forEach(function (file) {
-			const fullPath = path.join(folder, file);
-			_clearEmptyDirs(fullPath);
-		});
+	try {
+		spawnSync("rm", ["-rf", dest]);
+		console.log(`Backup ${dest} has been deleted`);
+	} catch (e) {
+		console.log(`Error while delete ${dest} backup`);
+	}
+}
+
+function createBackup(src: string, suffix = "-BACKUP") {
+	const dest = src + suffix;
 
-		// re-evaluate files; after deleting subfolder
-		// we may have parent folder empty now
-		files = fs.readdirSync(folder);
+	if (!fs.existsSync(src)) {
+		console.log(`Source ${src} does not exist`);
+		return;
 	}
 
-	if (files.length === 0) {
-		fs.rmdirSync(folder);
+	if (fs.existsSync(dest)) {
+		console.log(`Destination ${dest} already exists`);
 		return;
 	}
-};
 
-export { clearEmptyDirs, _clearEmptyDirs, deleteSites };
+	try {
+		spawnSync("mv", [src, dest]);
+		console.log(`Backup of ${src} has been created in ${dest}`);
+	} catch (e) {
+		console.log(`Error while coping ${src} to ${dest} backup`);
+	}
+}
+
+export {
+	clearEmptyDirs,
+	copyArtifacts,
+	deleteSites,
+	moveArtifacts,
+	removeArtifacts,
+};

package/exporter/utils/searches.ts

@@ -103,35 +103,31 @@ function stripSpaces(str: string) {
 }
 
 /**
- * Function that search in the /public folder the content info of the pages and send it to the search table in the ddbb using the API.
+ * Function that search in the `/public` dir the content info of the pages and
+ * send it to the search table in the ddbb using the API.
  */
 async function uploadSearchContentToAPI() {
 	// Extraemos el path de la carpeta store
-	const storeFolder = path.resolve(__dirname, `../store`);
+	const storeDir = path.resolve(__dirname, `../store`);
 	// Convertimos el string que nos devuelve el env en un booleano
-	const isDomainStrippedFromPath: boolean = JSON.parse(process.env.GRIDDO_EXPORT_STRIP_DOMAIN_FROM_PATH || "false");
-
+	const isDomainStrippedFromPath: boolean = JSON.parse(
+		process.env.GRIDDO_EXPORT_STRIP_DOMAIN_FROM_PATH || "false"
+	);
 
-	for await (const store of getBuildPages(storeFolder)) {
-		const { 
-			context: { 
-				page,
-				openGraph
-			} 
+	for await (const store of getBuildPages(storeDir)) {
+		const {
+			context: { page, openGraph },
 		} = store;
 
-		const { 
-			compose, 
-			domain 
-		} = page.fullPath;
+		const { compose, domain } = page.fullPath;
 
-		const contextPath = isDomainStrippedFromPath 
+		const contextPath = isDomainStrippedFromPath
 			? path.resolve(__dirname, `../dist/${compose}/index.html`)
 			: path.resolve(__dirname, `../dist${domain}${compose}/index.html`);
-		
+
 		const content = fs.readFileSync(contextPath).toString();
 
-		const pageObject: PostSearchInfoProps = { 
+		const pageObject: PostSearchInfoProps = {
 			siteId: page.site,
 			pageId: page.id,
 			title: page.title,
@@ -140,7 +136,7 @@ async function uploadSearchContentToAPI() {
 			template: page.template.templateType || page.templateId,
 			description: openGraph.description,
 			image: openGraph.image,
-			content
+			content,
 		};
 
 		await postSearchInfo(pageObject);

package/exporter/utils/shared.ts

@@ -1,4 +1,6 @@
+import type { Adapters } from "../adapters";
 import type { APIResponses } from "../types/api";
+import type { LifeCyclesNames } from "../types/global";
 import type { APIPageObject } from "../types/pages";
 import type { Site } from "../types/sites";
 
@@ -9,7 +11,6 @@ import gradient from "gradient-string";
 import pkgDir from "pkg-dir";
 
 import { version } from "../../package.json";
-import { Adapters } from "../adapters";
 
 dotenv.config();
 
@@ -20,8 +21,8 @@ const GRIDDO_BUILD_LOGS =
 	(!!process.env.GRIDDO_BUILD_LOGS &&
 		!!JSON.parse(process.env.GRIDDO_BUILD_LOGS)) ||
 	(!!process.env.LOGS && !!JSON.parse(process.env.LOGS));
-const CXRootFolder = pkgDir.sync(__dirname)!; // usually monorepo/packages/griddo-cx/
-const instanceRootFolder = pkgDir.sync()!; // instace root folder
+const CXRootDir = pkgDir.sync(__dirname)!; // usually monorepo/packages/griddo-cx/
+const instanceRootDir = pkgDir.sync()!; // instance root dir
 
 /**
  * Walk a directory and returns the file pathts.
@@ -183,28 +184,12 @@ function siteList(sites: Array<Site>) {
 	return sites.map(({ name, id }) => `${name} (${id})`).join(", ");
 }
 
-/**
- * Print a f**king great Griddo build domain logo.
- */
-function splash() {
-	const logo = `
- ___  _  _ _ _    ___  ___  ____ _  _ ____ _ __ _
- |==] |__| | |___ |__> |__> [__] |\\/| |--| | | \\|
-`;
-
-	console.log(gradient.cristal(logo));
-}
-
 /**
  * Print the great Griddo Exporter logo in ASCII.
  */
 function printExporterLogo(adapter: Adapters) {
 	const logo = `
 ··
-··      _______ _     _  _____   _____   ______ _______ _______  ______
-··      |______  \\___/  |_____] |     | |_____/    |    |______ |_____/
-··      |______ _/   \\_ |       |_____| |    \\_    |    |______ |    \\_
-··
 ··      Griddo Exporter ${version}
 ··      Adapter: ${adapter}
 ··
@@ -214,14 +199,14 @@ function printExporterLogo(adapter: Adapters) {
 }
 
 /**
- * Remove unused files (old) inside the `apiCache` folder
+ * Remove unused files (old) inside the `apiCache` dir
  *
- * @param folderPath The path for the `apiCache` folder
+ * @param dirPath The path for the `apiCache` dir
  * @todo remove other file types: sites, socials, etc..
  */
-function sanitizeAPICacheFolder(folderPath: string) {
+function sanitizeAPICacheDir(dirPath: string) {
 	// Read all `apiCache` file paths
-	const allCachedFiles = fs.readdirSync(folderPath);
+	const allCachedFiles = fs.readdirSync(dirPath);
 
 	// Object to store the the more rencent file names
 	// Record<string, string> = { "234856872634", "3268746238747238.json"};
@@ -231,7 +216,7 @@ function sanitizeAPICacheFolder(folderPath: string) {
 	// Page files.
 	// We only need files that describes a page object.
 	const pageFilePaths = allCachedFiles.filter((fileName) => {
-		const filePath = `${folderPath}/${fileName}`;
+		const filePath = `${dirPath}/${fileName}`;
 		const fileObject = fs.readJSONSync(filePath, "utf-8") as APIPageObject;
 		const { id, entity, fullUrl } = fileObject;
 
@@ -241,7 +226,7 @@ function sanitizeAPICacheFolder(folderPath: string) {
 
 	// Fill the filesById object
 	for (const fileName of pageFilePaths) {
-		const filePath = `${folderPath}/${fileName}`;
+		const filePath = `${dirPath}/${fileName}`;
 		const fileObject = fs.readJSONSync(filePath, "utf-8") as APIPageObject;
 		const fileCreationDate = fs.statSync(filePath).mtimeMs;
 
@@ -251,8 +236,7 @@ function sanitizeAPICacheFolder(folderPath: string) {
 		// that the stored one.
 		const validPageFile =
 			!filesByIdMap[id] ||
-			fileCreationDate >
-				fs.statSync(`${folderPath}/${filesByIdMap[id]}`).mtimeMs;
+			fileCreationDate > fs.statSync(`${dirPath}/${filesByIdMap[id]}`).mtimeMs;
 
 		if (validPageFile) filesByIdMap[id] = fileName;
 	}
@@ -262,7 +246,7 @@ function sanitizeAPICacheFolder(folderPath: string) {
 
 	// Delete files using the store object filesById as reference map.
 	for (const fileName of pageFilePaths) {
-		const filePath = `${folderPath}/${fileName}`;
+		const filePath = `${dirPath}/${fileName}`;
 		const fileObject = fs.readJSONSync(filePath, "utf-8") as APIPageObject;
 
 		const { id } = fileObject;
@@ -274,7 +258,7 @@ function sanitizeAPICacheFolder(folderPath: string) {
 		}
 	}
 
-	console.log(`Sanitize apiCache folder for ${counter} files`);
+	console.log(`Sanitize apiCache dir for ${counter} files`);
 }
 
 /**
@@ -324,11 +308,53 @@ function successLifeCyle(value: string) {
 	console.info(`${chalk.green("success")} ${value}`);
 }
 
+/**
+ * Executes a life cycle process, which involves executing an array of
+ * functions, printing to the console, and handling errors with optional
+ * retries.
+ *
+ * @async
+ * @param args - The arguments object.
+ * @param args.steps - An array of functions to execute.
+ * @param args.name - The name of the life cycle.
+ * @param [args.attempts=1] - The number of retry attempts allowed in case of errors.
+ * @returns - A promise that resolves when the life cycle process is completed.
+ */
+async function doLifeCycle(args: {
+	steps: Array<(...args: Array<unknown>) => unknown | Promise<any>>;
+	name: LifeCyclesNames;
+	attempts?: number;
+}) {
+	const { steps, name, attempts } = args;
+	let trysCount = 0;
+	const maxTrysAccepted =
+		Number(process.env.GRIDDO_LIFECYCLE_MAX_RETRY_ATTEMPTS) || attempts || 1;
+
+	while (trysCount < maxTrysAccepted) {
+		try {
+			console.info(`\n${chalk.blue(`info`)} start ${name} life-cycle`);
+			const exeTime = await measureExecutionTime(...steps);
+			console.info(`${chalk.green("success")} ${name} - ${exeTime}s`);
+			// if no errors, go out!! :)
+			break;
+		} catch (error) {
+			console.log(`Error in ${name}. Attempt (${trysCount + 1})`);
+			trysCount++;
+		}
+	}
+	if (trysCount === maxTrysAccepted) {
+		throw new Error(
+			`Exceeded maximum retry attempts (${maxTrysAccepted}) for ${name} LifeCycle`
+		);
+	}
+}
+
 export {
-	CXRootFolder,
+	CXRootDir,
 	debug,
 	delay,
-	instanceRootFolder,
+	doLifeCycle,
+	instanceRootDir,
 	logBox,
 	logInfo,
 	logPageSize,
@@ -336,9 +362,8 @@ export {
 	pause,
 	printExporterLogo,
 	removeProperties,
-	sanitizeAPICacheFolder,
+	sanitizeAPICacheDir,
 	siteList,
-	splash,
 	startLifeCycle,
 	successLifeCyle,
 	walk,

package/exporter/utils/sites.ts

@@ -56,15 +56,18 @@ async function checkSites(domain: string) {
 
 	// If there are valid sites...
 	if (validSites.length) {
-		const promisesOfValidSites = validSites.map(async (site) => {
-			const langResponse = await SitesService.getLanguages(site.id);
-
-			return (site.domains = langResponse.items
-				.filter((item) => item.domain && item.domain.slug.indexOf(domain) > 0)
-				.map((item) => ({ [item.id]: `${item.domain.slug}${item.path}` })));
-		});
-
-		await Promise.all(promisesOfValidSites);
+		for (const site of validSites) {
+			const { items } = await SitesService.getLanguages(site.id);
+
+			// Añadimos la prop domains con el dominio "cocinado" con los idiomas y teniendo en cuenta solo el dominio actual
+			site.domains = items
+				.filter(
+					(item) =>
+						item.domain &&
+						(item.domain.slug === domain || item.domain.slug === `/${domain}`)
+				)
+				.map((item) => ({ [item.id]: `${item.domain.slug}${item.path}` }));
+		}
 	}
 
 	// Save sites object to publish