@griddo/cx 11.7.12-rc.3 → 11.7.12

package/exporter/commands/end-render.ts

@@ -1,107 +1,105 @@
-import type { Report } from "../types/render";
+#!/usr/bin/env node
 
-import fsp from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
 
-import { ArtifactError } from "../constants/errors";
+import pkgDir from "pkg-dir";
+
 import { AuthService } from "../services/auth";
 import { endSiteRender } from "../services/sites";
+import { getConfig } from "../utils/core-utils";
 import { getInstanceDomains } from "../utils/domains";
-import { throwError } from "../utils/errors";
-import { pathExists } from "../utils/folders";
 import { infoLog } from "../utils/loggin";
-import { getRenderMetadataFromDB, getRenderMode, getRenderPathsFromDB } from "../utils/render";
 
-const renderByDomains = !!process.env.GRIDDO_RENDER_BY_DOMAINS;
+const RENDER_BY_DOMAIN = process.env.GRIDDO_RENDER_BY_DOMAINS || "";
+
+// Where we are going to find export dirs
+const execBasePath = pkgDir.sync(path.resolve(__dirname, "../.."))!;
+
+// Where we are going to find archived exports
+const exportArchiveBasePath = path.resolve(execBasePath, "exports/sites");
+
+type Report = {
+	authControl:
+		| {
+				Authorization: string;
+				"Cache-Control": string;
+				lang?: string | undefined;
+		  }
+		| undefined;
+	sites: Array<{
+		siteId: number;
+		publishHashes: Array<string>;
+		siteHash: string | null;
+		unpublishHashes: Array<string>;
+		publishPagesIds: Array<number>;
+	}>;
+};
+
+function getDomainRenderReport(domain: string) {
+	const reports: Array<Report> = [];
+	const { buildReportFileName } = getConfig();
 
-async function getRenderReport(options: {
-	domain: string;
-	exportsSiteDir: string;
-	buildReportFileName: string;
-}) {
-	const { buildReportFileName, domain, exportsSiteDir: exportArchiveBasePath } = options;
-	const buildReportFile = path.resolve(exportArchiveBasePath, domain, "dist", buildReportFileName);
+	const buildReportFile = path.resolve(
+		exportArchiveBasePath,
+		domain,
+		"dist",
+		buildReportFileName,
+	);
 
-	if (!(await pathExists(buildReportFile))) {
-		infoLog(`Build report file "${buildReportFile}" not found.`);
-		throwError(ArtifactError);
+	if (!fs.existsSync(buildReportFile)) {
+		console.info(`Build report file "${buildReportFile}" not found.`);
 	}
 
-	return JSON.parse(await fsp.readFile(buildReportFile, "utf-8")) as Report;
-}
+	const buildReport = JSON.parse(fs.readFileSync(buildReportFile, "utf-8"));
 
-const sendEndSiteRender = async (report: Report) => {
-	const sites = report.sites;
+	reports.push(buildReport);
 
-	for (const site of sites) {
-		const { siteId, ...body } = site;
-		infoLog(`Site (${siteId})`);
-		await endSiteRender(siteId, body);
-	}
-};
+	return reports;
+}
 
-async function endRender() {
-	const { buildReportFileName } = await getRenderMetadataFromDB();
-	const { __sites } = await getRenderPathsFromDB();
+(async () => {
+	const sendEndSiteRender = async (reports: Array<Report>) => {
+		for (const report of reports) {
+			const sites = report.sites;
 
-	await AuthService.login();
-	if (renderByDomains) {
-		const [domain] = process.argv.slice(2);
-		const { renderMode } = await getRenderMode(domain);
+			for (const site of sites) {
+				const { siteId, ...body } = site;
 
-		if (renderMode === "IDLE") {
-			infoLog(`Skipping build-end for domain ${domain} as it is marked as IDLE.`);
-			return;
+				console.info(`Site (${siteId})`);
+
+				await endSiteRender(siteId, body);
+			}
 		}
+	};
 
-		const report = await getRenderReport({
-			domain,
-			exportsSiteDir: __sites,
-			buildReportFileName,
-		});
+	if (RENDER_BY_DOMAIN) {
+		await AuthService.login();
+		const domain = process.argv.splice(2)[0];
+		const reports = getDomainRenderReport(domain);
 
 		infoLog(`Sending ending call to ${domain} sites`);
 
-		for (const site of report.sites) {
-			site.publishHashes = [...new Set(site.publishHashes)];
-			site.unpublishHashes = [...new Set(site.unpublishHashes)];
+		for (const report of reports) {
+			for (const site of report.sites) {
+				site.publishHashes = [...new Set(site.publishHashes)];
+				site.unpublishHashes = [...new Set(site.unpublishHashes)];
+			}
 		}
 
-		await sendEndSiteRender(report);
+		await sendEndSiteRender(reports);
 	} else {
-		console.log("- LEGACY RENDER MODE -");
+		// Legacy render
 		const domains = await getInstanceDomains();
 		for (const domain of domains) {
-			const { renderMode } = await getRenderMode(domain);
-
-			if (renderMode === "IDLE") {
-				infoLog(`Skipping build-end for domain ${domain} as it is marked as IDLE.`);
-				return;
-			}
-
-			const report = await getRenderReport({
-				domain,
-				exportsSiteDir: __sites,
-				buildReportFileName,
-			});
+			const reports = getDomainRenderReport(domain);
 
 			infoLog(`Sending ending call to ${domain} sites`);
 
-			for (const site of report.sites) {
-				site.publishHashes = [...new Set(site.publishHashes)];
-				site.unpublishHashes = [...new Set(site.unpublishHashes)];
-			}
-
-			await sendEndSiteRender(report);
+			await sendEndSiteRender(reports);
 		}
 	}
-}
-
-async function main() {
-	await endRender();
-}
-
-main().catch((err) => {
+})().catch((err) => {
 	console.error("Error", err?.stdout?.toString() || err);
 	process.exit(1);
 });

package/exporter/commands/move-assets.ts

@@ -0,0 +1,11 @@
+import { execSync } from "node:child_process";
+import path from "node:path";
+
+const domainName = "pro-griddo";
+const domainPath = path.resolve(
+	__dirname,
+	`../../../exports/sites/${domainName}`,
+);
+
+execSync(`mkdir -p ${domainPath}/assets/${domainName}`);
+execSync(`cp -R ${domainPath}/assets/* ${domainPath}/assets/${domainName}`);

package/exporter/commands/prepare-domains-render.ts

@@ -1,158 +1,46 @@
-import type { RenderDB } from "../types/render";
-
-import fsp from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
 
-import { version as griddoVersion } from "../../package.json";
-import { AuthService } from "../services/auth";
-import { readDB, writeDB } from "../services/db";
+import { getConfig } from "../utils/core-utils";
 import { getInstanceDomains } from "../utils/domains";
-import { pathExists, removeDirs } from "../utils/folders";
-import { resolveComponentsPath } from "../utils/instance";
-import { showExporterVersion } from "../utils/loggin";
-import { pkgDir } from "../utils/npm-deps/pkg-dir";
-import { resolveDomainRenderMode } from "../utils/render";
+import { infoLog, successLog } from "../utils/loggin";
 import { getSitesToRender } from "../utils/sites";
 
-async function getDomainsWithNumberOfPages(domains: Array<string>) {
-	const results = await Promise.all(
-		domains.map(async (domain) => {
-			// Get the sites to render for the domain
-			const { sitesToPublish, sitesToUnpublish } = await getSitesToRender(domain);
-
-			// Only count pages (offlinePending && publishPending) if sitesToPublish
-			// is not empty. Otherwise we set the domain has having 0 pages.
-			const pages: Array<number> = [];
-
-			if (sitesToPublish.length > 0) {
-				for (const site of sitesToPublish) {
-					// el site ya está publicado
-					if (site.isPublished && !site.shouldBeUpdated) {
-						const { pagesStatus } = site;
-						const { offlinePending, uploadPending } = pagesStatus;
-						const total = offlinePending.length + uploadPending.length;
-						pages.push(total);
-					}
-					// el site esta pendiente de publicar
-					if (site.isPublished && site.shouldBeUpdated) {
-						const { pagesStatus } = site;
-						const { offlinePending, uploadPending, active } = pagesStatus;
-						const total = offlinePending.length + uploadPending.length + active.length;
-						pages.push(total);
-					}
-				}
-			} else if (sitesToUnpublish.length > 0) {
-				// si tiene sites para despublicar marcamos el dominio como que tiene 1 página
-				pages.push(1);
-			} else {
-				// si eldominio no tiene nada ni para publicar ni despublicar lomarcamos como 0
-				pages.push(0);
-			}
-
-			const totalPages = pages.reduce((a, b) => a + b);
-
-			return { domain, totalPages };
-		}),
-	);
-
-	return results;
-}
-
-function getDomainsSortedByNumberOfPages(
-	domainsInfo: Array<{
-		domain: string;
-		totalPages: number;
-	}>,
-) {
-	domainsInfo.sort((a, b) => a.totalPages - b.totalPages);
-
-	return domainsInfo.map(({ domain }) => domain);
-}
-
-async function initRender() {
-	const root = (await pkgDir({ cwd: path.resolve(__dirname, "../../..") })) || "";
-	const cx = root;
-	const ssg = path.resolve((await pkgDir({ cwd: __dirname })) || "");
-	const cxCache = path.resolve(root, ".cx-cache");
-	const components = resolveComponentsPath();
-	const exportsDir = path.join(root, "exports/sites");
+(async () => {
+	infoLog("Checking domains size");
 
-	const data: RenderDB = {
-		proDomainPrefix: "pro-",
-		griddoVersion,
-		buildReportFileName: "build-report.json",
-		sortedDomains: [],
-		domains: {},
-		paths: {
-			components,
-			cx,
-			cxCache,
-			exportsDir,
-			root,
-			ssg,
-		},
-	};
+	const { __cx } = getConfig().paths();
 
-	// create the main cache folder for cx if it doesn't exist.
-	if (!(await pathExists(cxCache))) {
-		await fsp.mkdir(cxCache, { recursive: true });
-	}
-
-	await writeDB(data);
-}
-
-async function prepareDomains() {
-	await AuthService.login();
-
-	const db = await readDB();
-
-	const __ssg = db.paths.ssg;
 	const domains = await getInstanceDomains();
-	const domainsWithNumberOfPages = await getDomainsWithNumberOfPages(domains);
-	const domainSorted = getDomainsSortedByNumberOfPages(domainsWithNumberOfPages);
-
-	// @deprecated use db.json (only for infra)
-	await fsp.writeFile(path.join(__ssg, "domains.json"), JSON.stringify(domainSorted));
-	await fsp.writeFile(path.join(__ssg, "domains.txt"), domainSorted.join(","));
-
-	db.sortedDomains = domainSorted;
-	db.domains = {};
-
-	for (const { domain, totalPages } of domainsWithNumberOfPages) {
-		const shouldBeRendered = totalPages > 0;
-		const { renderMode, reason } = await resolveDomainRenderMode({
-			domain,
-			shouldBeRendered,
-		});
+	const domainsInfo = [];
+	const domainsFilePath = path.join(__cx, "domains.json");
+
+	for (const domain of domains) {
+		const { sitesToPublish } = await getSitesToRender(domain);
+
+		// Only count pages (changedPages) if sitesToPublish is not empty.
+		// Otherwise we set the domain has having 0 pages.
+		const pages = [];
+		if (sitesToPublish.length > 0) {
+			for (const site of sitesToPublish) {
+				pages.push(site.changedPages.length);
+			}
+		} else {
+			pages.push(0);
+		}
 
-		db.domains[domain] = db.domains[domain] || {};
-		db.domains[domain].renderMode = renderMode;
-		db.domains[domain].shouldBeRendered = shouldBeRendered;
-		db.domains[domain].renderModeReason = reason;
+		const totalPages = pages.reduce((a, b) => a + b);
+		domainsInfo.push({ domain, totalPages });
 	}
 
-	await writeDB(db);
-}
-
-async function clean() {
-	const db = await readDB();
-	const { root: __root } = db.paths;
-	await removeDirs([path.join(__root, "apiCache")]);
-}
+	// sort domains, smaller first
+	domainsInfo.sort((a, b) => a.totalPages - b.totalPages);
+	const domainSorted = domainsInfo.map(({ domain }) => domain);
 
-/**
- * Prepare domains to render.
- * It creates a `domains.json` file with the sorted list of domains and writes a
- * `RENDE-STATE.json` file to persist a state between all cx-infra commands.
- */
-async function main() {
-	await showExporterVersion();
-	await initRender();
-	await prepareDomains();
-	await clean();
-}
+	fs.writeFileSync(domainsFilePath, JSON.stringify(domainSorted));
 
-main().catch((err) => {
-	console.error("Error", err?.stdout?.toString() || err);
+	successLog(`Checking domains size`);
+})().catch((err) => {
+	console.error(err);
 	process.exit(1);
 });

package/exporter/commands/reset-render.ts

@@ -1,18 +1,11 @@
-import { RESET_RENDER } from "../constants/endpoints";
-import { AuthService } from "../services/auth";
-import { post } from "../utils/api";
+#!/usr/bin/env node
 
-async function resetRender() {
-	await post({
-		endpoint: RESET_RENDER,
-		useApiCacheDir: false,
-	});
-}
+import { AuthService } from "../services/auth";
+import { resetRender } from "../services/settings";
 
 async function main() {
 	await AuthService.login();
 	await resetRender();
-	console.log(`The render status has been reset.`);
 }
 
 main().catch((err) => {

package/exporter/commands/start-render.ts

@@ -1,45 +1,68 @@
-import { gatsbyRenderDomain } from "../adapters/gatsby";
-import { AuthService } from "../services/auth";
-import { brush } from "../utils/brush";
-import { checkEnvironmentHealth } from "../utils/check-environment-health";
+#!/usr/bin/env node
+import { renderDomainsWithGatsbyAdapter } from "../adapters/gatsby";
+import { RenderError } from "../errors";
 import { getInstanceDomains } from "../utils/domains";
-import { RenderError } from "../utils/errors";
+import { errorLabelLog, showExporterVersion } from "../utils/loggin";
+import { sendGriddoDefaultAlerts } from "../utils/render";
 
-const renderByDomains = !!process.env.GRIDDO_RENDER_BY_DOMAINS;
+const GRIDDO_RENDER_DOMAINS = process.env.GRIDDO_RENDER_DOMAINS || "";
+const RENDER_BY_DOMAIN = process.env.GRIDDO_RENDER_BY_DOMAINS || "";
 
 async function startRender() {
 	try {
-		if (renderByDomains) {
-			const [domain] = process.argv.slice(2);
-			await gatsbyRenderDomain(domain);
+		// DOMAINS
+		// This block is just for the local instance renders.
+		if (GRIDDO_RENDER_DOMAINS) {
+			console.log("USANDO EL .ENV");
+			showExporterVersion();
+			for (const domain of GRIDDO_RENDER_DOMAINS.split(",")) {
+				await renderDomainsWithGatsbyAdapter(domain);
+			}
+			await sendGriddoDefaultAlerts();
+			process.exit(0);
+		}
+
+		// This will render every domain opposed to the new logic of render each
+		// domain separately.
+		if (RENDER_BY_DOMAIN) {
+			const domain = process.argv.splice(2)[0];
+
+			if (!domain) {
+				console.log("Needs the domain name argument");
+				throw new RenderError();
+			}
+
+			showExporterVersion();
+			await renderDomainsWithGatsbyAdapter(domain);
+			await sendGriddoDefaultAlerts();
+
+			process.exit(0);
 		} else {
-			console.log("- LEGACY RENDER MODE -");
+			showExporterVersion();
+
+			console.log("( Legacy Render Mode )\n");
+
 			const domains = await getInstanceDomains();
+
 			for (const domain of domains) {
-				await gatsbyRenderDomain(domain);
+				await renderDomainsWithGatsbyAdapter(domain);
+				await sendGriddoDefaultAlerts();
 			}
+			process.exit(0);
 		}
-
-		return;
 	} catch (error) {
 		if (error instanceof RenderError) {
-			console.log(brush.red("GRIDDO_ERROR InternalCXError"));
+			errorLabelLog("GRIDDO_ERROR InternalCXError");
 			process.exit(1);
 		}
 
-		console.log(brush.red("GRIDDO_ERROR UnknownError"));
+		errorLabelLog("GRIDDO_ERROR UnknownError");
 		console.error(error);
 		process.exit(1);
 	}
 }
 
-async function main() {
-	checkEnvironmentHealth();
-	await AuthService.login();
-	await startRender();
-}
-
-main().catch((err) => {
+startRender().catch((err) => {
 	console.error("Error", err?.stdout?.toString() || err);
 	process.exit(1);
 });