@griddo/cx 11.7.10 → 11.7.12-rc.0

package/exporter/services/reference-fields.ts

@@ -1,9 +1,9 @@
+import type { Core, Fields } from "@griddo/core";
 import type { FetchDataProps } from "../types/global";
 import type { APIPageObject } from "../types/pages";
-import type { Core, Fields } from "@griddo/core";
 
-import { getReferenceFieldSiteData } from "./sites";
 import { boxLog } from "../utils/loggin";
+import { getReferenceFieldSiteData } from "./sites";
 
 /**
  * Get the body data from a ReferenceField.
@@ -54,9 +54,7 @@ function getBody(data: Fields.Reference<unknown>, page: Core.Page) {
 		};
 	}
 
-	console.log(
-		`Error: ReferenceField mode: ${mode} is not recognized on page ${page?.id}.`,
-	);
+	console.log(`Error: ReferenceField mode: ${mode} is not recognized on page ${page?.id}.`);
 
 	return data;
 }
@@ -71,11 +69,8 @@ function getBody(data: Fields.Reference<unknown>, page: Core.Page) {
  * @returns The ContentType data.
  */
 async function fetchContentTypeData(props: FetchDataProps) {
-	const {
-		page,
-		component: { data },
-		cacheKey,
-	} = props;
+	const { page, component, cacheKey } = props;
+	const { data } = component;
 
 	// Distrubutor with `hasDistributorData: true` / `getStaticData: true` but without `data` prop
 	if (!data) {
@@ -109,13 +104,7 @@ async function fetchContentTypeData(props: FetchDataProps) {
 
 	const body = getBody(data, page);
 
-	const response = await getReferenceFieldSiteData(
-		page,
-		body,
-		cacheKey,
-		site,
-		lang,
-	);
+	const response = await getReferenceFieldSiteData(page, body, cacheKey, site, lang);
 
 	return response;
 }
@@ -165,10 +154,7 @@ async function getReferenceFieldData({
 					continue;
 				}
 
-				const _key = key as
-					| "hasDistributorData"
-					| "queriedItems"
-					| "getStaticData";
+				const _key = key as "hasDistributorData" | "queriedItems" | "getStaticData";
 				const component = templateChunk[_key] as unknown as {
 					data: Fields.Reference<unknown>;
 					queriedItems: Fields.QueriedData<unknown>;
@@ -181,8 +167,7 @@ async function getReferenceFieldData({
 					continue;
 				}
 
-				const componentHasRequestForData =
-					component.hasDistributorData || component.getStaticData;
+				const componentHasRequestForData = component.hasDistributorData || component.getStaticData;
 
 				if (componentHasRequestForData) {
 					component.queriedItems = await fetchContentTypeData({
@@ -210,7 +195,7 @@ async function getReferenceFieldData({
 	} catch (err) {
 		console.error(`Error in getReferenceFieldData ${err}`);
 
-		process.exit(1);
+		throw err;
 	}
 }
 

package/exporter/services/robots.ts

@@ -1,18 +1,14 @@
 import type { Robots } from "../types/global";
 
-import fs from "node:fs";
+import fsp from "node:fs/promises";
 import path from "node:path";
 
-import { endpoints } from "../constants";
+import { ROBOTS } from "../constants/endpoints";
 import { get } from "../utils/api";
-import { getConfig } from "../utils/core-utils";
+import { pathExists } from "../utils/folders";
 import { verboseLog } from "../utils/loggin";
+import { getRenderPathsFromDB } from "../utils/render";
 
-const config = getConfig();
-
-/**
- * TODO: JSDoc
- */
 class RobotsService {
 	robots: Robots;
 	settings: Record<string, unknown>;
@@ -22,12 +18,9 @@ class RobotsService {
 		this.settings = {};
 	}
 
-	/**
-	 * TODO: JSDoc
-	 */
 	private async getRobots() {
 		try {
-			const apiRobots = await get<Robots>({ endpoint: endpoints.ROBOTS });
+			const apiRobots = await get<Robots>({ endpoint: ROBOTS });
 			this.robots =
 				apiRobots
 					?.filter((r) => !!r.path)
@@ -44,8 +37,8 @@ class RobotsService {
 	 * Write robots.txt files for the domain.
 	 */
 	async writeFiles(domain: string) {
-		const { __cx } = config.paths(domain);
-		const distDirectory = path.join(__cx, "dist");
+		const { __root } = await getRenderPathsFromDB({ domain });
+		const distDirectory = path.join(__root, "dist");
 
 		await this.getRobots();
 
@@ -56,9 +49,9 @@ class RobotsService {
 			return;
 		}
 
-		if (fs.existsSync(distDirectory)) {
+		if (await pathExists(distDirectory)) {
 			const fileLocation = path.join(distDirectory, "robots.txt");
-			fs.writeFileSync(fileLocation, robot?.content);
+			await fsp.writeFile(fileLocation, robot?.content);
 			verboseLog(`wrote robots.txt to ${fileLocation}`);
 		} else {
 			console.log(`${distDirectory} not found`);

package/exporter/services/sites.ts

@@ -1,3 +1,4 @@
+import type { Core } from "@griddo/core";
 import type {
 	AllSitesReponse,
 	EndPageInfoResponse,
@@ -11,17 +12,26 @@ import type {
 	StartPageRenderResponse,
 } from "../types/api";
 import type { Site } from "../types/sites";
-import type { Core } from "@griddo/core";
 
-import { endpoints } from "../constants";
+import {
+	BUILD_END,
+	BUILD_START,
+	GET_ALL,
+	GET_PAGE,
+	GET_REFERENCE_FIELD_DATA,
+	GET_SITEMAP,
+	INFO,
+	LANGUAGES,
+	SOCIALS,
+} from "../constants/endpoints";
 import { get, post } from "../utils/api";
 
 /**
  * Get a list of site objects.
  */
 async function getAllSites(domain: string) {
-	return await get<AllSitesReponse>({
-		endpoint: `${endpoints.GET_ALL}?domainSlug=${domain}`,
+	return get<AllSitesReponse>({
+		endpoint: `${GET_ALL}?domainSlug=${domain}`,
 	});
 }
 
@@ -29,7 +39,7 @@ async function getAllSites(domain: string) {
  * Get a list of site objects from a domain.
  */
 async function getAllSitesFromDomain(domain: string) {
-	const allSites = await get<AllSitesReponse>({ endpoint: endpoints.GET_ALL });
+	const allSites = await get<AllSitesReponse>({ endpoint: GET_ALL });
 
 	if (allSites.length) {
 		for (const site of allSites) {
@@ -40,8 +50,7 @@ async function getAllSitesFromDomain(domain: string) {
 			site.domains = items
 				.filter(
 					(item) =>
-						item.domain &&
-						(item.domain.slug === domain || item.domain.slug === `/${domain}`),
+						item.domain && (item.domain.slug === domain || item.domain.slug === `/${domain}`),
 				)
 				.map((item) => ({ [item.id]: `${item.domain.slug}${item.path}` }));
 		}
@@ -54,8 +63,8 @@ async function getAllSitesFromDomain(domain: string) {
  * Fetch a page object from API.
  */
 async function getPage(id: number, cacheKey: string) {
-	return await get<PageResponse>({
-		endpoint: `${endpoints.GET_PAGE}/${id}`,
+	return get<PageResponse>({
+		endpoint: `${GET_PAGE}/${id}`,
 		cacheKey,
 	});
 }
@@ -64,27 +73,27 @@ async function getPage(id: number, cacheKey: string) {
  * Get site info
  */
 async function getSiteInfo(id: number, cacheKey = "") {
-	const [prefix, suffix] = endpoints.INFO;
+	const [prefix, suffix] = INFO;
 
-	return await get<Site>({
+	return get<Site>({
 		endpoint: `${prefix}${id}${suffix}`,
 		cacheKey,
 	});
 }
 
 async function getSiteLanguages(id: number, cacheKey = "") {
-	const [prefix, suffix] = endpoints.LANGUAGES;
+	const [prefix, suffix] = LANGUAGES;
 
-	return await get<LanguagesResponse>({
+	return get<LanguagesResponse>({
 		endpoint: `${prefix}${id}${suffix}`,
 		cacheKey,
 	});
 }
 
 async function startSiteRender(id: number) {
-	const [prefix, suffix] = endpoints.BUILD_START;
+	const [prefix, suffix] = BUILD_START;
 
-	return await get<StartPageRenderResponse>({
+	return get<StartPageRenderResponse>({
 		endpoint: `${prefix}${id}${suffix}`,
 	});
 }
@@ -93,12 +102,13 @@ async function startSiteRender(id: number) {
  * Send the end signal to API for a render site.
  */
 async function endSiteRender(id: number, body: EndSiteRenderBody) {
-	const [prefix, suffix] = endpoints.BUILD_END;
+	const [prefix, suffix] = BUILD_END;
 
-	return await post<EndPageInfoResponse>({
+	return post<EndPageInfoResponse>({
 		endpoint: `${prefix}${id}${suffix}`,
 		body,
 		useApiCacheDir: false,
+		logToFile: false,
 	});
 }
 
@@ -109,11 +119,11 @@ async function getReferenceFieldSiteData(
 	dataSiteId?: number,
 	dataLangID?: number,
 ) {
-	const [prefix, suffix] = endpoints.GET_REFERENCE_FIELD_DATA;
+	const [prefix, suffix] = GET_REFERENCE_FIELD_DATA;
 	const site = dataSiteId || page.site;
 	const lang = dataLangID || page.language;
 
-	return await post<ReferenceFieldResponse>({
+	return post<ReferenceFieldResponse>({
 		endpoint: `${prefix}${site}${suffix}`,
 		body,
 		headers: { lang },
@@ -121,18 +131,20 @@ async function getReferenceFieldSiteData(
 	});
 }
 
-async function getSitemap(id: number) {
-	const [prefix, suffix] = endpoints.GET_SITEMAP;
+async function getSitemap(options: { siteId: number; headers?: Record<string, string> }) {
+	const { siteId, headers } = options;
+	const [prefix, suffix] = GET_SITEMAP;
 
 	return get<SitemapAPIResponse>({
-		endpoint: `${prefix}${id}${suffix}`,
+		endpoint: `${prefix}${siteId}${suffix}`,
+		headers,
 	});
 }
 
 async function getSiteSocials(id: number, cacheKey = "") {
-	const [prefix, suffix] = endpoints.SOCIALS;
+	const [prefix, suffix] = SOCIALS;
 
-	return await get<SocialsResponse>({
+	return get<SocialsResponse>({
 		endpoint: `${prefix}${id}${suffix}`,
 		cacheKey,
 	});

package/exporter/services/store.ts

@@ -1,4 +1,4 @@
-import type { BuildProcessData } from "../types/global";
+import type { BuildProcessData, Settings } from "../types/global";
 import type {
 	GriddoListPage,
 	GriddoMultiPage,
@@ -6,20 +6,23 @@ import type {
 	GriddoSinglePage,
 	PageAdditionalInfo,
 } from "../types/pages";
+import type { RenderMode } from "../types/render";
 
-import fs from "node:fs";
+import fsp from "node:fs/promises";
 import path from "node:path";
 
 import pLimit from "p-limit";
 
-import { envs } from "../constants";
-import { NavigationService } from "./navigation";
-import { getReferenceFieldData } from "./reference-fields";
-import { getAllSettings } from "./settings";
-import { getPage } from "./sites";
+import { SETTINGS } from "../constants/endpoints";
+import {
+	GRIDDO_API_CONCURRENCY_COUNT,
+	GRIDDO_API_URL,
+	GRIDDO_PUBLIC_API_URL,
+	GRIDDO_REACT_APP_INSTANCE,
+} from "../constants/envs";
+import { get } from "../utils/api";
 import { updatedSiteHash } from "../utils/cache";
-import { getConfig, removeAllSiteDirsFromStore } from "../utils/core-utils";
-import { buildLog, listSitesLog } from "../utils/loggin";
+import { infoLog, listSitesLog } from "../utils/loggin";
 import {
 	createGriddoListPages,
 	createGriddoMultiPages,
@@ -29,26 +32,38 @@ import {
 } from "../utils/pages";
 import { getSiteData, getSitesToRender, unpublishSites } from "../utils/sites";
 import {
-	getMissingPublishedPagesInStore,
 	getZombiePagesInStore,
 	removeOrphanSites,
 	removeSitePagesFromStore,
 	saveRenderInfoInStore,
 	saveSitePagesInStore,
 } from "../utils/store";
+import { NavigationService } from "./navigation";
+import { getReferenceFieldData } from "./reference-fields";
+import { getPage } from "./sites";
 
-const renderId = new Date().valueOf().toString();
-const { griddoVersion, paths } = getConfig();
-const { __cx } = paths();
-const storeDir = path.join(__cx, "store");
+const renderId = Date.now().toString();
+
+function guessSiteNeedsToBeRenderedFromScratch() {
+	return false;
+}
 
 /**
  * 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(domain: string) {
-	console.info(`API calls with ${envs.GRIDDO_API_CONCURRENCY_COUNT} threads`);
-	console.info(`API URL ${envs.GRIDDO_API_URL as string}`);
+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 === "FROM_SCRATCH";
+	const storeDir = path.join(basePath, "store");
 
 	try {
 		// Vars to save later in the report file
@@ -58,31 +73,43 @@ async function createStore(domain: string) {
 		// 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);
+		await removeOrphanSites(sitesToPublish, domain);
+
+		const allPagesToRemoveFromBuild: Array<number> = [];
+		// let numberOfFinalActivePages: Array<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,
+			);
+		}
 
-		// Solo los sites to publish...
 		for (const site of sitesToPublish) {
 			const { id: siteId, slug: siteSlug, theme, favicon, pagesStatus } = site;
 			const siteDirName = siteId.toString();
+			// numberOfFinalActivePages.push(
+			// 	...pagesStatus.active,
+			// 	...pagesStatus.uploadPending,
+			// );
+
+			allPagesToRemoveFromBuild.push(...pagesStatus.offlinePending, ...pagesStatus.deleted);
 
 			const {
 				siteInfo,
@@ -104,7 +131,7 @@ async function createStore(domain: string) {
 				avoidSelfReferenceCanonicals,
 				avoidHrefLangXDefault,
 				avoidDebugMetas,
-			} = await getAllSettings();
+			} = await get<Settings>({ endpoint: SETTINGS });
 
 			buildProcessData[siteId] = {
 				siteHash,
@@ -118,7 +145,7 @@ async function createStore(domain: string) {
 
 			site.languages = siteLangs;
 
-			const shouldUpdateSite = updatedSiteHash(siteId, siteHash);
+			const shouldUpdateSite = await updatedSiteHash(siteId, siteHash);
 
 			const siteScript = siteInfo.siteScript;
 
@@ -129,9 +156,9 @@ async function createStore(domain: string) {
 			};
 
 			const additionalInfo = {
-				baseUrl: envs.GRIDDO_API_URL,
-				publicBaseUrl: envs.GRIDDO_PUBLIC_API_URL,
-				instance: envs.GRIDDO_REACT_APP_INSTANCE,
+				baseUrl: GRIDDO_API_URL,
+				publicBaseUrl: GRIDDO_PUBLIC_API_URL,
+				instance: GRIDDO_REACT_APP_INSTANCE,
 				siteSlug,
 				theme,
 				siteMetadata,
@@ -151,10 +178,10 @@ async function createStore(domain: string) {
 				siteScript,
 			};
 
-			buildLog(`${site.name} site`);
+			infoLog(`Getting pages from ${site.name} site`);
 
 			/// Creates the store directory for each site using the id
-			fs.mkdirSync(path.join(storeDir, siteDirName), {
+			await fsp.mkdir(path.join(storeDir, siteDirName), {
 				recursive: true,
 			});
 
@@ -163,10 +190,7 @@ async function createStore(domain: string) {
 			// -------------------------------------------------------------------------
 			// 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,
-			) => {
+			const fetchSitePageAndSaveInStore = async (siteIdName: string, pageId: number) => {
 				// Here will be store every page returned by the API and processed
 				let griddoPageObjects: Array<GriddoPageObject> = [];
 
@@ -185,9 +209,7 @@ async function createStore(domain: string) {
 				// 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;
+				const pageAdditionalInfo = JSON.parse(JSON.stringify(additionalInfo)) as PageAdditionalInfo;
 
 				// Updated with navigations (header & footer)
 				pageAdditionalInfo.navigations = NavService.getPageNavigations(page);
@@ -217,8 +239,7 @@ async function createStore(domain: string) {
 				// - Single: just one page
 
 				// Griddo page types
-				const isStaticListPage =
-					page?.mode === "list" || page?.mode === "paginated-data";
+				const isStaticListPage = page?.mode === "list" || page?.mode === "paginated-data";
 				const isMultiPage = !isStaticListPage && multiPageElements;
 				const isSinglePage = !isMultiPage && !isStaticListPage;
 
@@ -234,10 +255,12 @@ async function createStore(domain: string) {
 					} as GriddoListPage;
 
 					// pageObjects = await createGriddoListPages({ adapter: "Gatsby" })
-					griddoPageObjects = await createGriddoListPages(
-						griddoListPage,
-						pageAdditionalInfo,
-					);
+					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 <<
@@ -249,10 +272,12 @@ async function createStore(domain: string) {
 					griddoMultipage.multiPageElements = multiPageElements;
 					griddoMultipage.defaultLang = defaultLang;
 
-					griddoPageObjects = await createGriddoMultiPages(
-						griddoMultipage,
-						pageAdditionalInfo,
-					);
+					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 <<
@@ -263,9 +288,7 @@ async function createStore(domain: string) {
 					griddoSinglePage.template = template;
 					griddoSinglePage.defaultLang = defaultLang;
 
-					griddoPageObjects = [
-						await createGriddoSinglePage(griddoSinglePage, pageAdditionalInfo),
-					];
+					griddoPageObjects = [await createGriddoSinglePage(griddoSinglePage, pageAdditionalInfo)];
 				}
 
 				// Upload only the valid pages hashes or ids of pages that has
@@ -276,25 +299,26 @@ async function createStore(domain: string) {
 				}
 
 				// Save build data to store
-				saveSitePagesInStore(siteIdName, griddoPageObjects);
+				await 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),
-			];
+			// 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);
+			}
 
 			// 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 limit = pLimit(GRIDDO_API_CONCURRENCY_COUNT);
 			const pagesToStore = pagesToFetchFromAPI.map((id: number) =>
 				limit(() => fetchSitePageAndSaveInStore(siteDirName, id)),
 			);
@@ -302,13 +326,13 @@ async function createStore(domain: string) {
 			await Promise.all(pagesToStore);
 
 			// @ts-expect-error Mutate pagesStatus for reading pourposes.
-			pagesStatus.zombie = getZombiePagesInStore(siteDirName, [
+			pagesStatus.zombie = await getZombiePagesInStore(siteDirName, [
 				...pagesStatus.active,
 				...pagesStatus.uploadPending,
 			]);
 
 			// Delete pages from the store removing them from disk.
-			removeSitePagesFromStore(siteDirName, [
+			await removeSitePagesFromStore(siteDirName, [
 				pagesStatus.deleted,
 				pagesStatus.offline,
 				pagesStatus.offlinePending,
@@ -321,35 +345,22 @@ async function createStore(domain: string) {
 		// 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
+		// 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({
+		await saveRenderInfoInStore(
+			{
 				buildProcessData,
 				createdPages,
 				sitesToPublish,
-			});
-		} else {
-			// ( 2 )
-			removeAllSiteDirsFromStore();
-			saveRenderInfoInStore({
-				buildProcessData,
-				createdPages: [],
-				sitesToPublish: [],
-			});
-		}
+			},
+			domain,
+		);
+
+		return {
+			pagesToCreate: createdPages,
+			pagesToDelete: allPagesToRemoveFromBuild,
+		};
 	} catch (e) {
 		const error = e as { message: string };
 		console.error(error.message);