@griddo/cx 11.9.7-rc.2 → 11.9.8-rc.0

package/exporter/registers/gatsby.ts

@@ -1,14 +0,0 @@
-import { MemoryRegister, Register } from "../services/register";
-
-const entries = {
-	GATSBY_PAGE_SIZE_TOO_BIG: {
-		title: "Gatsby JSON page size is too large",
-		description:
-			"The JSON of some Gatsby pages (page-data folder) are too large and may affect rendering performance",
-		entries: [],
-	},
-};
-
-const register = new Register(new MemoryRegister(entries));
-
-export default register;

package/exporter/registers/index.ts

@@ -1,4 +0,0 @@
-import apiRegister from "./api";
-import gatsbyRegister from "./gatsby";
-
-export { apiRegister, gatsbyRegister };

package/exporter/services/register.ts

@@ -1,113 +0,0 @@
-import fsx from "fs-extra";
-
-type Entry = Record<string, unknown>;
-
-type EntryData = {
-	title: string;
-	description: string;
-	entries: Array<Entry>;
-};
-
-type Entries = Record<string, EntryData>;
-
-interface RegisterBase<T extends Entries> {
-	insert(name: keyof T, entry: Entry): void;
-	get(name: keyof T): EntryData;
-	getAll(): T;
-}
-
-class MemoryRegister<T extends Entries> implements RegisterBase<T> {
-	entries: T;
-
-	constructor(entries: T) {
-		this.entries = entries;
-	}
-
-	insert(name: keyof T, entry: Entry) {
-		this.entries[name].entries.push(entry);
-	}
-
-	get(name: keyof T) {
-		return this.entries[name];
-	}
-
-	getAll() {
-		return this.entries;
-	}
-}
-
-class FileRegister<T extends Entries> implements RegisterBase<T> {
-	private readonly filePath: string;
-	entries: T;
-
-	constructor(filePath: string, entries: T) {
-		this.entries = entries;
-		this.filePath = filePath;
-		try {
-			fsx.writeJSONSync(this.filePath, this.entries);
-		} catch (e) {
-			console.error(`Error writing ${this.filePath}`, e);
-		}
-	}
-
-	private getCurrentEntries(): T {
-		return fsx.readJSONSync(this.filePath, "utf8") as T;
-	}
-
-	insert(name: keyof T, entry: Entry) {
-		try {
-			const currentEntries = this.getCurrentEntries();
-			currentEntries[name].entries.push(entry);
-			fsx.writeJSONSync(this.filePath, currentEntries);
-		} catch (e) {
-			console.error(e);
-		}
-	}
-
-	get(name: keyof T) {
-		try {
-			return fsx.readJSONSync(this.filePath, "utf8")[name] as EntryData;
-		} catch (e) {
-			console.error(e);
-			throw new Error(`Error reading ${this.filePath}`);
-		}
-	}
-
-	getAll() {
-		try {
-			return fsx.readJSONSync(this.filePath, "utf8") as T;
-		} catch (e) {
-			console.error(e);
-			throw new Error(`Error reading ${this.filePath}`);
-		}
-	}
-}
-
-class Register<T extends Entries> {
-	private strategy: RegisterBase<T>;
-
-	constructor(strategy: RegisterBase<T>) {
-		this.strategy = strategy;
-	}
-
-	insert<K extends keyof T>(name: K, entry: Entry) {
-		this.strategy.insert(name, entry);
-	}
-
-	get<K extends keyof T>(name: K) {
-		return this.strategy.get(name);
-	}
-
-	getAll() {
-		return this.strategy.getAll();
-	}
-}
-
-export {
-	FileRegister,
-	MemoryRegister,
-	Register,
-	type Entries,
-	type Entry,
-	type EntryData,
-};

package/exporter/services/settings.ts

@@ -1,17 +0,0 @@
-import type { Settings } from "../types/global";
-
-import { endpoints } from "../constants";
-import { get, post } from "../utils/api";
-
-async function getAllSettings() {
-	return get<Settings>({ endpoint: endpoints.SETTINGS });
-}
-
-async function resetRender() {
-	await post({
-		endpoint: endpoints.RESET_RENDER,
-		useApiCacheDir: false,
-	});
-}
-
-export { getAllSettings, resetRender };

package/exporter/utils/alerts.ts

@@ -1,29 +0,0 @@
-import type { GriddoAlertRegisterProps } from "@griddo/core";
-
-import axios from "axios";
-
-import { endpoints } from "../constants";
-
-// Esta función está duplicada de core de manera intencionada por si esta recibe
-// cambios necesitados solo por CX.
-// Nota: Sí estamos reutilizando el type.
-async function insertAlert({
-	area,
-	description,
-	fullData,
-	instantNotification = false,
-	level,
-}: Omit<GriddoAlertRegisterProps, "publicApiUrl">) {
-	const url = endpoints.ALERT;
-	const body = { level, area, description, fullData, instantNotification };
-
-	try {
-		await axios.post(url, body, {
-			headers: { "Content-Type": "application/json", Connection: "close" },
-		});
-	} catch (error) {
-		console.error("Error creating Griddo alert:", error);
-	}
-}
-
-export { insertAlert };

package/exporter/utils/api.ts

@@ -1,243 +0,0 @@
-import type {
-	APIRequest,
-	APIResponses,
-	GetAPI,
-	PostAPI,
-	PutAPI,
-	ShowApiErrorOptions,
-} from "../types/api";
-import type { AxiosError, Method } from "axios";
-
-import axios from "axios";
-import dotenv from "dotenv";
-import kleur from "kleur";
-
-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;
-
-/**
- * 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: Method,
-	appendToLog = "",
-): Promise<T> {
-	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);
-
-		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}`,
-			);
-			return cacheData;
-		}
-	}
-
-	// 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,
-		});
-
-		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}`,
-		);
-
-		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,
-				});
-			}
-		}
-
-		return data;
-	} catch (e) {
-		const error = e as AxiosError;
-
-		if (error.response?.status === 404) {
-			// @ts-expect-error page maybe will be 404
-			return null;
-		}
-
-		if (attempt > parseInt(RETRY_ATTEMPTS)) {
-			console.log(`
-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)}
---------------------------------------
-`);
-
-			console.log(JSON.stringify(error, null, 2));
-			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 },
-		});
-
-		console.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: AxiosError, options: ShowApiErrorOptions) {
-	const { response, 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]
-			}`,
-		);
-	}
-
-	// 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(`
-=============
-
-{ Call info }
-${callInfoStr}
-
-{ API Response }
-${apiResponseStr}
-
-{ Error details }
-${errorDetailsStr}
-
-=============
-`),
-	);
-}
-
-export { getApi as get, postApi as post, putApi as put };

package/exporter/utils/cache.ts

@@ -1,142 +0,0 @@
-import type { Petition } from "../types/global";
-import type { HashSites, SiteHash } from "../types/sites";
-
-import crypto from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-
-import fsx from "fs-extra";
-
-import { getConfig } from "./core-utils";
-
-const config = getConfig();
-
-/**
- * Creates an `apiCache` dir to store pages fetched from them API.
- */
-function createAPICacheDir() {
-	const { __cx } = config.paths();
-	const apiCacheDir = path.join(__cx, "apiCache");
-
-	if (!fs.existsSync(apiCacheDir)) {
-		fs.mkdirSync(apiCacheDir);
-	}
-
-	console.info("Cache initialized");
-}
-
-/**
- * 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();
-	const apiCacheDir = path.join(__cx, "apiCache");
-
-	const hashSum = crypto.createHash("sha256");
-	hashSum.update(JSON.stringify(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);
-	const filepath = path.dirname(filename);
-	if (!fs.existsSync(filepath)) {
-		fs.mkdirSync(filepath, { recursive: true });
-	}
-	fs.writeFileSync(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
- */
-function searchCacheData<T>(petition: Petition) {
-	try {
-		const file = generateFilenameWithHash(petition);
-		const jsonData = fsx.readJSONSync(file, {
-			encoding: "utf-8",
-		});
-		return jsonData as T;
-	} catch {
-		return null;
-	}
-}
-
-/**
- * Get site hashes from the file as an object
- */
-function getHashSites(): HashSites {
-	const { __cx } = config.paths();
-	const apiCacheDir = path.join(__cx, "apiCache");
-	const siteHasFilename = `${apiCacheDir}/siteHash.json`;
-
-	try {
-		const jsonData = fsx.readJSONSync(siteHasFilename, {
-			encoding: "utf-8",
-		});
-		return jsonData || {};
-	} catch {
-		return {};
-	}
-}
-
-/**
- * Update (write) the site hash file.
- *
- * @param siteId The id of the site.
- * @param siteHash The has of the site.
- */
-function updatedSiteHash(siteId: number, siteHash: SiteHash) {
-	const allHash = getHashSites();
-	const lastHash = allHash[siteId];
-	const currentHash = siteHash || lastHash || new Date().valueOf();
-
-	const { __cx } = config.paths();
-	const apiCacheDir = path.join(__cx, "apiCache");
-	const siteHasFilename = `${apiCacheDir}/siteHash.json`;
-
-	if (currentHash !== lastHash) {
-		allHash[siteId] = currentHash;
-		fs.writeFileSync(siteHasFilename, JSON.stringify(allHash), {
-			encoding: "utf-8",
-		});
-	}
-
-	return currentHash.toString();
-}
-
-export {
-	createAPICacheDir,
-	createSha256,
-	saveCache,
-	searchCacheData,
-	updatedSiteHash,
-};