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

package/exporter/react/GriddoOpenGraph/index.tsx

@@ -1,39 +0,0 @@
-import type { CustomHeadProps } from "../../shared/types";
-
-interface GriddoOpenGraphProps {
-	openGraph?: CustomHeadProps["pageContext"]["openGraph"];
-	pageMetadata?: CustomHeadProps["pageContext"]["pageMetadata"];
-	siteMetadata?: CustomHeadProps["pageContext"]["siteMetadata"];
-	locale?: string;
-	fullUrl?: string;
-}
-
-const GriddoOpenGraph = (props: GriddoOpenGraphProps) => {
-	const { openGraph, pageMetadata, siteMetadata, locale, fullUrl } = props;
-
-	// La lógica de fallback se encapsula aquí
-	const ogTitle = openGraph?.title || pageMetadata?.title;
-	const ogDescription = openGraph?.description || pageMetadata?.description;
-	const ogUrl = pageMetadata?.canonical || fullUrl || "";
-
-	return (
-		<>
-			{/* Open Graph */}
-			{!!siteMetadata?.title && <meta property="og:site_name" content={siteMetadata.title} />}
-			{!!locale && <meta property="og:locale" content={locale} />}
-			{!!ogTitle && <meta property="og:title" content={ogTitle} />}
-			<meta property="og:type" content={openGraph?.type || "website"} />
-			{!!ogDescription && <meta property="og:description" content={ogDescription} />}
-			{!!openGraph?.image && <meta property="og:image" content={openGraph.image} />}
-			<meta property="og:url" content={ogUrl} />
-
-			{/* Twitter */}
-			<meta property="twitter:card" content="summary_large_image" />
-			{!!openGraph?.twitterImage && (
-				<meta property="twitter:image" content={openGraph.twitterImage} />
-			)}
-		</>
-	);
-};
-
-export { GriddoOpenGraph };

package/exporter/services/api.ts

@@ -1,306 +0,0 @@
-import type {
-	APIRequest,
-	APIResponses,
-	GetAPI,
-	PostAPI,
-	PutAPI,
-	ShowApiErrorOptions,
-} from "../shared/types/api";
-import type { Petition } from "../shared/types/global";
-
-import crypto from "node:crypto";
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { RenderError } from "../core/errors";
-import { pathExists } from "../core/fs";
-import { GriddoLog } from "../core/GriddoLog";
-import { addLogToBuffer } from "../core/logger";
-import { brush } from "../shared/npm-modules/brush";
-import { AuthService } from "./auth";
-import { getRenderPathsHydratedWithDomainFromDB } from "./render";
-
-// Envs
-const { env } = process;
-const { RETRY_WAIT_SECONDS = "4", RETRY_ATTEMPTS = "4" } = env;
-
-/**
- * Make a GET/PUT/POST request to the Griddo API.
- *
- * @template T Response Type returned.
- * @returns {Promise<T>} A promise that is resolved with the data from the API response.
- *
- * @example
- *	const response = await requestAPI<Site>(
- *		{ endpoint: "...", cacheKey: "...", ... },
- *		"get",
- *		"..."
- *	);
- */
-async function requestAPI<T extends APIResponses>(
-	props: APIRequest,
-	method: string,
-	appendToLog = "",
-): Promise<T> {
-	const {
-		endpoint,
-		body,
-		cacheKey = "",
-		attempt = 1,
-		headers,
-		useApiCacheDir = true,
-		logToFile = true,
-	} = props;
-	const cacheOptions = { endpoint, body, headers, cacheKey };
-
-	// Cache
-	if (cacheKey && useApiCacheDir) {
-		const start = new Date();
-		const cacheData = await searchCacheData<T>(cacheOptions);
-
-		if (cacheData) {
-			if (logToFile) {
-				const siteId = getSafeSiteId(cacheData);
-				const siteIdMsg = siteId ? `site: ${siteId}` : "";
-				const duration = msToSec(Date.now() - start.getTime());
-				addLogToBuffer(`${method} (cache) ${siteIdMsg} ${endpoint} - ${duration}s ${appendToLog}`);
-			}
-			return cacheData;
-		}
-	}
-
-	// Network
-	try {
-		const start = new Date();
-
-		// Prepare fetch options
-		const fetchOptions: RequestInit = {
-			method: method.toUpperCase(),
-			headers: Object.assign({}, headers, AuthService.headers) as Record<string, string>,
-		};
-
-		// Add body for non-GET requests
-		if (method.toLowerCase() !== "get" && body) {
-			fetchOptions.body = JSON.stringify(body);
-			if (!fetchOptions.headers) fetchOptions.headers = {};
-			(fetchOptions.headers as Record<string, string>)["Content-Type"] = "application/json";
-		}
-
-		const response = await fetch(endpoint, fetchOptions);
-
-		// Handle non-2xx responses
-		if (!response.ok) {
-			if (response.status === 404) {
-				// @ts-expect-error page maybe will be 404
-				return null;
-			}
-
-			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-		}
-
-		const data: T = await response.json();
-
-		if (logToFile) {
-			const siteId = getSafeSiteId(data);
-			const siteIdMsg = siteId ? `site: ${siteId}` : "";
-			const duration = msToSec(Date.now() - start.getTime());
-			addLogToBuffer(`${method} (fetch) ${siteIdMsg} ${endpoint} - ${duration}s ${appendToLog}`);
-		}
-
-		if (useApiCacheDir) {
-			await saveCache(cacheOptions, data);
-		}
-
-		return data;
-	} catch (e) {
-		const error = e as Error;
-
-		if (attempt > parseInt(RETRY_ATTEMPTS)) {
-			GriddoLog.log(`
-Max attempts ${RETRY_ATTEMPTS} reached
---------------------------------------
-- ${method.toUpperCase()} ${endpoint}
-- BODY: ${JSON.stringify(body)}
-- HEADERS: ${JSON.stringify(headers)}
-- ERROR: ${error.message}
---------------------------------------
-`);
-			throw new RenderError(error);
-		}
-
-		showApiError(error, {
-			callInfo: { endpoint, body },
-		});
-
-		GriddoLog.warn(`Waiting for retry: ${method}`, endpoint);
-
-		await delay(parseInt(RETRY_WAIT_SECONDS) * 1000);
-
-		return requestAPI<T>(
-			{
-				endpoint,
-				body,
-				headers,
-				cacheKey,
-				attempt: attempt + 1,
-			},
-			method,
-			appendToLog,
-		);
-	}
-}
-
-/**
- * Make a GET request to the Griddo API.
- *
- * @template T Response Type returned.
- * @returns A promise that is resolved with the data from the API response.
- */
-async function getApi<T extends APIResponses>(props: GetAPI) {
-	return requestAPI<T>(props, "get");
-}
-
-/**
- * Make a PUT request to the Griddo API.
- *
- * @template T Response Type returned.
- * @returns A promise that is resolved with the data from the API response.
- */
-async function putApi<T extends APIResponses>(props: PutAPI) {
-	return requestAPI<T>(props, "put");
-}
-
-/**
- * Make a POST request to the Griddo API.
- *
- * @template T Response Type returned.
- * @returns A promise that is resolved with the data from the API response.
- */
-async function postApi<T extends APIResponses>(props: PostAPI) {
-	const { endpoint, body, headers } = props;
-	const referenceFieldBodyParams =
-		endpoint.endsWith("/distributor") &&
-		`# ReferenceField body: ${JSON.stringify(body)} lang: ${JSON.stringify(headers?.lang)}`;
-
-	return requestAPI<T>(props, "post", referenceFieldBodyParams || "");
-}
-
-/**
- * Shows an API error through the terminal.
- */
-function showApiError(error: Error, options: ShowApiErrorOptions) {
-	const { message, stack } = error;
-	const { callInfo } = options;
-	const callInfoArray = [];
-
-	for (const item of Object.keys(callInfo) as (keyof typeof callInfo)[]) {
-		callInfoArray.push(
-			`${item}: ${
-				typeof callInfo[item] === "object" ? JSON.stringify(callInfo[item]) : callInfo[item]
-			}`,
-		);
-	}
-
-	// Compose the errors output
-	const callInfoStr = callInfoArray.join("\n");
-	const errorDetailsStr = `${message}\n${stack}`;
-
-	// Print the error
-	GriddoLog.warn(
-		brush.red(`
-=============
-
-{ Call info }
-${callInfoStr}
-
-{ Error details }
-${errorDetailsStr}
-
-=============
-`),
-	);
-}
-
-/**
- * Return a siteID from a response object if exist
- * @param response A response object
- */
-function getSafeSiteId(response: APIResponses) {
-	if (typeof response !== "object" || response === null || Array.isArray(response)) {
-		return undefined;
-	}
-
-	return "site" in response && response.site ? response.site : undefined;
-}
-
-/**
- * Custom delay using the "promise hack",
- *
- * @param ms Amount of miliseconds to be delayed
- */
-function delay(ms: number): Promise<void> {
-	return new Promise((res) => setTimeout(res, ms));
-}
-
-/**
- * Converts milliseconds to seconds with a fixed number of decimals.
- *
- * @param ms The number in milliseconds.
- * @param fixed The amount of fixed decimals.
- * @returns The converted number in seconds with the fixed number of decimals.
- */
-function msToSec(ms: number, decimals = 3): number {
-	return Number.parseFloat((ms / 1000).toFixed(decimals));
-}
-
-/**
- * Generate a filename with a hash using a Petition object
- * @param petition An object
- */
-async function generateFilenameWithHash(petition: Petition) {
-	const { __root } = await getRenderPathsHydratedWithDomainFromDB();
-	const apiCacheDir = path.join(__root, "apiCache");
-
-	const hashSum = crypto.createHash("sha256");
-	hashSum.update(JSON.stringify(petition));
-
-	return `${apiCacheDir}/${hashSum.digest("hex")}`;
-}
-
-/**
- * Save a file using a hash name.
- *
- * @param petition An object.
- * @param content Content to be saved.
- */
-async function saveCache<T>(petition: Petition, content: T) {
-	const stringContent = typeof content === "string" ? content : JSON.stringify(content);
-	const filename = await generateFilenameWithHash(petition);
-	const filepath = path.dirname(filename);
-
-	if (!(await pathExists(filepath))) {
-		await fsp.mkdir(filepath, { recursive: true });
-	}
-
-	await fsp.writeFile(filename, stringContent, "utf8");
-}
-
-/**
- * Search in the `apiCache` dir for a file using the petition as hash generator.
- * Return the file content if found or null if not.
- *
- * @param petition An object
- */
-async function searchCacheData<T>(petition: Petition) {
-	try {
-		const file = await generateFilenameWithHash(petition);
-		const fileContent = await fsp.readFile(file, "utf8");
-		const jsonData = JSON.parse(fileContent) as T;
-
-		return jsonData;
-	} catch {
-		return null;
-	}
-}
-
-export { getApi as get, postApi as post, putApi as put };

package/exporter/services/manage-sites.ts

@@ -1,116 +0,0 @@
-import type { Site, SiteData } from "../shared/types/sites";
-
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { getRenderPathsHydratedWithDomainFromDB } from "./render";
-import {
-	endSiteRender,
-	getAllSites,
-	getSiteInfo,
-	getSiteLanguages,
-	getSiteSocials,
-	startSiteRender,
-} from "./sites";
-
-/**
- * Check the instance sites and returns site prepared to be published and unpublished.
- */
-async function getSitesToRender(domain: string) {
-	// Get all sites. An array of Site
-	const allSites = await getAllSites(domain);
-
-	// If there are valid sites...
-	// En este paso se añade al objeto `Site` la información de los dominios
-	// utilizando los idiomas.
-	if (allSites.length) {
-		for (const site of allSites) {
-			const { items } = await getSiteLanguages(site.id);
-
-			// Añadimos la prop site.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
-	const sitesToPublish = allSites.filter((site) => !!site.isPublished);
-
-	// Save sites object to unpublish
-	const sitesToUnpublish = allSites.filter((site) => !site.isPublished && site.shouldBeUpdated);
-
-	return {
-		sitesToPublish,
-		sitesToUnpublish,
-	};
-}
-
-/**
- * Unpublish an array of sites sending the information to the API.
- *
- * @param sites An array of sites
- */
-async function unpublishSites(sites: Site[]) {
-	const { __root } = await getRenderPathsHydratedWithDomainFromDB();
-
-	for (const site of sites) {
-		// API
-		const buildInfo = await startSiteRender(site.id);
-		const { siteHash } = buildInfo;
-		const body = {
-			siteHash,
-			publishHashes: [],
-			unpublishHashes: [],
-			publishPagesIds: [],
-		};
-
-		await endSiteRender(site.id, body);
-
-		// STORE
-		// Remove site directory from the Store to prevent rendering
-		await fsp.rm(path.join(__root, "store", site.id.toString()), {
-			force: true,
-			recursive: true,
-		});
-	}
-}
-
-/**
- * Return a single site generic data.
- *
- * @param siteID The site id.
- * @see SiteData
- */
-async function getSiteData(siteID: number) {
-	const buildData = await startSiteRender(siteID);
-	const siteInfo = await getSiteInfo(siteID);
-	const siteLangs = await getSiteLanguages(siteID);
-	const socials = await getSiteSocials(siteID);
-	const siteLangsInfo = siteLangs.items;
-	const defaultLang = siteLangsInfo.find((lang) => lang.isDefault);
-
-	const { siteHash, unpublishHashes, publishIds } = buildData;
-	const { headers, footers } = siteInfo;
-	const validPagesIds = publishIds;
-
-	const siteData: SiteData = {
-		siteInfo,
-		validPagesIds,
-		siteHash,
-		unpublishHashes,
-		siteLangs: siteLangsInfo,
-		defaultLang,
-		headers,
-		footers,
-		socials,
-	};
-
-	return siteData;
-}
-
-export { getSiteData, getSitesToRender, unpublishSites };

package/exporter/services/manage-store.ts

@@ -1,173 +0,0 @@
-import type { BuildMetaData } from "../shared/types/api";
-import type { RenderInfo } from "../shared/types/global";
-import type { GriddoPageObject } from "../shared/types/pages";
-import type { Site } from "../shared/types/sites";
-
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { readDB, writeDB } from "../core/db";
-import { throwError } from "../core/errors";
-import { pathExists } from "../core/fs";
-import { GriddoLog } from "../core/GriddoLog";
-import { WriteToStoreError } from "../shared/errors";
-import { getRenderPathsHydratedWithDomainFromDB } from "./render";
-
-/**
- * Get the build metadata from the Store.
- */
-async function getBuildMetadata(domain: string): Promise<BuildMetaData> {
-	const db = await readDB();
-	const { sitesToPublish, createdPages, buildProcessData } = db.domains[domain].renderInfo || {};
-
-	if (!sitesToPublish || !createdPages || !buildProcessData) {
-		throw new Error("Build metadata not found");
-	}
-
-	return {
-		buildProcessData,
-		createdPages,
-		sitesToPublish,
-	};
-}
-
-/**
- * Write render info into a file.
- * @param renderInfo - Data that will be saved related to the render process.
- */
-async function saveRenderInfoInStore(renderInfo: RenderInfo, domain: string) {
-	const db = await readDB();
-	db.domains[domain] = db.domains[domain] || {};
-	db.domains[domain].renderInfo = renderInfo;
-	await writeDB(db);
-}
-
-/**
- * Return an array of paths only from `.json` files (no dirs) in the `basePath` dir based in the file name.
- * @param basePath - Absolute path of the dir from which files will be read.
- * @returns A number[] of pages ids in `basePath` dir.
- */
-async function getPageInStoreDir(basePath: string) {
-	const filesInStore = await fsp.readdir(basePath);
-
-	return filesInStore
-		.filter(async (file) => {
-			const fullPathFile = `${basePath}/${file}`;
-			const stat = await fsp.stat(fullPathFile);
-			// Si es un directorio, no lo incluimos.
-			if (stat?.isDirectory()) {
-				return false;
-			}
-
-			// Si es un archivo pero no tiene la extensión `.json`, no lo incluimos
-			if (path.extname(file) !== ".json") {
-				return false;
-			}
-
-			// no es dir, es json.
-			return true;
-		})
-		.map((page) => {
-			return path.join(basePath, page);
-		});
-}
-
-/**
- * Save the pages into the file system.
- * @param pages - An array of Griddo page objects to be saved.
- */
-async function saveSitePagesInStore(siteDirName: string, pages: GriddoPageObject[]) {
-	const { __root } = await getRenderPathsHydratedWithDomainFromDB();
-
-	try {
-		const propsToRemove = new Set(["editorID", "parentEditorID"]);
-		for (const page of pages) {
-			removeProperties(page, propsToRemove);
-			const filename = `${page.context.page.id}.json`;
-			const filePath = path.join(__root, "store", siteDirName, filename);
-			// En los listados estáticos y multipage los ids de las páginas son iguales
-			await writeUniqueFileSync(filePath, JSON.stringify(page));
-		}
-	} catch (error) {
-		throwError(WriteToStoreError, error);
-	}
-}
-
-/**
- * Removes sites that exist in the store that should no longer be there because
- * the domain has been changed. This is necessary because those sites will not
- * be marked as `sitesToUnpublish` so they must be removed manually.
- */
-async function removeOrphanSites(sitesToPublish: Site[], domain: string) {
-	const { __root } = await getRenderPathsHydratedWithDomainFromDB({ domain });
-	const storePath = path.join(__root, "store");
-
-	if (!(await pathExists(storePath))) {
-		return;
-	}
-
-	const currentSitesInStore = await fsp.readdir(storePath);
-	const sitesFromAPI = sitesToPublish.map(({ id }) => `${id}`);
-	const sitesToDelete = currentSitesInStore.filter((site) => !sitesFromAPI.includes(site));
-
-	for (const site of sitesToDelete) {
-		await fsp.rm(path.join(storePath, site), { recursive: true, force: true });
-		GriddoLog.verbose(`Removed orphan site id: ${site}`);
-	}
-}
-
-async function writeUniqueFileSync(filePath: string, content: string) {
-	const dir = path.dirname(filePath);
-	const ext = path.extname(filePath);
-	const base = path.basename(filePath, ext);
-
-	let uniquePath = filePath;
-	let counter = 1;
-
-	while (await pathExists(uniquePath)) {
-		const newName = `${base}-${counter}${ext}`;
-		uniquePath = path.join(dir, newName);
-		counter++;
-	}
-
-	await fsp.writeFile(uniquePath, content);
-}
-
-/**
- * Remove props from an object
- *
- * @param obj The object
- * @param props An array of props to be removed
- */
-function removeProperties(obj: Record<string, unknown>, propsToRemove: Set<string>) {
-	function remove(currentObj: Record<string, unknown>) {
-		if (!currentObj || typeof currentObj !== "object" || Array.isArray(currentObj)) {
-			return;
-		}
-
-		for (const key in currentObj) {
-			if (Object.hasOwn(currentObj, key)) {
-				if (propsToRemove.has(key)) {
-					// Búsqueda O(1) en lugar de O(n)
-					delete currentObj[key];
-				} else {
-					const value = currentObj[key];
-					if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-						remove(value as Record<string, unknown>);
-					}
-				}
-			}
-		}
-	}
-
-	remove(obj);
-}
-
-export {
-	getBuildMetadata,
-	getPageInStoreDir,
-	removeOrphanSites,
-	saveRenderInfoInStore,
-	saveSitePagesInStore,
-	writeUniqueFileSync,
-};

package/exporter/services/render-artifacts.ts

@@ -1,44 +0,0 @@
-import type { RenderArtifacts } from "../shared/types/global";
-
-import path from "node:path";
-
-import { getRenderPathsHydratedWithDomainFromDB } from "./render";
-
-/**
- * Returns the artifacts of CX.
- */
-async function getRenderArtifacts(domain: string): Promise<RenderArtifacts> {
-	const { __exports, __cache, __root, __ssg } = await getRenderPathsHydratedWithDomainFromDB({
-		domain,
-	});
-
-	return {
-		initials: [
-			__exports, // `<root>/exports/<domain>`
-			__cache, // `<root>/.griddo/<domain>`
-			path.join(__exports, "logs"),
-			path.join(__root, "store"),
-			path.join(__root, "apiCache"),
-		],
-		disposables: [
-			path.join(__root, "store"),
-			path.join(__root, "apiCache"),
-			path.join(__root, "dist"),
-			path.join(__root, "dist-restored"),
-			path.join(__root, "assets"),
-			path.join(__root, "render-detail-log.txt"),
-			path.join(__root, "current-dist"),
-			path.join(__ssg, "domains.json"),
-			path.join(__ssg, "render-metadata.json"),
-		],
-		cacheables: [],
-		archivables: [
-			// dist ya se usa directamente en exports
-			// "dist",
-			"assets",
-		],
-		restaurable: ["dist"],
-	};
-}
-
-export { getRenderArtifacts };