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

package/exporter/core/GriddoLog.ts

@@ -1,45 +0,0 @@
-import { GRIDDO_BUILD_LOGS, GRIDDO_VERBOSE_LOGS } from "../shared/envs";
-import { brush } from "../shared/npm-modules/brush";
-
-/**
- * Clase estática para gestionar los logs de la aplicación.
- * No se puede instanciar, se usa directamente: GriddoLogs.info("mensaje").
- */
-class GriddoLog {
-	/** El constructor es privado para prevenir la instanciación de la clase. */
-	private constructor() {}
-
-	public static verbose(...str: unknown[]): void {
-		if (GRIDDO_VERBOSE_LOGS) {
-			console.log(brush.yellow("verbose"), brush.dim(str.join(" ")));
-		}
-	}
-
-	public static build(...str: unknown[]): void {
-		if (GRIDDO_BUILD_LOGS) {
-			GriddoLog.log(...str);
-		}
-	}
-
-	public static info(...str: unknown[]): void {
-		console.log(`${brush.blue("info")} ${str.join(" ")}`);
-	}
-
-	public static success(...str: unknown[]): void {
-		console.log(`${brush.green("success")} ${str.join(" ")}`);
-	}
-
-	public static error(...str: unknown[]): void {
-		console.error(`${brush.red("error")} ${str.join(" ")}`);
-	}
-
-	public static warn(...str: unknown[]): void {
-		console.warn(`${brush.yellow("warn")} ${str.join(" ")}`);
-	}
-
-	public static log(...args: Parameters<typeof console.log>): void {
-		console.log(...args);
-	}
-}
-
-export { GriddoLog };

package/exporter/core/check-env-health.ts

@@ -1,204 +0,0 @@
-import { CheckHealthError } from "../shared/errors";
-import { throwError } from "./errors";
-import { GriddoLog } from "./GriddoLog";
-
-// Environment variables that must be present (but value doesn't matter)
-const REQUIRED_ENV_VARS: readonly string[] = [];
-
-// Environment variables that must have specific values
-const REQUIRED_ENV_VALUES: readonly {
-	key: string;
-	expected: string;
-	description?: string;
-}[] = [
-	{
-		key: "GRIDDO_RENDER_BY_DOMAINS",
-		expected: "true",
-		description: "Must be set to 'true' for domain-based rendering",
-	},
-];
-
-// Environment variables that are recommended but not required
-// These will show warnings if missing but won't fail the health check
-const RECOMMENDED_ENV_VARS: readonly { key: string; description?: string }[] = [
-	{
-		key: "GRIDDO_BUILD_LOGS",
-		description: "Recommended for detailed render logs",
-	},
-	{
-		key: "GRIDDO_BUILD_LOGS_TO_FILE",
-		description: "Recommended for performance gain and simplify render logs",
-	},
-	{
-		key: "GRIDDO_API_CONCURRENCY_COUNT",
-		description: "Recommended for better performance and memory management",
-	},
-];
-
-// Environment variables that must be present (but value doesn't matter)
-const DEPRECATED_ENV_VARS: readonly { key: string; description?: string }[] = [
-	{
-		key: "GRIDDO_RENDER_SITE",
-		description:
-			"This environment variable no longer has any effect because it is incompatible with incremental rendering.",
-	},
-	{
-		key: "GRIDDO_RENDER_PAGES",
-		description:
-			"This environment variable no longer has any effect because it is incompatible with incremental rendering.",
-	},
-	{
-		key: "REACT_APP_API_ENDPOINT",
-		description: "Use GRIDDO_API_URL",
-	},
-	{
-		key: "REACT_APP_PUBLIC_API_ENDPOINT",
-		description: "Use GRIDDO_PUBLIC_API_URL",
-	},
-	{
-		key: "GRIDDO_RENDER_ALL_SITES",
-		description: "This environment variable is deprecated, remove it",
-	},
-];
-
-/**
- * Check if required environment variables exist with any value.
- *
- * @returns An object containing:
- *   - isValid: boolean indicating if all required environment variables are present.
- *   - missing: an array of missing environment variable names.
- */
-function checkRequiredEnvVars(): { isValid: boolean; missing: string[] } {
-	const missing = REQUIRED_ENV_VARS.filter((envName) => !process.env[envName]);
-
-	if (missing.length > 0) {
-		GriddoLog.error(`Missing required environment variables: ${missing.join(", ")}`);
-		return { isValid: false, missing };
-	}
-
-	return { isValid: true, missing: [] };
-}
-
-/**
- * Check if environment variables have the expected values.
- *
- * @returns An object containing:
- *   - isValid: boolean indicating if all required environment variables have the expected values.
- *   - mismatches: an array of mismatched environment variable names and their expected and actual values.
- */
-function checkEnvVarValues(): {
-	isValid: boolean;
-	mismatches: { key: string; expected: string; actual: string }[];
-} {
-	const mismatches: { key: string; expected: string; actual: string }[] = [];
-
-	for (const { key, expected } of REQUIRED_ENV_VALUES) {
-		const actual = process.env[key];
-
-		if (actual !== expected) {
-			mismatches.push({ key, expected, actual: actual || "(undefined)" });
-		}
-	}
-
-	if (mismatches.length > 0) {
-		return { isValid: false, mismatches };
-	}
-
-	return { isValid: true, mismatches: [] };
-}
-
-/**
- * Check recommended environment variables and show warnings for missing ones.
- *
- * @returns An object containing:
- *   - isValid: boolean indicating if all recommended environment variables are set.
- *   - missing: an array of missing recommended environment variable names.
- */
-function checkRecommendedEnvVars() {
-	const missing = RECOMMENDED_ENV_VARS.filter(({ key }) => !process.env[key]);
-
-	if (missing.length > 0) {
-		GriddoLog.warn("Recommended environment variables not set:");
-
-		for (const { key, description } of missing) {
-			const desc = description ? ` # ${description}` : "";
-			GriddoLog.log(`     -> ${key}${desc}`);
-		}
-	}
-}
-
-/**
- * Check if set enviroment variables have been deprecated
- *
- * @returns An object containing:
- *   - deprecated: an array of deprecated environment variable names.
- */
-function checkDeprecatedEnvVars() {
-	const deprecated = DEPRECATED_ENV_VARS.filter(({ key }) => process.env[key]);
-
-	if (deprecated.length > 0) {
-		const deprecatedMessages = deprecated.map(({ key, description }) => {
-			const desc = description ? ` # ${description}` : "";
-			return `  ${key}${desc}`;
-		});
-
-		GriddoLog.warn("Deprecated environment variables set:");
-		GriddoLog.warn(`${deprecatedMessages.join("\n")}\n`);
-	}
-
-	return { deprecated: deprecated.map((key) => key) };
-}
-
-/**
- * Check if the environment is secure to launch a render.
- * If something fails then log an error message and exit from the process.
- * Otherwise just return true.
- *
- * @returns A boolean indicating if the environment is secure to launch a render.
- */
-function checkEnvironmentHealth() {
-	// Check required environment variables
-	const envVarsCheck = checkRequiredEnvVars();
-	const envValuesCheck = checkEnvVarValues();
-
-	// (warnings only)
-	checkRecommendedEnvVars();
-	checkDeprecatedEnvVars();
-
-	// Render is safe if all required checks pass
-	const isSafeToRender = envVarsCheck.isValid && envValuesCheck.isValid;
-
-	if (isSafeToRender) {
-		GriddoLog.info("Build health check passed");
-		return true;
-	}
-
-	// Generate consolidated error message
-	const allIssues: string[] = [];
-
-	if (!envVarsCheck.isValid) {
-		allIssues.push(`Missing: ${envVarsCheck.missing.join(", ")}`);
-	}
-
-	if (!envValuesCheck.isValid) {
-		const mismatchMessages = envValuesCheck.mismatches.map(
-			({ key, expected, actual }) => `${key}="${actual || "undefined"}" (expected "${expected}")`,
-		);
-		allIssues.push(`Incorrect values:\n  ${mismatchMessages.join("\n  ")}`);
-	}
-
-	// Show what needs to be set
-	const requiredVarsMessage = REQUIRED_ENV_VALUES.map(({ key, expected, description }) => {
-		const desc = description ? ` # ${description}` : "";
-		return `  ${key}="${expected}"${desc}`;
-	}).join("\n");
-
-	GriddoLog.error(`Environment health check failed:`);
-	GriddoLog.error(`  ${allIssues.join("\n  ")}`);
-	GriddoLog.warn("\nRequired environment variables:");
-	GriddoLog.error(requiredVarsMessage);
-
-	throwError(CheckHealthError);
-}
-
-export { checkEnvironmentHealth };

package/exporter/core/db-class.ts

@@ -1,54 +0,0 @@
-import type { RenderDB } from "../shared/types/render";
-
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { pkgDirSync } from "../shared/npm-modules/pkg-dir";
-import { GriddoLog } from "./GriddoLog";
-
-// Interfaz para abstraer la DB
-export interface Database {
-	read(): Promise<RenderDB>;
-	write(renderDB: RenderDB): Promise<void>;
-}
-
-export class JsonDatabase implements Database {
-	private readonly dbFilePath: string;
-
-	constructor(customDBPath?: string) {
-		this.dbFilePath =
-			customDBPath ??
-			path.join(
-				pkgDirSync({ cwd: path.resolve(__dirname, "../../..") }) ?? "",
-				".griddo/cache/db.json",
-			);
-	}
-
-	async read(customDBFilePath?: string): Promise<RenderDB> {
-		try {
-			const raw = await fsp.readFile(customDBFilePath || this.dbFilePath, "utf-8");
-			return JSON.parse(raw) as RenderDB;
-		} catch (error) {
-			if (error instanceof Error) {
-				GriddoLog.error(`Error reading DB file at ${this.dbFilePath}:`, error.message);
-			} else {
-				GriddoLog.error(`Unknown error reading DB file at ${this.dbFilePath}:`, error);
-			}
-			throw error;
-		}
-	}
-
-	async write(renderDB: RenderDB): Promise<void> {
-		try {
-			await fsp.mkdir(path.dirname(this.dbFilePath), { recursive: true });
-			await fsp.writeFile(this.dbFilePath, JSON.stringify(renderDB, null, "\t"));
-		} catch (error) {
-			if (error instanceof Error) {
-				GriddoLog.error(`Error writing to DB file at ${this.dbFilePath}:`, error.message);
-			} else {
-				GriddoLog.error(`Unknown error writing to DB file at ${this.dbFilePath}:`, error);
-			}
-			throw error;
-		}
-	}
-}

package/exporter/core/db.ts

@@ -1,33 +0,0 @@
-import type { RenderDB } from "../shared/types/render";
-
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { pkgDirSync } from "../shared/npm-modules/pkg-dir";
-import { GriddoLog } from "./GriddoLog";
-
-const root = pkgDirSync({ cwd: path.resolve(__dirname, "../../..") }) || "";
-const cache = path.join(root, ".griddo/cache");
-const dbFilePath = path.join(cache, "db.json");
-
-async function readDB(customDBPath = "") {
-	const file = customDBPath || dbFilePath;
-	try {
-		return JSON.parse(await fsp.readFile(file, "utf-8")) as RenderDB;
-	} catch (error) {
-		GriddoLog.error(`Failed to read DB file at ${file}:`, error);
-		throw error;
-	}
-}
-
-async function writeDB(renderDB: RenderDB, customDBPath = "") {
-	const file = customDBPath || dbFilePath;
-	try {
-		await fsp.writeFile(file, JSON.stringify(renderDB, null, "\t"));
-	} catch (error) {
-		GriddoLog.error(`Failed to write DB file at ${file}:`, error);
-		throw error;
-	}
-}
-
-export { readDB, writeDB };

package/exporter/core/dist-rollback.ts

@@ -1,49 +0,0 @@
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { readDB } from "./db";
-import { pathExists } from "./fs";
-import { GriddoLog } from "./GriddoLog";
-
-/**
- * Rolls back the exports directory for the given domain.
- *
- * - Deletes the potentially corrupt exports directory for the domain.
- * - If a backup exists, it restores the directory from the backup location.
- * - If no backup is found, it informs that a fresh exports directory will be created on the next render.
- *
- * @param domain The domain for which to rollback the exports directory.
- */
-async function distRollback(domain: string): Promise<void> {
-	const data = await readDB();
-	const { exportsDir, exportsDirBackup } = data.paths;
-
-	GriddoLog.info(`Cleaning exports dir for the domain ${domain}`);
-	GriddoLog.verbose(`Deleting ${path.join(exportsDir, domain)}...`);
-
-	// TODO: Probar rsync en lugar de borrar y copiar
-
-	// 1 - Borrar dist corrupto
-	await fsp.rm(path.join(exportsDir, domain), {
-		recursive: true,
-		force: true,
-	});
-
-	// 2 - Si hay backup, restaurar
-	if (await pathExists(path.join(exportsDirBackup, domain))) {
-		await fsp.cp(path.join(exportsDirBackup, domain), path.join(exportsDir, domain), {
-			recursive: true,
-		});
-
-		GriddoLog.info(`export-backup dir for the domain ${domain} found. Restoring before exit...`);
-		GriddoLog.verbose(
-			`Copying ${path.join(exportsDirBackup, domain)} -> ${path.join(exportsDir, domain)}...`,
-		);
-	} else {
-		GriddoLog.info(
-			"No export-backup found, skipping rollback. Next render will create a new exports dir from scratch...",
-		);
-	}
-}
-
-export { distRollback };

package/exporter/core/errors.ts

@@ -1,92 +0,0 @@
-import type { ErrorsType } from "../shared/errors";
-
-import path from "node:path";
-
-import { brush } from "../shared/npm-modules/brush";
-import { readDB, writeDB } from "./db";
-import { distRollback } from "./dist-rollback";
-import { GriddoLog } from "./GriddoLog";
-
-export type ErrorData = {
-	error: ErrorsType;
-	message: string;
-	expected?: string;
-	hint?: string;
-};
-
-export class RenderError extends Error {
-	constructor(originalError?: unknown) {
-		super(originalError instanceof Error ? originalError.message : String(originalError));
-
-		this.name = "InternalCXError";
-		this.stack = originalError instanceof Error ? originalError.stack : "";
-	}
-}
-
-/**
- * Throws an error with the provided error message, expected value, and hint.
- */
-function throwError(options: ErrorData, stack?: unknown): never {
-	const { error, message, expected, hint } = options;
-
-	const errorColor = GriddoLog.log(brush.red(`[ ${error} ]`));
-	const extraText = [expected, hint].filter(Boolean).join("\n");
-
-	GriddoLog.log(`
-${errorColor}
-${message}
-${extraText}
-
-${brush.red("stack")}
-${JSON.stringify(stack, null, 2)}`);
-
-	throw new RenderError(stack);
-}
-
-/**
- * Executes the provided asynchronous function and handles errors that occur during execution.
- *
- * - If an error is thrown, attempts to log the error and, if necessary, rolls back the exports directory.
- * - Updates the render database to set the domain's rendering state to "ERROR" if an error occurs.
- *
- * @param fn - The asynchronous function to execute within the error handler.
- * @returns A promise that resolves when the function is executed successfully.
- * @throws RenderError | unknown - Rethrows the original error after handling and database state update.
- */
-async function withErrorHandler(fn: () => Promise<void>) {
-	try {
-		await fn();
-	} catch (error) {
-		if (error instanceof RenderError) {
-			GriddoLog.error("Internal Griddo RenderError");
-		} else if (error instanceof Error) {
-			GriddoLog.error(error.message);
-		} else {
-			GriddoLog.error(`An unexpected error occurred ${error}`);
-		}
-
-		// Try to rollback the exports directory if needed
-		try {
-			const data = await readDB();
-			const { root } = data.paths;
-			if (data.needsRollbackOnError) {
-				GriddoLog.info("Cleaning exports dir...");
-				GriddoLog.verbose(`Deleting ${path.join(root, "exports")}...`);
-
-				await distRollback(data.currentRenderingDomain!);
-			} else {
-				GriddoLog.info("No rollback needed, skipping...");
-			}
-		} catch (_e) {
-			GriddoLog.info("Early render stage, no db.json created yet...");
-		}
-
-		const data = await readDB();
-		data.domains[data.currentRenderingDomain!].isRendering = false;
-		data.domains[data.currentRenderingDomain!].renderMode = "ERROR";
-		await writeDB(data);
-		throw error;
-	}
-}
-
-export { throwError, withErrorHandler };