@griddo/cx 11.9.11 → 11.9.12-rc.0

package/exporter/services/store.ts

@@ -1,102 +1,181 @@
-import type { BuildProcessData } from "../types/global";
+import type { BuildProcessData, Settings } from "../shared/types/global";
 import type {
 	GriddoListPage,
 	GriddoMultiPage,
 	GriddoPageObject,
 	GriddoSinglePage,
 	PageAdditionalInfo,
-} from "../types/pages";
+} from "../shared/types/pages";
+import type { HashSites, Site, SiteHash } from "../shared/types/sites";
 
-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 { 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 { 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 "../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");
+} from "./pages";
+import { getReferenceFieldData } from "./reference-fields";
+import { getRenderPathsHydratedWithDomainFromDB } from "./render";
+import { getPage } from "./sites";
 
-/**
- * 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}`);
+const renderId = Date.now().toString();
 
-	try {
-		// Vars to save later in the report file
-		const createdPages: Array<number> = [];
-		const buildProcessData: BuildProcessData = {};
+function guessSiteNeedsToBeRenderedFromScratch() {
+	return false;
+}
 
-		// Get sites objects to publish and unpublish from this domain
-		const { sitesToPublish, sitesToUnpublish } = await getSitesToRender(domain);
+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 domainHasSites =
-			sitesToPublish.length > 0 || sitesToUnpublish.length > 0;
+	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)}`;
+	});
 
-		if (!domainHasSites) {
-			console.warn(`There are no sites to update in the domain ${domain}`);
-		}
+	const sitesOutput = sitesStr.length > 0 ? `\n\n${sitesStr.join("\n")}` : brush.dim("--none--\n");
+
+	GriddoLog.log(`
+${title} ${sitesOutput}`);
+}
 
-		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,
+/**
+ * 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,
+		);
+	}
+
+	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: {
 				useMetaTitle,
 				useMetaKeywords,
 				showBasicMetaRobots,
@@ -104,257 +183,211 @@ async function createStore(domain: string) {
 				avoidSelfReferenceCanonicals,
 				avoidHrefLangXDefault,
 				avoidDebugMetas,
-			} = 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,
+			},
+			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,
 			});
 
-			// -------------------------------------------------------------------------
-			// 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,
-			]);
+			// 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);
 		}
 
-		// 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);
+		// 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",
+		});
+	}
+
+	return currentHash.toString();
 }
 
 export { createStore };