@griddo/cx 11.9.9-rc.0 → 11.9.9-rc.1

package/exporter/services/store.ts

@@ -1,181 +1,102 @@
-import type { BuildProcessData, Settings } from "../shared/types/global";
+import type { BuildProcessData } from "../types/global";
 import type {
 	GriddoListPage,
 	GriddoMultiPage,
 	GriddoPageObject,
 	GriddoSinglePage,
 	PageAdditionalInfo,
-} from "../shared/types/pages";
-import type { HashSites, Site, SiteHash } from "../shared/types/sites";
+} from "../types/pages";
 
-import fsp from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
 
 import pLimit from "p-limit";
 
-import { GriddoLog } from "../core/GriddoLog";
-import { SETTINGS } from "../shared/endpoints";
-import {
-	GRIDDO_API_CONCURRENCY_COUNT,
-	GRIDDO_API_URL,
-	GRIDDO_PUBLIC_API_URL,
-	GRIDDO_REACT_APP_INSTANCE,
-} from "../shared/envs";
-import { brush } from "../shared/npm-modules/brush";
-import { RENDER_MODE, type RenderMode } from "../shared/types/render";
-import { get } from "./api";
-import { getSiteData, getSitesToRender, unpublishSites } from "./manage-sites";
-import { removeOrphanSites, saveRenderInfoInStore, saveSitePagesInStore } from "./manage-store";
+import { envs } from "../constants";
 import { NavigationService } from "./navigation";
+import { getReferenceFieldData } from "./reference-fields";
+import { getAllSettings } from "./settings";
+import { getPage } from "./sites";
+import { updatedSiteHash } from "../utils/cache";
+import { getConfig, removeAllSiteDirsFromStore } from "../utils/core-utils";
+import { buildLog, listSitesLog } from "../utils/loggin";
 import {
 	createGriddoListPages,
 	createGriddoMultiPages,
 	createGriddoSinglePage,
 	getMultiPageElements,
 	getPaginatedPages,
-} from "./pages";
-import { getReferenceFieldData } from "./reference-fields";
-import { getRenderPathsHydratedWithDomainFromDB } from "./render";
-import { getPage } from "./sites";
-
-const renderId = Date.now().toString();
-
-function guessSiteNeedsToBeRenderedFromScratch() {
-	return false;
-}
-
-function listSitesLog(title: string, sites: Site[]) {
-	const maxline = Math.max(
-		...sites.map((s) => s.name.length + (s.shouldBeUpdated ? 1 : 0) + s.id.toString().length),
-	);
-
-	const sitesStr = sites.map((s) => {
-		const shouldBeUpdated = s.shouldBeUpdated ? "*" : "";
-		const lineLen = s.name.length + shouldBeUpdated.length + s.id.toString().length;
-		const padding = " ".repeat(maxline - lineLen);
-		return `${brush.bold(s.name)} ${brush.dim(`(${s.id})`)} ${shouldBeUpdated} ${padding}${brush.dim("-")} ${brush.dim(s.slug)}`;
-	});
-
-	const sitesOutput = sitesStr.length > 0 ? `\n\n${sitesStr.join("\n")}` : brush.dim("--none--\n");
-
-	GriddoLog.log(`
-${title} ${sitesOutput}`);
-}
+} from "../utils/pages";
+import { getSiteData, getSitesToRender, unpublishSites } from "../utils/sites";
+import {
+	getMissingPublishedPagesInStore,
+	getZombiePagesInStore,
+	removeOrphanSites,
+	removeSitePagesFromStore,
+	saveRenderInfoInStore,
+	saveSitePagesInStore,
+} from "../utils/store";
+
+const renderId = new Date().valueOf().toString();
+const { griddoVersion, paths } = getConfig();
+const { __cx } = paths();
+const storeDir = path.join(__cx, "store");
 
 /**
  * Fetch, process and save object pages and sites data into the file system to
  * be consumed by other services (Griddo itself, Adapters, etc.)
  */
-async function createStore(options: {
-	domain: string;
-	renderMode: RenderMode;
-	griddoVersion: string;
-	basePath: string;
-}) {
-	console.info(`API calls with ${GRIDDO_API_CONCURRENCY_COUNT} threads`);
-	console.info(`API URL ${GRIDDO_API_URL as string}`);
-
-	const { renderMode, domain, griddoVersion, basePath } = options;
-	const renderFromScratch = renderMode === RENDER_MODE.FROM_SCRATCH;
-	const storeDir = path.join(basePath, "store");
-
-	// Vars to save later in the report file
-	const createdPages: number[] = [];
-	const buildProcessData: BuildProcessData = {};
-
-	// Get sites objects to publish and unpublish from this domain
-	const { sitesToPublish, sitesToUnpublish } = await getSitesToRender(domain);
-
-	listSitesLog("Sites to publish:", sitesToPublish);
-	listSitesLog("Sites to unpublish:", sitesToUnpublish);
-
-	// Send unpublished sites to API.
-	await unpublishSites(sitesToUnpublish);
-
-	// Eliminamos posibles sites que estén en el store pero que no deberían
-	// porque han sido cambiados de dominio. Si han sido despublicados ya se
-	// despublican bien porque entran en `sitesToUnpublish`
-	await removeOrphanSites(sitesToPublish, domain);
-
-	const allPagesToRemoveFromBuild: number[] = [];
-	// let numberOfFinalActivePages: number[] = [];
-
-	for (const site of sitesToUnpublish) {
-		const { pagesStatus } = site;
-
-		// Añadimos a allPagesToRemoveFromBuild todas las páginas de un site
-		// para despublicar.
-		allPagesToRemoveFromBuild.push(
-			...pagesStatus.active,
-			...pagesStatus.offlinePending,
-			...pagesStatus.uploadPending,
-			...pagesStatus.deleted,
-			...pagesStatus.offline,
-		);
-	}
+async function createStore(domain: string) {
+	console.info(`API calls with ${envs.GRIDDO_API_CONCURRENCY_COUNT} threads`);
+	console.info(`API URL ${envs.GRIDDO_API_URL as string}`);
 
-	for (const site of sitesToPublish) {
-		const { id: siteId, slug: siteSlug, theme, favicon, pagesStatus } = site;
-		const siteDirName = siteId.toString();
-
-		allPagesToRemoveFromBuild.push(...pagesStatus.offlinePending, ...pagesStatus.deleted);
-
-		const {
-			siteInfo,
-			siteHash,
-			unpublishHashes,
-			siteLangs,
-			defaultLang,
-			headers,
-			footers,
-			socials,
-		} = await getSiteData(siteId);
-
-		const {
-			cloudinaryName,
-			useMetaTitle,
-			useMetaKeywords,
-			showBasicMetaRobots,
-			avoidHrefLangsOnCanonicals,
-			avoidSelfReferenceCanonicals,
-			avoidHrefLangXDefault,
-			avoidDebugMetas,
-		} = await get<Settings>({ endpoint: SETTINGS });
-
-		buildProcessData[siteId] = {
-			siteHash,
-			unpublishHashes,
-			publishHashes: [],
-			publishPagesIds: [],
-		};
-
-		const NavService = new NavigationService();
-		NavService.navigations = { headers, footers };
-
-		site.languages = siteLangs;
-
-		const shouldUpdateSite = await updatedSiteHash(siteId, siteHash);
-
-		const siteScript = siteInfo.siteScript;
-
-		const siteMetadata = {
-			siteUrl: siteInfo.slug,
-			title: siteInfo.name,
-			favicon,
-		};
-
-		const additionalInfo = {
-			baseUrl: GRIDDO_API_URL,
-			publicBaseUrl: GRIDDO_PUBLIC_API_URL,
-			instance: GRIDDO_REACT_APP_INSTANCE,
-			siteSlug,
-			theme,
-			siteMetadata,
-			socials,
-			siteLangs,
-			cloudinaryName,
-			griddoVersion,
-			siteOptions: {
+	try {
+		// Vars to save later in the report file
+		const createdPages: Array<number> = [];
+		const buildProcessData: BuildProcessData = {};
+
+		// Get sites objects to publish and unpublish from this domain
+		const { sitesToPublish, sitesToUnpublish } = await getSitesToRender(domain);
+
+		const domainHasSites =
+			sitesToPublish.length > 0 || sitesToUnpublish.length > 0;
+
+		if (!domainHasSites) {
+			console.warn(`There are no sites to update in the domain ${domain}`);
+		}
+
+		listSitesLog("Sites to publish:", sitesToPublish);
+		listSitesLog("Sites to unpublish:", sitesToUnpublish);
+
+		// Send unpublished sites to API.
+		// @todo ¿mover esta llamada al final del proceso de render?
+		// Aquí también se están eliminado físicamente los archivos json del
+		// store de los sites para despublicar.
+		await unpublishSites(sitesToUnpublish);
+
+		// Eliminamos posibles sites que estén en el store pero que no deberían
+		// porque han sido cambiados de dominio. Si han sido despublicados ya se
+		// despublican bien porque entran en `sitesToUnpublish`
+		removeOrphanSites(sitesToPublish, domain);
+
+		// Solo los sites to publish...
+		for (const site of sitesToPublish) {
+			const { id: siteId, slug: siteSlug, theme, favicon, pagesStatus } = site;
+			const siteDirName = siteId.toString();
+
+			const {
+				siteInfo,
+				siteHash,
+				unpublishHashes,
+				siteLangs,
+				defaultLang,
+				headers,
+				footers,
+				socials,
+			} = await getSiteData(siteId);
+
+			const {
+				cloudinaryName,
 				useMetaTitle,
 				useMetaKeywords,
 				showBasicMetaRobots,
@@ -183,211 +104,257 @@ async function createStore(options: {
 				avoidSelfReferenceCanonicals,
 				avoidHrefLangXDefault,
 				avoidDebugMetas,
-			},
-			siteScript,
-		};
-
-		GriddoLog.info(`Getting pages from ${site.name} site`);
-
-		/// Creates the store directory for each site using the id
-		await fsp.mkdir(path.join(storeDir, siteDirName), {
-			recursive: true,
-		});
-
-		// -------------------------------------------------------------------------
-		// Pages loop promise creation
-		// -------------------------------------------------------------------------
-		// Async function that process every page for one site to use later in the
-		// `Promise.all` with pLimit.
-		const fetchSitePageAndSaveInStore = async (siteIdName: string, pageId: number) => {
-			// Here will be store every page returned by the API and processed
-			let griddoPageObjects: GriddoPageObject[] = [];
-
-			// Get page data
-			const page = await getPage(pageId, shouldUpdateSite);
-
-			// Probably a 404
-			if (!page) {
-				return;
-			}
-
-			// Update Array of page ids
-			createdPages.push(pageId);
-
-			// TODO: Use structuredClone() when node 18 is available.
-			// SHAME: This new pageAdditionalInfo needs to be a copy because
-			// additionalInfo referenced from outside this function and
-			// its used by other pages.
-			const pageAdditionalInfo = JSON.parse(JSON.stringify(additionalInfo)) as PageAdditionalInfo;
-
-			// Updated with navigations (header & footer)
-			pageAdditionalInfo.navigations = NavService.getPageNavigations(page);
-
-			// Content Type Data Query.
-			// Where the pair `hasDistributorData:true` /
-			// `getStaticData:true` and `data` prop exists, this function
-			// will attach a `queriedItems` prop with the result of the
-			// fetch for the data.
-			const template = await getReferenceFieldData({
-				page,
-				cacheKey: renderId,
+			} = await getAllSettings();
+
+			buildProcessData[siteId] = {
+				siteHash,
+				unpublishHashes,
+				publishHashes: [],
+				publishPagesIds: [],
+			};
+
+			const NavService = new NavigationService();
+			NavService.navigations = { headers, footers };
+
+			site.languages = siteLangs;
+
+			const shouldUpdateSite = updatedSiteHash(siteId, siteHash);
+
+			const siteScript = siteInfo.siteScript;
+
+			const siteMetadata = {
+				siteUrl: siteInfo.slug,
+				title: siteInfo.name,
+				favicon,
+			};
+
+			const additionalInfo = {
+				baseUrl: envs.GRIDDO_API_URL,
+				publicBaseUrl: envs.GRIDDO_PUBLIC_API_URL,
+				instance: envs.GRIDDO_REACT_APP_INSTANCE,
+				siteSlug,
+				theme,
+				siteMetadata,
+				socials,
+				siteLangs,
+				cloudinaryName,
+				griddoVersion,
+				siteOptions: {
+					useMetaTitle,
+					useMetaKeywords,
+					showBasicMetaRobots,
+					avoidHrefLangsOnCanonicals,
+					avoidSelfReferenceCanonicals,
+					avoidHrefLangXDefault,
+					avoidDebugMetas,
+				},
+				siteScript,
+			};
+
+			buildLog(`${site.name} site`);
+
+			/// Creates the store directory for each site using the id
+			fs.mkdirSync(path.join(storeDir, siteDirName), {
+				recursive: true,
 			});
 
-			// MultiPage Query
-			// Where the pair `hasGriddoMultiPage:true` prop exists, this function
-			// will process the schema and return a multiPageElemtens array to use
-			// in `createGriddoMultiPages()`
-			const multiPageElements = await getMultiPageElements(template);
-
-			// -----------------------------------------------------------------------
-			// Build Griddo page objects.
-			// -----------------------------------------------------------------------
-			// A page from the API could be one of those:
-			// - List with pagination (static list template): needs to be splitted in n pages
-			// - Multi-page module: needs to be splitted in n pages
-			// - Single: just one page
-
-			// Griddo page types
-			const isStaticListPage = page?.mode === "list" || page?.mode === "paginated-data";
-			const isMultiPage = !isStaticListPage && multiPageElements;
-			const isSinglePage = !isMultiPage && !isStaticListPage;
-
-			// >> List (static list template) <<
-			if (isStaticListPage) {
-				const griddoListPage = {
-					page: page,
-					pages: getPaginatedPages(template),
-					isRoot: false,
-					defaultLang: defaultLang,
-					template: template,
-					totalQueriedItems: template.queriedItems,
-				} as GriddoListPage;
-
-				// pageObjects = await createGriddoListPages({ adapter: "Gatsby" })
-				griddoPageObjects = await createGriddoListPages(griddoListPage, pageAdditionalInfo);
-
-				// ¿Por qué la añadimos a las páginas para borrar?
-				// Porque este tipo de páginas no está manejada por API y se crean varias páginas con el mismo ID.
-				// Esto hace que no se pueda rastrear bien el render.
-				allPagesToRemoveFromBuild.push(page.id);
-			}
-
-			// >> Multi-page <<
-			if (isMultiPage) {
-				const griddoMultipage = page as GriddoMultiPage;
-
-				// The `template` key with the (maybe) data (ReferenceField) items queried
-				griddoMultipage.template = template;
-				griddoMultipage.multiPageElements = multiPageElements;
-				griddoMultipage.defaultLang = defaultLang;
-
-				griddoPageObjects = await createGriddoMultiPages(griddoMultipage, pageAdditionalInfo);
-
-				// ¿Por qué la añadimos a las páginas para borrar?
-				// Porque este tipo de páginas no está manejada por API y se crean varias páginas con el mismo ID.
-				// Esto hace que no se pueda rastrear bien el render.
-				allPagesToRemoveFromBuild.push(page.id);
-			}
-
-			// >> Single template <<
-			if (isSinglePage) {
-				const griddoSinglePage = page as GriddoSinglePage;
-
-				// The `template` key with the (maybe) data (ReferenceField) items queried
-				griddoSinglePage.template = template;
-				griddoSinglePage.defaultLang = defaultLang;
-
-				griddoPageObjects = [await createGriddoSinglePage(griddoSinglePage, pageAdditionalInfo)];
-			}
-
-			// Upload only the valid pages hashes or ids of pages that has
-			// been changed or created.
-			if (page.hash !== null) {
-				buildProcessData[siteId].publishHashes.push(page.hash);
-				buildProcessData[siteId].publishPagesIds.push(page.id);
-			}
-
-			// Save build data to store
-			await saveSitePagesInStore(siteIdName, griddoPageObjects);
-		};
-
-		// Pages that needs to be fetched from the API and written to the store.
-		const pagesToFetchFromAPI = pagesStatus.uploadPending;
-
-		// Esto es necesario porque en la BBDD las páginas pueden estar
-		// marcadas como activas (online) pero si es una máquina nueva hace
-		// falta hacerlas de nuevo...
-		// const sitePendingOfPublishing = site.isPublished && site.shouldBeUpdated;
-		const sitePendingOfPublishing = guessSiteNeedsToBeRenderedFromScratch();
-		// @todo: necesito tener un sistema par publicar todo de un site (cuando un site esté pending to publish)
-		// algo como site.status = pending | published | unpublished...
-		if (renderFromScratch || sitePendingOfPublishing) {
-			pagesToFetchFromAPI.push(...pagesStatus.active);
+			// -------------------------------------------------------------------------
+			// Pages loop promise creation
+			// -------------------------------------------------------------------------
+			// Async function that process every page for one site to use later in the
+			// `Promise.all` with pLimit.
+			const fetchSitePageAndSaveInStore = async (
+				siteIdName: string,
+				pageId: number,
+			) => {
+				// Here will be store every page returned by the API and processed
+				let griddoPageObjects: Array<GriddoPageObject> = [];
+
+				// Get page data
+				const page = await getPage(pageId, shouldUpdateSite);
+
+				// Probably a 404
+				if (!page) {
+					return;
+				}
+
+				// Update Array of page ids
+				createdPages.push(pageId);
+
+				// TODO: Use structuredClone() when node 18 is available.
+				// SHAME: This new pageAdditionalInfo needs to be a copy because
+				// additionalInfo referenced from outside this function and
+				// its used by other pages.
+				const pageAdditionalInfo = JSON.parse(
+					JSON.stringify(additionalInfo),
+				) as PageAdditionalInfo;
+
+				// Updated with navigations (header & footer)
+				pageAdditionalInfo.navigations = NavService.getPageNavigations(page);
+
+				// Content Type Data Query.
+				// Where the pair `hasDistributorData:true` /
+				// `getStaticData:true` and `data` prop exists, this function
+				// will attach a `queriedItems` prop with the result of the
+				// fetch for the data.
+				const template = await getReferenceFieldData({
+					page,
+					cacheKey: renderId,
+				});
+
+				// MultiPage Query
+				// Where the pair `hasGriddoMultiPage:true` prop exists, this function
+				// will process the schema and return a multiPageElemtens array to use
+				// in `createGriddoMultiPages()`
+				const multiPageElements = await getMultiPageElements(template);
+
+				// -----------------------------------------------------------------------
+				// Build Griddo page objects.
+				// -----------------------------------------------------------------------
+				// A page from the API could be one of those:
+				// - List with pagination (static list template): needs to be splitted in n pages
+				// - Multi-page module: needs to be splitted in n pages
+				// - Single: just one page
+
+				// Griddo page types
+				const isStaticListPage =
+					page?.mode === "list" || page?.mode === "paginated-data";
+				const isMultiPage = !isStaticListPage && multiPageElements;
+				const isSinglePage = !isMultiPage && !isStaticListPage;
+
+				// >> List (static list template) <<
+				if (isStaticListPage) {
+					const griddoListPage = {
+						page: page,
+						pages: getPaginatedPages(template),
+						isRoot: false,
+						defaultLang: defaultLang,
+						template: template,
+						totalQueriedItems: template.queriedItems,
+					} as GriddoListPage;
+
+					// pageObjects = await createGriddoListPages({ adapter: "Gatsby" })
+					griddoPageObjects = await createGriddoListPages(
+						griddoListPage,
+						pageAdditionalInfo,
+					);
+				}
+
+				// >> Multi-page <<
+				if (isMultiPage) {
+					const griddoMultipage = page as GriddoMultiPage;
+
+					// The `template` key with the (maybe) data (ReferenceField) items queried
+					griddoMultipage.template = template;
+					griddoMultipage.multiPageElements = multiPageElements;
+					griddoMultipage.defaultLang = defaultLang;
+
+					griddoPageObjects = await createGriddoMultiPages(
+						griddoMultipage,
+						pageAdditionalInfo,
+					);
+				}
+
+				// >> Single template <<
+				if (isSinglePage) {
+					const griddoSinglePage = page as GriddoSinglePage;
+
+					// The `template` key with the (maybe) data (ReferenceField) items queried
+					griddoSinglePage.template = template;
+					griddoSinglePage.defaultLang = defaultLang;
+
+					griddoPageObjects = [
+						await createGriddoSinglePage(griddoSinglePage, pageAdditionalInfo),
+					];
+				}
+
+				// Upload only the valid pages hashes or ids of pages that has
+				// been changed or created.
+				if (page.hash !== null) {
+					buildProcessData[siteId].publishHashes.push(page.hash);
+					buildProcessData[siteId].publishPagesIds.push(page.id);
+				}
+
+				// Save build data to store
+				saveSitePagesInStore(siteIdName, griddoPageObjects);
+			};
+
+			// Pages that needs to be fetched from the API and written to the
+			// store.
+			const pagesToFetchFromAPI = [
+				// These pages are news or has been updated.
+				...pagesStatus.uploadPending,
+				// You should take into account the pages that, even though they are
+				// already published and therefore should be avoided from requesting
+				// them to the API, are not in the store, probably due to a failed
+				// render. In that case, you have to request them again from the API
+				// to include them in the store.
+				...getMissingPublishedPagesInStore(siteDirName, pagesStatus.active),
+			];
+
+			// Create pages to the store. First requesting from API,
+			// transform, etc., and then writing them to disk.
+			const limit = pLimit(envs.GRIDDO_API_CONCURRENCY_COUNT);
+			const pagesToStore = pagesToFetchFromAPI.map((id: number) =>
+				limit(() => fetchSitePageAndSaveInStore(siteDirName, id)),
+			);
+
+			await Promise.all(pagesToStore);
+
+			// @ts-expect-error Mutate pagesStatus for reading pourposes.
+			pagesStatus.zombie = getZombiePagesInStore(siteDirName, [
+				...pagesStatus.active,
+				...pagesStatus.uploadPending,
+			]);
+
+			// Delete pages from the store removing them from disk.
+			removeSitePagesFromStore(siteDirName, [
+				pagesStatus.deleted,
+				pagesStatus.offline,
+				pagesStatus.offlinePending,
+				// @ts-expect-error Mutate pagesStatus for reading pourposes.
+				pagesStatus.zombie,
+			]);
 		}
 
-		// Create pages to the store. First requesting from API,
-		// transform, etc., and then writing them to disk.
-		const limit = pLimit(GRIDDO_API_CONCURRENCY_COUNT);
-		const pagesToStore = pagesToFetchFromAPI.map((id: number) =>
-			limit(() => fetchSitePageAndSaveInStore(siteDirName, id)),
-		);
-
-		await Promise.all(pagesToStore);
-	}
-
-	// Después de guardar en el store todos los sites y sus páginas (las que
-	// sean que hayan cambiado etc.) guardamos un archivo con la información del
-	// render para usos posteriores.
-	// Render de dominios con sites para publicar o despublicar. Se guarda la
-	// infor del render normalmente.
-	await saveRenderInfoInStore({ buildProcessData, createdPages, sitesToPublish }, domain);
-
-	return {
-		pagesToCreate: createdPages,
-		pagesToDelete: allPagesToRemoveFromBuild,
-	};
-}
-
-/**
- * Get site hashes from the file as an object
- */
-async function getHashSites(): Promise<HashSites> {
-	const { __root } = await getRenderPathsHydratedWithDomainFromDB();
-	const apiCacheDir = path.join(__root, "apiCache");
-	const siteHasFilename = `${apiCacheDir}/siteHash.json`;
-
-	try {
-		const fileContent = await fsp.readFile(siteHasFilename, "utf8");
-		const jsonData = JSON.parse(fileContent);
-		return jsonData || {};
-	} catch {
-		return {};
-	}
-}
-
-/**
- * Update (write) the site hash file.
- *
- * @param siteId The id of the site.
- * @param siteHash The has of the site.
- */
-async function updatedSiteHash(siteId: number, siteHash: SiteHash) {
-	const allHash = await getHashSites();
-	const lastHash = allHash[siteId];
-	const currentHash = siteHash || lastHash || Date.now();
-
-	const { __root } = await getRenderPathsHydratedWithDomainFromDB();
-	const apiCacheDir = path.join(__root, "apiCache");
-	const siteHasFilename = `${apiCacheDir}/siteHash.json`;
-
-	if (currentHash !== lastHash) {
-		allHash[siteId] = currentHash;
-		await fsp.writeFile(siteHasFilename, JSON.stringify(allHash), {
-			encoding: "utf-8",
-		});
+		// Después de guardar en el store todos los sites y sus páginas (las que
+		// sean que hayan cambiado etc.) guardamos un archivo con la información
+		// del render para usos posteriores.
+
+		// Tenemos dos casos:
+
+		// ( 1 ) - Render de dominios con sites para publicar o despublicar. Se
+		// guarda la infor del render normalmente.
+
+		// ( 2 ) - Render de un dominio que no tiene sites ni para publicar ni para
+		// despublicar, lo que llamamos un dominio "vacío".
+		// Entonces se eliminan las páginas "huérfanas" de la carpeta `store`
+		// así el proceso de SSG se encontrará efectivamente con un dominio "sin
+		// páginas" y "borrará" lo que exista en ese momento en el store para
+		// ese dominio y se guarda la información del render con arrays vacíos
+		// directamente en `createdPages` y `sitesToPublish`.
+
+		if (domainHasSites) {
+			// ( 1 )
+			saveRenderInfoInStore({
+				buildProcessData,
+				createdPages,
+				sitesToPublish,
+			});
+		} else {
+			// ( 2 )
+			removeAllSiteDirsFromStore();
+			saveRenderInfoInStore({
+				buildProcessData,
+				createdPages: [],
+				sitesToPublish: [],
+			});
+		}
+	} catch (e) {
+		const error = e as { message: string };
+		console.error(error.message);
+		process.exit(1);
 	}
-
-	return currentHash.toString();
 }
 
 export { createStore };