@griddo/cx 11.9.7 → 11.9.8-rc.0

package/exporter/core/print-logos.ts

@@ -0,0 +1,21 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { brush } from "../shared/npm-modules/brush";
+import { GriddoLog } from "./GriddoLog";
+
+/**
+ * Console log the Griddo exporter version.
+ */
+async function showExporterVersion() {
+	// console.clear();
+	const { version } = JSON.parse(
+		await fsp.readFile(path.resolve(__dirname, "../..", "package.json"), "utf-8"),
+	) as { version: string };
+	const logo = `\n${brush.yellow(`Griddo Exporter ${version}`)}
+${brush.dim(`Node ${process.version.slice(1)}`)}\n`;
+
+	GriddoLog.log(logo);
+}
+
+export { showExporterVersion };

package/exporter/index.ts

@@ -1,22 +1,4 @@
-/**
- *
- * Griddo CX library main export file.
- *
- * This file exports functions to use in both: adapters and SSG's frameworks.
- * Turning CX basically in a javascript library.
- *
- * # React
- * There is another export in the `/react` directory to use exclusivelly in
- * the browser context where nodejs (path, fs, etc..) is not available.
- *
- * # Separate scripts.
- * There are some separate .ts files as end-render.ts or reset-render.ts
- * that are intended to be used by infra via npm script like `npm run
- * end-render`
- *
- */
-
-import type { SocialsResponse } from "./types/api";
+import type { SocialsResponse } from "./shared/types/api";
 import type {
 	AdditionalInfo,
 	Dimensions,
@@ -24,53 +6,29 @@ import type {
 	GriddoMultiPage,
 	GriddoPageObject,
 	GriddoSinglePage,
-} from "./types/pages";
-import type { Site } from "./types/sites";
+} from "./shared/types/pages";
+import type { Site } from "./shared/types/sites";
 
-import { endpoints, envs } from "./constants";
-import { apiRegister } from "./registers/index";
-import { FileRegister, MemoryRegister, Register } from "./services/register";
-import { insertAlert } from "./utils/alerts";
-import { getConfig, walk } from "./utils/core-utils";
+import { throwError } from "./core/errors";
+import { walkStore } from "./core/fs";
 import {
 	componentLibraryPathAlias,
 	isComponentLibrary,
 	resolveComponentsPath,
-} from "./utils/instance";
-import {
-	buildLog,
-	debugLog,
-	infoLog,
-	pageSizeLog,
-	verboseLog,
-} from "./utils/loggin";
-import {
-	getBuildPagesFromCachedStore,
-	getBuildPagesFromStore,
-	getBuildPagesPath,
-} from "./utils/store";
+} from "./core/instance";
+import { addLogToBuffer } from "./core/logger";
+import { getRenderPathsHydratedWithDomainFromDB } from "./services/render";
+import { ReadFromStoreError } from "./shared/errors";
 
 export {
-	apiRegister,
-	buildLog,
+	addLogToBuffer,
 	componentLibraryPathAlias,
-	debugLog,
-	endpoints,
-	envs,
-	FileRegister,
-	getBuildPagesFromCachedStore,
-	getBuildPagesFromStore,
-	getBuildPagesPath,
-	getConfig,
-	infoLog,
-	insertAlert,
+	getRenderPathsHydratedWithDomainFromDB,
 	isComponentLibrary,
-	MemoryRegister,
-	pageSizeLog,
-	Register,
+	ReadFromStoreError,
 	resolveComponentsPath,
-	verboseLog,
-	walk,
+	throwError,
+	walkStore,
 	type AdditionalInfo,
 	type Dimensions,
 	type GriddoListPage,

package/exporter/services/api.ts

@@ -0,0 +1,306 @@
+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/auth.ts

@@ -1,23 +1,21 @@
-import type { AuthHeaders } from "../types/api";
+import type { AuthHeaders } from "../shared/types/api";
 
-import { endpoints, envs } from "../constants";
-import { throwError } from "../errors";
-import { LoginError } from "../errors/errors-data";
+import { throwError } from "../core/errors";
+import { LOGIN } from "../shared/endpoints";
+import { GRIDDO_BOT_PASSWORD, GRIDDO_BOT_USER } from "../shared/envs";
+import { LoginError } from "../shared/errors";
 
-/**
- * Service for authentication in the Griddo Private API
- */
 class AuthService {
 	headers: AuthHeaders | undefined;
 
 	async login() {
 		try {
-			const response = await fetch(endpoints.LOGIN, {
+			const response = await fetch(LOGIN, {
 				method: "POST",
 				headers: { "Content-Type": "application/json", Connection: "close" },
 				body: JSON.stringify({
-					username: envs.GRIDDO_BOT_USER,
-					password: envs.GRIDDO_BOT_PASSWORD,
+					username: GRIDDO_BOT_USER,
+					password: GRIDDO_BOT_PASSWORD,
 				}),
 			});
 

package/exporter/services/domains.ts

@@ -1,16 +1,31 @@
-import type { Domains } from "../types/global";
+import type { Domains } from "../shared/types/global";
 
-import { endpoints } from "../constants";
-import { get } from "../utils/api";
+import { throwError } from "../core/errors";
+import { GriddoLog } from "../core/GriddoLog";
+import { DOMAINS } from "../shared/endpoints";
+import { NoDomainsFoundError } from "../shared/errors";
+import { get } from "./api";
 
 /**
- * Get an array of available domain.
+ * Return an array of domains name (string) of the current instance.
  */
-async function getAllDomains() {
-	return get<Domains>({
-		endpoint: endpoints.DOMAINS,
+async function getInstanceDomains() {
+	const domains = await get<Domains>({
+		endpoint: DOMAINS,
 		useApiCacheDir: false,
 	});
+
+	if (!domains.length) {
+		throwError(NoDomainsFoundError);
+	}
+
+	GriddoLog.verbose(`getting domains names (${domains.length})`);
+
+	const filteredDomains = domains
+		.filter(({ slug }) => !!slug)
+		.map(({ slug }) => slug.replace("/", ""));
+
+	return [...new Set(filteredDomains)];
 }
 
-export { getAllDomains };
+export { getInstanceDomains };

package/exporter/services/manage-sites.ts

@@ -0,0 +1,116 @@
+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 };