@griddo/cx 11.7.4 → 11.7.6-rc.0

package/exporter/utils/api.ts

@@ -6,25 +6,16 @@ import type {
 	PutAPI,
 	ShowApiErrorOptions,
 } from "../types/api";
-import type { AxiosError, Method } from "axios";
-
-import axios from "axios";
-import dotenv from "dotenv";
-import kleur from "kleur";
 
+import { AuthService } from "../services/auth";
+import { brush } from "./brush";
 import { saveCache, searchCacheData } from "./cache";
 import { delay, getSafeSiteId, msToSec } from "./core-utils";
 import { buildLog } from "./loggin";
-import { envs } from "../constants";
-import { apiRegister } from "../registers";
-import { AuthService } from "../services/auth";
-
-dotenv.config();
 
 // Envs
-const {
-	env: { RETRY_WAIT_SECONDS = "4", RETRY_ATTEMPTS = "4" },
-} = process;
+const { env } = process;
+const { RETRY_WAIT_SECONDS = "4", RETRY_ATTEMPTS = "4" } = env;
 
 /**
  * Make a GET/PUT/POST request to the Griddo API.
@@ -41,31 +32,22 @@ const {
  */
 async function requestAPI<T extends APIResponses>(
 	props: APIRequest,
-	method: Method,
+	method: string,
 	appendToLog = "",
 ): Promise<T> {
-	const {
-		endpoint,
-		body,
-		cacheKey = "",
-		attempt = 1,
-		headers,
-		useApiCacheDir = true,
-	} = props;
+	const { endpoint, body, cacheKey = "", attempt = 1, headers, useApiCacheDir = true } = props;
 	const cacheOptions = { endpoint, body, headers, cacheKey };
 
 	// Cache
 	if (cacheKey && useApiCacheDir) {
 		const start = new Date();
-		const cacheData = searchCacheData<T>(cacheOptions);
+		const cacheData = await searchCacheData<T>(cacheOptions);
 
 		if (cacheData) {
 			const siteId = getSafeSiteId(cacheData);
 			const siteIdMsg = siteId ? `site: ${siteId}` : "";
-			const duration = msToSec(new Date().getTime() - start.getTime());
-			buildLog(
-				`${method} (cache) ${siteIdMsg} ${endpoint} - ${duration}s ${appendToLog}`,
-			);
+			const duration = msToSec(Date.now() - start.getTime());
+			buildLog(`${method} (cache) ${siteIdMsg} ${endpoint} - ${duration}s ${appendToLog}`);
 			return cacheData;
 		}
 	}
@@ -73,47 +55,46 @@ async function requestAPI<T extends APIResponses>(
 	// Network
 	try {
 		const start = new Date();
-		const {
-			data,
-			headers: responseHeaders,
-		}: { data: T; headers: { "content-length": string } } = await axios({
-			url: endpoint,
-			method,
-			headers: Object.assign({}, headers, AuthService.headers),
-			data: body,
-		});
+
+		// 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();
 
 		const siteId = getSafeSiteId(data);
 		const siteIdMsg = siteId ? `site: ${siteId}` : "";
-		const duration = msToSec(new Date().getTime() - start.getTime());
-		buildLog(
-			`${method} (fetch) ${siteIdMsg} ${endpoint} - ${duration}s ${appendToLog}`,
-		);
+		const duration = msToSec(Date.now() - start.getTime());
+		buildLog(`${method} (fetch) ${siteIdMsg} ${endpoint} - ${duration}s ${appendToLog}`);
 
 		if (useApiCacheDir) {
-			saveCache(cacheOptions, data);
-		}
-
-		// Only save registers if alerts are enabled
-		if (envs.GRIDDO_ALERT_FEATURE) {
-			const responseSize = Number.parseInt(responseHeaders["content-length"]);
-			if (responseSize > envs.GRIDDO_API_MAX_RESPONSE_SIZE) {
-				apiRegister.insert("API_RESPONSE_TOO_BIG", {
-					endpoint,
-					responseSize,
-					duration,
-				});
-			}
+			await saveCache(cacheOptions, data);
 		}
 
 		return data;
 	} catch (e) {
-		const error = e as AxiosError;
-
-		if (error.response?.status === 404) {
-			// @ts-expect-error page maybe will be 404
-			return null;
-		}
+		const error = e as Error;
 
 		if (attempt > parseInt(RETRY_ATTEMPTS)) {
 			console.log(`
@@ -122,7 +103,7 @@ Max attempts ${RETRY_ATTEMPTS} reached
 - ${method.toUpperCase()} ${endpoint}
 - BODY: ${JSON.stringify(body)}
 - HEADERS: ${JSON.stringify(headers)}
-- RESPONSE: ${error.response?.status} ${JSON.stringify(error.response?.data)}
+- ERROR: ${error.message}
 --------------------------------------
 `);
 
@@ -130,12 +111,6 @@ Max attempts ${RETRY_ATTEMPTS} reached
 			process.exit(1);
 		}
 
-		if (!error.response) {
-			console.log("Unknown error occurred");
-			console.log(JSON.stringify(error, null, 2));
-			process.exit(1);
-		}
-
 		showApiError(error, {
 			callInfo: { endpoint, body },
 		});
@@ -188,9 +163,7 @@ 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,
-		)}`;
+		`# ReferenceField body: ${JSON.stringify(body)} lang: ${JSON.stringify(headers?.lang)}`;
 
 	return requestAPI<T>(props, "post", referenceFieldBodyParams || "");
 }
@@ -198,40 +171,31 @@ async function postApi<T extends APIResponses>(props: PostAPI) {
 /**
  * Shows an API error through the terminal.
  */
-function showApiError(error: AxiosError, options: ShowApiErrorOptions) {
-	const { response, message, stack } = error;
+function showApiError(error: Error, options: ShowApiErrorOptions) {
+	const { message, stack } = error;
 	const { callInfo } = options;
-	const { status, statusText, data } = response || {};
 	const callInfoArray = [];
 
 	for (const item of Object.keys(callInfo) as Array<keyof typeof callInfo>) {
 		callInfoArray.push(
 			`${item}: ${
-				typeof callInfo[item] === "object"
-					? JSON.stringify(callInfo[item])
-					: callInfo[item]
+				typeof callInfo[item] === "object" ? JSON.stringify(callInfo[item]) : callInfo[item]
 			}`,
 		);
 	}
 
 	// Compose the errors output
 	const callInfoStr = callInfoArray.join("\n");
-	const apiResponseStr = response
-		? `Code: ${status} - ${statusText}\nResponse: ${JSON.stringify(data)}`
-		: "";
 	const errorDetailsStr = `${message}\n${stack}`;
 
 	// Print the error
 	console.warn(
-		kleur.red(`
+		brush.red(`
 =============
 
 { Call info }
 ${callInfoStr}
 
-{ API Response }
-${apiResponseStr}
-
 { Error details }
 ${errorDetailsStr}
 

package/exporter/{artifacts/index.ts → utils/artifacts.ts}

@@ -2,14 +2,13 @@ import type { Artifacts } from "../types/global";
 
 import path from "node:path";
 
-import { getConfig } from "../utils/core-utils";
+import { getRenderPathsFromDB } from "./render";
 
 /**
  * Returns the artifacts of CX.
  */
-function getCxArtifacts(domain: string): Artifacts {
-	const config = getConfig();
-	const { __cx, __exports, __cache } = config.paths(domain);
+async function getCxArtifacts(domain: string): Promise<Artifacts> {
+	const { __cx, __exports, __cache } = await getRenderPathsFromDB({ domain });
 
 	return {
 		initials: [
@@ -21,13 +20,15 @@ function getCxArtifacts(domain: string): Artifacts {
 		disposables: [
 			path.join(__cx, "store"),
 			path.join(__cx, "apiCache"),
-			path.join(__cx, "render-metadata.json"),
 			path.join(__cx, "dist"),
+			path.join(__cx, "dist-restored"),
 			path.join(__cx, "debug"),
+			path.join(__cx, "assets"),
 		],
-		cacheables: ["apiCache", "store"],
-		archivables: ["dist", "assets", "debug"],
+		cacheables: [],
+		archivables: ["dist", "debug", "assets"],
+		restaurable: ["dist", "debug"],
 	};
 }
 
-export default getCxArtifacts;
+export { getCxArtifacts };

package/exporter/utils/brush.ts

@@ -0,0 +1,34 @@
+//
+// Brush adds color to a string|number, it does not print it!
+// Its simple, no log, no chains, just color in a string|number
+// usage:
+// console.log(brush.green("sucess!"))
+//
+
+const RESET = "\x1b[0m";
+const CODES = {
+	black: "\x1b[30m",
+	red: "\x1b[31m",
+	green: "\x1b[32m",
+	yellow: "\x1b[33m",
+	blue: "\x1b[34m",
+	magenta: "\x1b[35m",
+	cyan: "\x1b[36m",
+	white: "\x1b[37m",
+	gray: "\x1b[90m",
+	bold: "\x1b[1m",
+	dim: "\x1b[2m",
+} as const;
+
+type ColorFunction = (text: string | number) => string;
+type ColorName = keyof typeof CODES;
+type Brush = Record<ColorName, ColorFunction>;
+
+const brush = {} as Brush;
+
+for (const color in CODES) {
+	const key = color as ColorName;
+	brush[key] = (text: string | number) => `${CODES[key]}${text}${RESET}`;
+}
+
+export { brush };

package/exporter/utils/cache.ts

@@ -2,24 +2,21 @@ import type { Petition } from "../types/global";
 import type { HashSites, SiteHash } from "../types/sites";
 
 import crypto from "node:crypto";
-import fs from "node:fs";
+import fsp from "node:fs/promises";
 import path from "node:path";
 
-import fsx from "fs-extra";
-
-import { getConfig } from "./core-utils";
-
-const config = getConfig();
+import { pathExists } from "../utils/folders";
+import { getRenderPathsFromDB } from "./render";
 
 /**
  * Creates an `apiCache` dir to store pages fetched from them API.
  */
-function createAPICacheDir() {
-	const { __cx } = config.paths();
-	const apiCacheDir = path.join(__cx, "apiCache");
+async function createAPICacheDir(options: { basePath: string }) {
+	const { basePath } = options;
+	const apiCacheDir = path.join(basePath, "apiCache");
 
-	if (!fs.existsSync(apiCacheDir)) {
-		fs.mkdirSync(apiCacheDir);
+	if (!(await pathExists(apiCacheDir))) {
+		await fsp.mkdir(apiCacheDir);
 	}
 
 	console.info("Cache initialized");
@@ -27,12 +24,10 @@ function createAPICacheDir() {
 
 /**
  * Generate a filename with a hash using a Petition object
- *
- * @todo Merge with createSha256
  * @param petition An object
  */
-function generateFilenameWithHash(petition: Petition) {
-	const { __cx } = config.paths();
+async function generateFilenameWithHash(petition: Petition) {
+	const { __cx } = await getRenderPathsFromDB();
 	const apiCacheDir = path.join(__cx, "apiCache");
 
 	const hashSum = crypto.createHash("sha256");
@@ -41,35 +36,22 @@ function generateFilenameWithHash(petition: Petition) {
 	return `${apiCacheDir}/${hashSum.digest("hex")}`;
 }
 
-/**
- * Generate a filename with a hash using a string.
- *
- * @todo Merge with generateFilenameWithHash
- * @param data A string to create a sha256 based on.
- */
-function createSha256(data: string) {
-	const uniqueString = crypto.randomBytes(16).toString("hex");
-	const hash = crypto.createHash("sha256");
-	hash.update(`${data}${uniqueString}`);
-
-	return hash.digest("hex");
-}
-
 /**
  * Save a file using a hash name.
  *
  * @param petition An object.
  * @param content Content to be saved.
  */
-function saveCache<T>(petition: Petition, content: T) {
-	const stringContent =
-		typeof content === "string" ? content : JSON.stringify(content);
-	const filename = generateFilenameWithHash(petition);
+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 (!fs.existsSync(filepath)) {
-		fs.mkdirSync(filepath, { recursive: true });
+
+	if (!(await pathExists(filepath))) {
+		await fsp.mkdir(filepath, { recursive: true });
 	}
-	fs.writeFileSync(filename, stringContent, "utf8");
+
+	await fsp.writeFile(filename, stringContent, "utf8");
 }
 
 /**
@@ -78,13 +60,13 @@ function saveCache<T>(petition: Petition, content: T) {
  *
  * @param petition An object
  */
-function searchCacheData<T>(petition: Petition) {
+async function searchCacheData<T>(petition: Petition) {
 	try {
-		const file = generateFilenameWithHash(petition);
-		const jsonData = fsx.readJSONSync(file, {
-			encoding: "utf-8",
-		});
-		return jsonData as T;
+		const file = await generateFilenameWithHash(petition);
+		const fileContent = await fsp.readFile(file, "utf8");
+		const jsonData = JSON.parse(fileContent) as T;
+
+		return jsonData;
 	} catch {
 		return null;
 	}
@@ -93,15 +75,14 @@ function searchCacheData<T>(petition: Petition) {
 /**
  * Get site hashes from the file as an object
  */
-function getHashSites(): HashSites {
-	const { __cx } = config.paths();
+async function getHashSites(): Promise<HashSites> {
+	const { __cx } = await getRenderPathsFromDB();
 	const apiCacheDir = path.join(__cx, "apiCache");
 	const siteHasFilename = `${apiCacheDir}/siteHash.json`;
 
 	try {
-		const jsonData = fsx.readJSONSync(siteHasFilename, {
-			encoding: "utf-8",
-		});
+		const fileContent = await fsp.readFile(siteHasFilename, "utf8");
+		const jsonData = JSON.parse(fileContent);
 		return jsonData || {};
 	} catch {
 		return {};
@@ -114,18 +95,18 @@ function getHashSites(): HashSites {
  * @param siteId The id of the site.
  * @param siteHash The has of the site.
  */
-function updatedSiteHash(siteId: number, siteHash: SiteHash) {
-	const allHash = getHashSites();
+async function updatedSiteHash(siteId: number, siteHash: SiteHash) {
+	const allHash = await getHashSites();
 	const lastHash = allHash[siteId];
-	const currentHash = siteHash || lastHash || new Date().valueOf();
+	const currentHash = siteHash || lastHash || Date.now();
 
-	const { __cx } = config.paths();
+	const { __cx } = await getRenderPathsFromDB();
 	const apiCacheDir = path.join(__cx, "apiCache");
 	const siteHasFilename = `${apiCacheDir}/siteHash.json`;
 
 	if (currentHash !== lastHash) {
 		allHash[siteId] = currentHash;
-		fs.writeFileSync(siteHasFilename, JSON.stringify(allHash), {
+		await fsp.writeFile(siteHasFilename, JSON.stringify(allHash), {
 			encoding: "utf-8",
 		});
 	}
@@ -133,10 +114,4 @@ function updatedSiteHash(siteId: number, siteHash: SiteHash) {
 	return currentHash.toString();
 }
 
-export {
-	createAPICacheDir,
-	createSha256,
-	saveCache,
-	searchCacheData,
-	updatedSiteHash,
-};
+export { createAPICacheDir, saveCache, searchCacheData, updatedSiteHash };

package/exporter/utils/check-health.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+import { CheckHealthError } from "../constants/errors";
+import { isTruthy } from "./core-utils";
+import { throwError } from "./errors";
+
+const GRIDDO_ENVS_VARS: ReadonlyArray<string> = [];
+const GRIDDO_SKIP_BUILD_CHECKS = isTruthy(process.env.GRIDDO_SKIP_BUILD_CHECKS);
+
+/**
+ * Check if a list of environments variables exist with any value.
+ *
+ * @todo Also check the value.
+ * @param envs An array of environments variables
+ * @returns exists with (1) if there are missing envs vars
+ */
+function checkEnvsVars(envs: ReadonlyArray<string>) {
+	const missingEnvs = envs.filter((envName) => {
+		return !process.env[envName];
+	});
+
+	if (missingEnvs.length) {
+		const missingEnvsMsg = missingEnvs.join("\n");
+		console.error(`Env check failed. These envs vars are missing: \n\n${missingEnvsMsg}`);
+
+		return false;
+	}
+
+	return true;
+}
+
+function checkEnvsVarsAndValues(envs: Array<Record<string, string>>): boolean {
+	for (const env of envs) {
+		const [key, expected] = Object.entries(env)[0];
+		const actual = process.env[key];
+
+		if (actual !== expected) {
+			return false;
+		}
+	}
+	return true;
+}
+
+/**
+ * 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.
+ */
+export function checkHealth() {
+	// Bypass the check using this env var, handy for local renders.
+	if (GRIDDO_SKIP_BUILD_CHECKS) {
+		console.info("Build health check skipped");
+
+		return true;
+	}
+
+	// Checklist
+	// check if it's setted
+	const areRequiredEnvsSet = checkEnvsVars(GRIDDO_ENVS_VARS);
+	// check if it's setted and the value
+	const areEnvsMatchingExpected = checkEnvsVarsAndValues([
+		{
+			GRIDDO_RENDER_BY_DOMAINS: "true",
+		},
+	]);
+
+	// Render is safe if...
+	const isSafeToRender = areRequiredEnvsSet && areEnvsMatchingExpected;
+
+	// The environment is suitable for a build-render
+	if (isSafeToRender) {
+		console.info("\nBuild health check passed\n");
+
+		return true;
+	}
+
+	// Error
+	throwError(CheckHealthError);
+}