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

package/cli.mjs

@@ -1,231 +0,0 @@
-#!/usr/bin/env node
-
-import { execSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-function getRoot(rootFlag) {
-	if (rootFlag) {
-		return path.resolve(rootFlag);
-	}
-	return path.resolve(__dirname, "../../");
-}
-
-function getDBPath(rootFlag) {
-	return path.join(getRoot(rootFlag), ".griddo/cache/db.json");
-}
-
-const COMMANDS_PATH = path.join(__dirname, "build/commands");
-
-export const AVAILABLE_COMMANDS = [
-	{
-		name: "render",
-		description: "Render the instance",
-		domainArgument: "optional",
-		rootArgument: false,
-		script: "render-full-instance",
-		isCommandPack: true,
-		commandPack: renderCommandPack,
-	},
-	{
-		name: "prepare-assets-directory",
-		description: "Prepare assets directory (internal local only)",
-		domainArgument: true,
-		script: "prepare-assets-directory",
-		rootArgument: true,
-		isCommandPack: false,
-	},
-	{
-		name: "prepare-domains-render",
-		description: "Prepare domains",
-		domainArgument: false,
-		script: "prepare-domains-render",
-		rootArgument: true,
-		isCommandPack: false,
-	},
-	{
-		name: "start-render",
-		description: "Start rendering for a domain",
-		domainArgument: true,
-		script: "start-render",
-		rootArgument: false,
-		isCommandPack: false,
-	},
-	{
-		name: "end-render",
-		description: "End rendering for a domain",
-		domainArgument: true,
-		script: "end-render",
-		isCommandPack: false,
-		rootArgument: true,
-	},
-	{
-		name: "upload-search-content",
-		description: "Upload search content for a domain",
-		domainArgument: false,
-		script: "upload-search-content",
-		isCommandPack: false,
-		rootArgument: true,
-	},
-	{
-		name: "reset-render",
-		description: "Reset render state",
-		domainArgument: false,
-		script: "reset-render",
-		isCommandPack: false,
-		rootArgument: false,
-	},
-];
-
-function showHelp() {
-	console.log("Griddo CX CLI - Available commands:\n");
-
-	AVAILABLE_COMMANDS.forEach((cmd) => {
-		const domainArg = cmd.domainArgument ? " --domain=<domain>" : "";
-		console.log(`  ${cmd.name}${domainArg} --root=<path> - ${cmd.description}`);
-	});
-
-	console.log("\nUsage:");
-	console.log("  node cli.mjs <command> --root=<path> [--domain=<domain>]");
-	console.log("  node cli.mjs --help");
-	console.log("\nExamples:");
-	console.log("  node cli.mjs render --domain=pro-pikachu --root=. ");
-	console.log("  node cli.mjs start-render --domain=mydomain.com --root=some-path");
-	console.log("  node cli.mjs prepare-domains-render --root=. ");
-	console.log("  node cli.mjs --help");
-}
-
-function findCommand(commandName) {
-	return AVAILABLE_COMMANDS.find((cmd) => cmd.name === commandName);
-}
-
-function validateCommand(commandName, config) {
-	const command = findCommand(commandName);
-
-	if (!command) {
-		console.error(`Error: Unknown command '${commandName}'`);
-		console.error("Use 'node cli.mjs --help' to see available commands");
-		process.exit(1);
-	}
-
-	if (!config.root && command.rootArgument) {
-		console.error(`Error: --root flag is required`);
-		console.error(`Usage: node cli.mjs ${commandName} --root=<path>`);
-		process.exit(1);
-	}
-
-	if (command.domainArgument === true && !config.domain) {
-		console.error(`Error: Command '${commandName}' requires a --domain argument`);
-		console.error(`Usage: node cli.mjs ${commandName} --domain=<domain> --root=<path>`);
-		process.exit(1);
-	}
-
-	if (command.domainArgument === false && config.domain) {
-		console.warn(
-			`Warning: Command '${commandName}' doesn't require a domain, ignoring '${config.domain}'`,
-		);
-	}
-
-	// Creamos un nuevo config validado para asegurar que el dominio se pasa solo cuando es necesario
-	const validatedConfig = {
-		...config,
-		domain: command.domainArgument ? config.domain : undefined,
-	};
-
-	return { command, config: validatedConfig };
-}
-
-function executeCommand(command, config) {
-	try {
-		const env = { ...process.env };
-		const scriptPath = path.join(COMMANDS_PATH, command.script);
-
-		if (command.isCommandPack) {
-			command.commandPack(config);
-			return;
-		}
-
-		const commandToRun = `node ${scriptPath}${config.domain ? ` ${config.domain}` : ""}`;
-
-		execSync(commandToRun, {
-			stdio: "inherit",
-			env,
-			cwd: process.cwd(),
-		});
-	} catch (error) {
-		console.error(`Error executing command ${command.name}`);
-		throw error;
-	}
-}
-
-function renderCommandPack(config) {
-	// Pequeño helper para no repetir la lógica de búsqueda y ejecución
-	const run = (commandName, domainOverride) => {
-		const commandToRun = findCommand(commandName);
-		// Pasamos una copia del config con el dominio que necesite este comando en particular
-		const runConfig = { ...config, domain: domainOverride ?? config.domain };
-		if (commandToRun) {
-			executeCommand(commandToRun, runConfig);
-		}
-	};
-
-	try {
-		run("prepare-domains-render", null);
-
-		let domainsToProcess = [];
-		if (config.domain) {
-			domainsToProcess = [config.domain];
-		} else {
-			const { sortedDomains } = JSON.parse(fs.readFileSync(getDBPath(config.root), "utf-8"));
-			domainsToProcess = sortedDomains;
-		}
-
-		for (const domain of domainsToProcess) {
-			run("start-render", domain);
-			run("prepare-assets-directory", domain);
-			run("end-render", domain);
-		}
-
-		// All domains
-		run("upload-search-content");
-	} catch (error) {
-		console.error("An error occurred during the render process:", error);
-		run("reset-render", null);
-	}
-}
-
-function main() {
-	const options = {
-		help: { type: "boolean", short: "h" },
-		domain: { type: "string" },
-		root: { type: "string" },
-	};
-
-	const { values, positionals } = parseArgs({
-		args: process.argv.slice(2),
-		options,
-		allowPositionals: true,
-	});
-
-	const commandName = positionals[0];
-
-	if (!commandName || values.help) {
-		showHelp();
-		return;
-	}
-
-	const initialConfig = {
-		domain: values.domain,
-		root: values.root,
-	};
-
-	const { command, config } = validateCommand(commandName, initialConfig);
-
-	executeCommand(command, config);
-}
-
-main();

package/exporter/build-esbuild.noop

@@ -1,42 +0,0 @@
-#!/usr/bin/env bash
-
-# Build CX script file
-#
-# This file generates the necessary builds for CX.
-# - Setup, to generate necessary elements (tsconfig, etc..)
-# - Library, CX library that will be used by the SSG framework.
-# - Scripts, CX scripts that will be used by infra during the render process.
-#
-# @todo:
-# In the future, we will try to eliminate the bundling processes and use
-# TypeScript or ESModules directly.
-
-# start
-echo "📦 Building ..."
-
-# CLI options
-log="--log-level=error"
-production_node_opts="--bundle --platform=node --minify --sourcemap"
-debugging_node_opts="--bundle --platform=node --sourcemap"
-# react_opts="--platform=node --external:@griddo-instance --external:react --external:react-dom --bundle --minify"
-
-# Manage --minify for debugging
-bundle_node_opts=$production_node_opts
-if [ "$1" = "--debug" ]; then
-    bundle_node_opts=$debugging_node_opts
-fi
-
-# library
-# esbuild ${log} ./exporter/index.ts ${bundle_node_opts} --outfile=./build/index.js
-# esbuild ${log} ./exporter/react/index.tsx ${react_opts} --outfile=./build/react/index.js
-
-# scripts
-esbuild ${log} ./exporter/commands/end-render.ts ${bundle_node_opts} --outfile=./build/end-render.js
-esbuild ${log} ./exporter/commands/upload-search-content.ts ${bundle_node_opts} --outfile=./build/upload-search-content.js
-esbuild ${log} ./exporter/commands/reset-render.ts ${bundle_node_opts} --outfile=./build/reset-render.js
-esbuild ${log} ./exporter/commands/start-render.ts ${bundle_node_opts} --outfile=./build/start-render.js
-esbuild ${log} ./exporter/commands/prepare-domains-render.ts ${bundle_node_opts} --outfile=./build/prepare-domains-render.js
-esbuild ${log} ./exporter/commands/prepare-assets-directory.ts ${bundle_node_opts} --outfile=./build/prepare-assets-directory.js
-
-# types
-tsc --emitDeclarationOnly --declaration --outDir build --project tsconfig.exporter.json

package/exporter/commands/README.md

@@ -1,151 +0,0 @@
-# Comandos del Orquestador Griddo CX
-
-Este directorio contiene los comandos principales de Griddo Exporter (CX). Estos comandos forman parte del ciclo de vida completo del proceso de render de una instancia.
-
-La recomendación es llamarlos mediante el cli `node cli.mjs <comand-name> [options]`
-
-## Listado de comandos.
-
-### 1. `prepare-domains-render.ts`
-
-**Propósito**: Prepara los dominios para el proceso de renderizado.
-
-**Funcionalidades principales**:
-- Inicializa el entorno de renderizado creando la estructura de base de datos local (db.json)
-- Obtiene la lista de dominios disponibles desde la API
-- Calcula el número de páginas por dominio analizando sitios para publicar/despublicar
-- Determina el modo de renderizado para cada dominio (basado en si tiene contenido pendiente)
-- Ordena los dominios por número de páginas para optimizar el procesamiento
-- Crea archivos de configuración (`domains.json`) para uso de infraestructura (A deprecar: infra deberá leer db.json para obtener esa información)
-
-**Uso típico**: Se ejecuta antes de cualquier proceso de renderizado para preparar el estado inicial.
-
-**Características técnicas**:
-- No requiere argumentos (proceso global)
-- Crea la carpeta `.griddo` si no existe donde le indiquemos cuando le pasemos `--root` desde el cli.
-
-
-### 2. `start-render.ts`
-
-**Propósito**: Ejecuta el ciclo completo de renderizado para uno o múltiples dominios.
-
-**Funcionalidades principales**:
-- Autenticación con la API de Griddo
-- Verificación del estado de salud del entorno
-- Ejecución del proceso Gatsby para generar sitios estáticos
-- Soporte para modo legacy (múltiples dominios) y modo moderno (dominio específico)
-
-**Uso**:
-```bash
-# Modo moderno (recomendado)
-start-render <dominio>
-
-# Modo legacy (múltiples dominios)
-start-render
-```
-
-**Características técnicas**:
-- Puede procesar un dominio específico o todos los dominios disponibles
-- Utiliza el adaptador Gatsby para la generación de sitios
-- Requiere autenticación previa con la API
-
-### 3. `end-render.ts`
-
-**Propósito**: Finaliza el ciclo de renderizado notificando a la API sobre los cambios realizados.
-
-**Funcionalidades principales**:
-- Lee el reporte de construcción generado por Gatsby
-- Procesa cada sitio del dominio indicando qué se publicó/despublicó
-- Envía llamadas de finalización a la API para cada sitio
-- Maneja modos IDLE para sitios sin cambios
-
-**Uso**:
-```bash
-# Modo moderno
-end-render <dominio>
-
-# Modo legacy
-end-render
-```
-
-**Características técnicas**:
-- Lee `build-report.json` generado durante el proceso de construcción
-- Elimina hashes duplicados antes del envío
-- Puede saltar dominios marcados como IDLE
-
-### 4. `upload-search-content.ts`
-
-**Propósito**: Sube el contenido de las páginas generadas para el uso posterior en los buscadores de Griddo.
-
-**Funcionalidades principales**:
-- Extrae contenido de las páginas HTML generadas
-- Limpia el contenido HTML removiendo etiquetas, scripts y elementos no deseados
-- Procesa archivos `page-data.json` de Gatsby para obtener metadatos
-- Envía el contenido indexable a la API de búsqueda
-- Soporte opcional para embeddings de IA
-
-**Características técnicas**:
-- Solo se ejecuta si `GRIDDO_SEARCH_FEATURE` está habilitado
-- Procesa recursivamente directorios `page-data` y `public`
-- Normaliza el contenido eliminando múltiples espacios y saltos de línea
-- Envía datos estructurados: título, descripción, imagen, URL, contenido, template
-
-**Configuración**:
-- Activado por `GRIDDO_SEARCH_FEATURE=true`
-- Embeddings de IA con `GRIDDO_AI_EMBEDDINGS=true`
-
-### 5. `reset-render.ts`
-
-**Propósito**: Resetea el estado de renderizado en el sistema remoto.
-
-**Funcionalidades principales**:
-- Envía una llamada a la API para resetear el estado de renderizado
-- Útil para limpiar estados inconsistentes o errores de procesamiento
-
-**Uso típico**: Se utiliza cuando hay problemas con el estado del renderizado que requieren un reinicio limpio.
-
-**Características técnicas**:
-- No requiere argumentos
-- Comunicación directa con el endpoint `RESET_RENDER`
-- Operación atómica que afecta el estado global
-
-### 6. `prepare-assets-directory.ts` (USO SOLO EN DESARROLLO LOCAL)
-
-**Propósito**: Prepara el directorio de assets para un dominio específico.
-
-**Funcionalidades principales**:
-- Reorganiza la estructura de directorios de assets
-- Mueve assets desde ubicación compartida a ubicación específica del dominio
-
-**Uso**:
-```bash
-prepare-assets-directory <dominio>
-```
-
-**Características técnicas**:
-- Mueve el directorio `assets` compartido al directorio específico del dominio
-- Operación de bajo nivel para organización de archivos estáticos
-- Elimina y recrea la estructura según sea necesario
-
-## Flujo de Uso Típico
-
-1. **`prepare-domains-render`** - Preparar el entorno y obtener dominios
-2. **`start-render`** - Ejecutar la generación de sitios para un dominio
-3. **`end-render`** - Notificar finalización y cambios a la API
-4. **`upload-search-content`** - Subir contenido para búsqueda (si está habilitado)
-5. **`prepare-assets-directory`** - Organizar assets (si es necesario)
-
-## Variables de Entorno Relevantes
-
-- `GRIDDO_RENDER_BY_DOMAINS`: Habilita modo legacy para múltiples dominios
-- `GRIDDO_SEARCH_FEATURE`: Habilita subida de contenido para búsqueda
-- `GRIDDO_AI_EMBEDDINGS`: Habilita generación de embeddings de IA
-- `GRIDDO_API_URL`: URL base de la API de Griddo
-- `GRIDDO_BOT_USER` / `GRIDDO_BOT_PASSWORD`: Credenciales de autenticación
-
-## Notas de Desarrollo
-
-- Todos los comandos utilizan manejo de errores consistente a través de `withErrorHandler`
-- La mayoría requiere autenticación previa con `AuthService.login()`
-- Los comandos modernos esperan un argumento de dominio específico
-- El modo legacy permite procesamiento masivo pero está deprecated

package/exporter/commands/prepare-assets-directory.ts

@@ -1,34 +0,0 @@
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { withErrorHandler } from "../core/errors";
-import { pathExists } from "../core/fs";
-import { GriddoLog } from "../core/GriddoLog";
-import { getRenderModeFromDB, getRenderPathsHydratedWithDomainFromDB } from "../services/render";
-
-async function prepareAssetsDir() {
-	const [domain] = process.argv.slice(2);
-
-	const { renderMode } = await getRenderModeFromDB(domain);
-
-	if (renderMode === "IDLE") {
-		return;
-	}
-
-	const { __exports } = await getRenderPathsHydratedWithDomainFromDB({ domain });
-	const assetsDir = path.join(__exports, "assets");
-	const domainAssetsDir = path.join(__exports, domain);
-
-	if (await pathExists(assetsDir)) {
-		await fsp.rm(domainAssetsDir, { force: true, recursive: true });
-		await fsp.rename(assetsDir, domainAssetsDir);
-	} else {
-		GriddoLog.warn("Assets directory not found");
-	}
-}
-
-async function main() {
-	await prepareAssetsDir();
-}
-
-withErrorHandler(main);

package/exporter/commands/single-domain-upload-search-content.ts

@@ -1,206 +0,0 @@
-import type { PostSearchInfoResponse } from "../shared/types/api";
-import type { PostSearchInfoProps } from "../shared/types/global";
-import type { GatsbyPageData } from "../ssg-adapters/gatsby/shared/types";
-
-import fsp from "node:fs/promises";
-import path from "node:path";
-
-import { throwError, withErrorHandler } from "../core/errors";
-import { pathExists } from "../core/fs";
-import { GriddoLog } from "../core/GriddoLog";
-import { post } from "../services/api";
-import { AuthService } from "../services/auth";
-import { getRenderModeFromDB, getRenderPathsHydratedWithDomainFromDB } from "../services/render";
-import { SEARCH } from "../shared/endpoints";
-import { GRIDDO_SEARCH_FEATURE } from "../shared/envs";
-import { ReadFromStoreError, UploadSearchError } from "../shared/errors";
-import { RENDER_MODE } from "../shared/types/render";
-
-/**
- * Save in the BBDD the content of a page parsed without HTML tags.
- *
- * @param props Object with parts of the final page object to be saved in the BBDD.
- */
-async function postSearchInfo(props: PostSearchInfoProps) {
-	const { title, description, image, pageId, languageId, siteId, url, content, template } = props;
-
-	const response = await post<PostSearchInfoResponse>({
-		endpoint: SEARCH,
-		body: {
-			title,
-			description,
-			image,
-			pageId,
-			languageId,
-			siteId,
-			url,
-			template,
-			content,
-		},
-		useApiCacheDir: false,
-		logToFile: false,
-	});
-
-	return response;
-}
-
-function prepareHTMLContentForSearch(content: string): string {
-	// 1. Remove script, style, and other unwanted block tags and their content.
-	// The regex looks for <tag...>...</tag> where tag is one of the specified ones.
-	const tagsToRemove = ["meta", "link", "style", "script", "noscript", "nav", "header", "footer"];
-	const removeTagsRegex = new RegExp(`<(${tagsToRemove.join("|")})\\b[^>]*>.*?<\\/\\1>`, "gis");
-	let processedContent = content.replace(removeTagsRegex, "");
-
-	// 2. Strip all remaining HTML tags.
-	processedContent = processedContent.replace(/<[^>]+>/g, " ");
-
-	// 3. Normalize whitespace: replace multiple spaces/newlines with a single space and trim.
-	processedContent = processedContent.replace(/\s+/g, " ").trim();
-
-	return processedContent;
-}
-
-async function getContentDirectories(domain: string) {
-	const { __exports } = await getRenderPathsHydratedWithDomainFromDB({ domain });
-
-	return {
-		htmlContentDir: path.join(__exports, "dist"),
-		jsonContentDir: path.join(__exports, "dist", "page-data"),
-	};
-}
-
-/**
- * Walk recursively in a basePath and return an array of pages with json
- * extension with the full absolute path and the path includes "page-data".
- *
- * @param basePath The path to walk recursively.
- * @returns An array of pages with json extension with the full absolute path
- * and the path includes "page-data".
- */
-async function* walkRecursively(basePath: string): AsyncGenerator<string> {
-	const filesHandle = await fsp.opendir(basePath);
-
-	for await (const fileDirent of filesHandle) {
-		if (fileDirent.isDirectory()) {
-			yield* walkRecursively(path.join(basePath, fileDirent.name));
-		} else if (
-			fileDirent.isFile() &&
-			path.extname(fileDirent.name) === ".json" &&
-			fileDirent.name.includes("page-data")
-		) {
-			yield path.join(basePath, fileDirent.name);
-		}
-	}
-}
-
-/**
- * Walk recursively in a basePath and return an array of pages with json
- * extension with the full absolute path and the path includes "page-data".
- *
- * @param basePath The path to walk recursively.
- * @returns An array of pages with json extension with the full absolute path
- * and the path includes "page-data".
- */
-async function* getPageDataPagesFromExports<PageType extends GatsbyPageData>(
-	basePath: string,
-): AsyncGenerator<PageType> {
-	const jsonFiles = walkRecursively(basePath);
-
-	for await (const filePath of jsonFiles) {
-		try {
-			const fileContent = await fsp.readFile(filePath, "utf8");
-			const page = JSON.parse(fileContent) as PageType;
-
-			if (page.path) {
-				yield page;
-			}
-		} catch (error) {
-			throwError(ReadFromStoreError, error);
-		}
-	}
-}
-
-/**
- * Function that search in the `/public` dir the content info of the pages and
- * send it to the search table in the ddbb using the API.
- * @todo Utilizar la carpeta page-data en lugar de la carpeta store puesto que
- * esta ya no es persistente.
- */
-async function uploadRenderedSearchContentToAPI(options: {
-	htmlContentDir: string;
-	jsonContentDir: string;
-}) {
-	const { htmlContentDir, jsonContentDir } = options;
-
-	if (!(await pathExists(jsonContentDir)) || !(await pathExists(htmlContentDir))) {
-		GriddoLog.info(
-			`(From Current Render) Skipping uploading content to the search endpoint because it has not exported sites.`,
-		);
-
-		return;
-	}
-
-	// Get pages from gatsby page-data dir
-	const gatsbyPageDataPages = getPageDataPagesFromExports(jsonContentDir);
-
-	for await (const pageData of gatsbyPageDataPages) {
-		const { result } = pageData;
-		const { pageContext } = result;
-		const { page, openGraph, pageMetadata } = pageContext;
-
-		const { compose } = page.fullPath;
-
-		const htmlPath = path.resolve(`${htmlContentDir}/${compose}/index.html`);
-		const htmlContent = await fsp.readFile(htmlPath, "utf-8");
-
-		const pageObject: PostSearchInfoProps = {
-			siteId: page.site,
-			pageId: page.id,
-			// `pageMetadata.title` has already a fallback `metatitle ||
-			// pageTitle` so probably `title` never will be take the
-			// `openGraph?.title` value. Only when the `metatitle` and
-			// `pageTitle` are empty.
-			title: pageMetadata?.title || openGraph?.title,
-			languageId: page.language,
-			url: page.fullUrl,
-			template: page.template.templateType || page.templateId,
-			description: pageMetadata?.description || openGraph?.description,
-			image: openGraph.image,
-			// _content: prepareHTMLContentForSearch(htmlContent),
-			content: prepareHTMLContentForSearch(htmlContent),
-		};
-
-		try {
-			await postSearchInfo(pageObject);
-		} catch (error) {
-			throwError(UploadSearchError, error);
-		}
-	}
-}
-
-async function uploadSearchContent() {
-	const [domain] = process.argv.slice(2);
-	const { renderMode, reason } = await getRenderModeFromDB(domain);
-
-	if (renderMode === RENDER_MODE.IDLE) {
-		GriddoLog.info(
-			`(From Current Render) [${domain}]: Skipping upload-search-content as it is marked as IDLE with the reason ${reason}.`,
-		);
-		return;
-	}
-
-	const { htmlContentDir, jsonContentDir } = await getContentDirectories(domain);
-	await uploadRenderedSearchContentToAPI({
-		htmlContentDir,
-		jsonContentDir,
-	});
-}
-
-async function main() {
-	if (GRIDDO_SEARCH_FEATURE) {
-		await AuthService.login();
-		await uploadSearchContent();
-	}
-}
-
-withErrorHandler(main);