@griddo/cx 1.75.179 → 1.75.181

package/src/types/global.ts

@@ -0,0 +1,64 @@
+// Types
+import type { Core, Fields } from "@griddo/core";
+import type { EndSiteRenderBody } from "./api";
+
+export type StoreMode = "memory" | "file";
+
+export interface Settings {
+	apiVersion?: string;
+	avoidCanonicalsOnSitemaps?: boolean;
+	avoidDebugMetas?: boolean;
+	avoidHrefLangsOnCanonicals?: boolean;
+	avoidHrefLangXDefault?: boolean;
+	avoidSelfReferenceCanonicals?: boolean;
+	cloudinaryName?: string;
+	forceMenuLinksLanguage?: boolean;
+	globalLogoBig?: string;
+	globalLogoMini?: string;
+	lastDBCheckVersion?: string;
+	schemasTimestamp?: string;
+	schemasVersion?: string;
+	showBasicMetaRobots?: boolean;
+	siteLogoBig?: string;
+	siteLogoMini?: string;
+	skipReviewOnPublish?: boolean;
+	useMetaTitle?: boolean;
+	welcomeText1?: string;
+	welcomeText2?: string;
+}
+
+/** ??? */
+export type Petition = Record<string, unknown>;
+
+export interface PostSearchInfoProps {
+	title?: string;
+	description: string;
+	image: string;
+	pageId?: number;
+	siteId: number;
+	content: string;
+	languageId?: number;
+	template?: string | null | number;
+	url?: string;
+}
+
+export interface FetchDataProps {
+	page: Core.Page;
+	component: {
+		data: Fields.Reference<unknown>;
+	};
+	cached: boolean;
+}
+
+export type Domains = Array<{
+	id: number;
+	slug: string;
+	url: string;
+}>;
+
+/** Describes the type of build process data object. */
+export type BuildProcessData = Record<string, EndSiteRenderBody>;
+
+export type Robot = { path: string; content: string };
+
+export type Robots = Array<Robot>;

package/src/types/navigation.ts

@@ -0,0 +1,25 @@
+/** Describes a Griddo Header */
+export type Header = {
+	component: "Header";
+	id: number;
+	isDefault: boolean;
+	language: number;
+	navigationLanguages: Array<{ navigationId: number }>;
+	setAsDefault: boolean;
+	theme: null | string;
+	title: string;
+	type: "header";
+};
+
+/** Describes a Griddo Footer */
+export type Footer = {
+	component: "Footer";
+	id: number;
+	isDefault: boolean;
+	language: number;
+	navigationLanguages: Array<{ navigationId: number }>;
+	setAsDefault: boolean;
+	theme: null | string;
+	title: string;
+	type: "header";
+};

package/src/types/pages.ts

@@ -0,0 +1,145 @@
+// Types
+import type { Core, Fields } from "@griddo/core";
+import type { SocialsResponse } from "./api";
+import type { Settings } from "./global";
+import type { Site } from "./sites";
+
+// TODO: In @griddo/core the type Core.Page has header/footer as React-Types,
+// but API return `number | null`.
+export type APIPageObject = Core.Page & {
+	header: number | null;
+	footer: number | null;
+};
+
+export type CleanPage = Core.Page & {
+	isRoot: boolean;
+	defaultLang?: Core.SiteLanguage | undefined;
+};
+
+export type RenderPage = Core.Page & {
+	isRoot?: boolean;
+	multiPageElements: MultiPageElements;
+	defaultLang?: Core.SiteLanguage;
+	header: number;
+	footer: number;
+	//
+	id: number;
+	path: string;
+	component: "Page";
+	template_id: string;
+	mode: "list";
+};
+
+export type GriddoSinglePage = Core.Page & {
+	defaultLang?: Core.SiteLanguage;
+};
+
+export type GriddoListPage = Core.Page & {
+	page: APIPageObject;
+	pages: Array<Array<Fields.QueriedDataItem>>;
+	isRoot?: boolean;
+	defaultLang?: Core.SiteLanguage;
+	template: {
+		[key: string]: any;
+		type: "template";
+		templateType: string;
+		activeSectionSlug: string;
+		activeSectionBase: string;
+	};
+	totalQueriedItems: Array<Fields.QueriedDataItem>;
+};
+
+export type GriddoMultiPage = Core.Page & {
+	header: number | null;
+	footer: number | null;
+	isRoot?: boolean;
+	multiPageElements: MultiPageElements;
+	defaultLang?: Core.SiteLanguage | undefined;
+};
+
+export interface AdditionalInfo {
+	baseUrl: string;
+	BUILD_MODE?: string;
+	cloudinaryName?: string;
+	griddoVersion: string;
+	instance?: string;
+	publicBaseUrl: string;
+	siteLangs: Array<Core.SiteLanguage>;
+	siteMetadata: Site["siteMetadata"];
+	siteSlug: string;
+	socials: SocialsResponse;
+	siteOptions: Pick<
+		Settings,
+		| "useMetaTitle"
+		| "showBasicMetaRobots"
+		| "avoidHrefLangsOnCanonicals"
+		| "avoidSelfReferenceCanonicals"
+		| "avoidHrefLangXDefault"
+		| "avoidDebugMetas"
+	>;
+	siteScript: string;
+	theme: string;
+}
+
+export interface PageAdditionalInfo extends AdditionalInfo {
+	navigations: {
+		header: Record<string, unknown> | null;
+		footer: Record<string, unknown> | null;
+	};
+}
+
+export type GatsbyPageObject = {
+	matchPath?: string;
+	path: string;
+	component: string;
+	/** Page size in bytes */
+	size: number;
+	context: {
+		// Page
+		BUILD_MODE?: string;
+		cloudinaryName?: string;
+		footer: Record<string, unknown> | null;
+		fullPath: Core.Page["fullPath"];
+		griddoVersion: string;
+		header: Record<string, unknown> | null;
+		id?: number;
+		languageId: number;
+		locale?: string;
+		openGraph: {
+			description?: string;
+			image?: string | null;
+			title?: string;
+			twitterImage?: string | null;
+			type: "website";
+		};
+		pageMetadata: {
+			canonical?: string | undefined;
+			description?: string;
+			follow?: "follow" | "nofollow";
+			index: "index" | "noindex";
+			locale?: string;
+			metasAdvanced?: string;
+			pageLanguages?: Core.Page["pageLanguages"];
+			title?: string;
+			translate?: "notranslate" | "";
+			url?: string;
+		};
+		siteMetadata: Site["siteMetadata"];
+		theme: string;
+		title: string;
+		siteLangs: Array<Core.SiteLanguage>;
+		siteOptions: AdditionalInfo["siteOptions"];
+		siteScript: string;
+		socials: SocialsResponse;
+	};
+};
+
+export type MultiPageElements = Array<{
+	component: string;
+	title: string | Required<Fields.Heading>;
+	elements: Array<Record<string, unknown>>;
+	componentModules: Array<Record<string, unknown>>;
+	sectionSlug: string;
+	metaTitle: string;
+	metaDescription: string;
+}>;

package/src/types/sites.ts

@@ -0,0 +1,64 @@
+// Types
+import type { Core } from "@griddo/core";
+import type { AllPagesResponse, SocialsResponse } from "./api";
+import type { Footer, Header } from "./navigation";
+
+/**
+ * Describe a Griddo site object from API.
+ * This takes some type props from Core.Site which is a Site for the Gatsby template.tsx.
+ */
+export interface Site
+	extends Required<
+		Pick<
+			Core.Site,
+			| "bigAvatar"
+			| "favicon"
+			| "home"
+			| "id"
+			| "isPublished"
+			| "timezone"
+			| "thumbnail"
+			| "theme"
+			| "socials"
+			| "slug"
+			| "smallAvatar"
+			| "modified"
+			| "name"
+			| "siteMetadata"
+		>
+	> {
+	author: string;
+	deleted: number;
+	domains: Array<Record<string, string>>;
+	footers: Array<Footer>;
+	hash: string | null;
+	headers: Array<Header>;
+	languages: Array<Core.SiteLanguage>; // in Core is Array<number>
+	languageSites: Array<number>;
+	navigationModules: { header?: string; footer?: string } | null;
+	pages: Array<number>;
+	published: string;
+	rendering: boolean;
+	renderingHours: number;
+	shouldBeUpdated: boolean;
+	siteScript: string;
+	smallAvatar: string;
+	updated: boolean;
+}
+
+export interface SiteData {
+	siteInfo: Site;
+	validPagesIds: number[];
+	siteHash: string | null;
+	unpublishHashes: string[];
+	siteLangs: Array<Core.SiteLanguage>;
+	defaultLang: Core.SiteLanguage | undefined;
+	headers: Array<Header>;
+	footers: Array<Footer>;
+	socials: SocialsResponse;
+	sitePages: AllPagesResponse;
+}
+
+export type SiteHash = string | null;
+
+export type HashSites = Record<string, number | string>;

package/src/types/templates.ts

@@ -0,0 +1,11 @@
+// Types
+import type { Core, Fields } from "@griddo/core";
+
+/** Describe a template object from a Griddo Page */
+export type Template = Core.Page["template"];
+
+/** Describes a template with distributor data */
+export type TemplateWithDistributor = Template & {
+	queriedItems?: Fields.QueriedData<unknown>;
+	itemsPerPage?: number;
+};

package/src/utils/api.ts

@@ -0,0 +1,325 @@
+// Types
+import type {
+	APIResponses,
+	Error,
+	GetAPI,
+	PostAPI,
+	PutAPI,
+} from "../types/api";
+
+// External libraries
+import axios from "axios";
+import chalk from "chalk";
+import dotenv from "dotenv";
+
+// Services
+import { AuthService } from "../services/auth";
+
+// Utils
+import { getCache, saveCache } from "./cache";
+import { delay, getSafeSiteId, logInfo, msToSec } from "./shared";
+
+dotenv.config();
+
+// Envs
+const {
+	env: { RETRY_WAIT_SECONDS = "4", RETRY_ATTEMPTS = "1" },
+} = process;
+
+/**
+ * Make a GET 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.
+ * @todo Maybe remove the loggin responsability
+ * @example
+ *	const response = await get<Site>({
+ *		endpoint: "...",
+ *		cached: true,
+ *	});
+ */
+async function getApi<T extends APIResponses>(props: GetAPI): Promise<T> {
+	const { endpoint, body, cached, attempt } = props;
+	const cacheOptions = { endpoint, body, cached };
+
+	// Start a timer
+	const start = new Date();
+
+	// Filesystem
+	if (cached) {
+		const cachedResponse = getCache<T>(cacheOptions);
+
+		if (cachedResponse) {
+			const duration = msToSec(new Date().getTime() - start.getTime());
+			const siteId = getSafeSiteId(cachedResponse);
+			const siteIdMsg = siteId ? `site: ${siteId} ` : "";
+
+			logInfo(`GET  (cache) ${siteIdMsg}${endpoint} - ${duration}s`);
+
+			return cachedResponse;
+		}
+	}
+
+	// Network API
+	try {
+		// Success. Connection stablished.
+		const { data }: { data: T } = await axios({
+			url: endpoint,
+			method: "get",
+			headers: { ...AuthService.headers },
+			data: body,
+		});
+
+		const duration = msToSec(new Date().getTime() - start.getTime());
+		const siteId = getSafeSiteId(data);
+		const siteIdMsg = siteId ? `site: ${siteId} ` : "";
+
+		logInfo(`GET  (fetch) ${siteIdMsg}${endpoint} - ${duration}s`);
+
+		// Save page object into filesystem
+		saveCache(cacheOptions, data);
+
+		// Return page object from API
+		return data;
+	} catch (e) {
+		// Failure. Network error
+		const error = e as Error;
+		showApiError(
+			error,
+			{ endpoint, body, attempt },
+			error.response.status !== 404
+		);
+
+		if (error.response.status === 404) {
+			// @ts-expect-error
+			return null;
+		}
+
+		// Try again `RETRY_ATTEMPTS` times
+		if (attempt && attempt < parseInt(RETRY_ATTEMPTS)) {
+			console.warn("Waiting for retry: GET", endpoint);
+			await delay(parseInt(RETRY_WAIT_SECONDS) * 1000);
+
+			// Lets try again!
+			return getApi({ endpoint, body, cached, attempt: attempt + 1 });
+		} else {
+			throw new Error("Error in getApi()");
+		}
+	}
+}
+
+/**
+ * Make a PUT 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.
+ */
+async function putApi<T extends APIResponses>(props: PutAPI): Promise<T> {
+	const { endpoint, body, cached = false, attempt = 0 } = props;
+	const cacheOptions = { endpoint, body, cached };
+
+	// Start a timer
+	const start = new Date();
+
+	// Filesystem
+	if (cached) {
+		const cachedResponse = getCache<T>(cacheOptions);
+
+		if (cachedResponse) {
+			const duration = msToSec(new Date().getTime() - start.getTime());
+
+			logInfo(`PUT  (cache) ${endpoint} - ${duration}s`);
+
+			return cachedResponse;
+		}
+	}
+
+	// Network API
+	try {
+		const { data }: { data: T } = await axios({
+			url: endpoint,
+			method: "put",
+			headers: { ...AuthService.headers },
+			data: body,
+		});
+
+		const duration = msToSec(new Date().getTime() - start.getTime());
+
+		logInfo(`PUT  (fetch) ${endpoint} - ${duration}s`);
+
+		// Save page object to filesystem
+		saveCache(cacheOptions, data);
+
+		// Return page object from API
+		return data;
+	} catch (e) {
+		// Failure. Network error
+		const error = e as Error;
+		showApiError(
+			error,
+			{ endpoint, body, attempt },
+			error.response.status !== 404
+		);
+
+		if (error.response.status === 404) {
+			// @ts-expect-error
+			return null;
+		}
+
+		// Try again `RETRY_ATTEMPTS` times
+		if (attempt < parseInt(RETRY_ATTEMPTS)) {
+			console.warn("Waiting for retry: PUT", endpoint);
+			await delay(parseInt(RETRY_WAIT_SECONDS) * 1000);
+
+			// Lets try again!
+			return putApi({ endpoint, body, cached, attempt: attempt + 1 });
+		} else {
+			throw new Error("Error in putApi()");
+		}
+	}
+}
+
+/**
+ * Make a 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.
+ */
+async function postApi<T extends APIResponses>(props: PostAPI): Promise<T> {
+	const { endpoint, body, headers, cached, attempt = 0 } = props;
+
+	const cacheOptions = { endpoint, body, headers, cached };
+
+	// Start a timer
+	const start = new Date();
+	const distributorBodyParams = endpoint.endsWith("/distributor")
+		? `# Distributor body: ${JSON.stringify(body)} - lang: ${JSON.stringify(
+				headers?.lang
+		  )}`
+		: "";
+
+	// Filesystem
+	if (cached) {
+		const cachedResponse = getCache<T>(cacheOptions);
+
+		if (cachedResponse) {
+			const duration = msToSec(new Date().getTime() - start.getTime());
+
+			logInfo(
+				`POST (cache) ${endpoint} - ${duration}s ${distributorBodyParams}`
+			);
+
+			return cachedResponse;
+		}
+	}
+
+	// Network API
+	try {
+		// Success. Connection stablished.
+		const { data }: { data: T } = await axios({
+			url: endpoint,
+			method: "post",
+			headers: { ...headers, ...AuthService.headers },
+			data: body,
+		});
+
+		const duration = msToSec(new Date().getTime() - start.getTime());
+
+		logInfo(`POST (fetch) ${endpoint} - ${duration}s`);
+
+		// Save page object to filesystem
+		saveCache(cacheOptions, data);
+
+		// Return page object from API
+		return data;
+	} catch (e) {
+		// Failure. Network error
+		const error = e as Error;
+		showApiError(
+			error,
+			{ endpoint, body, headers, attempt },
+			error.response.status !== 404
+		);
+
+		if (error.response.status === 404) {
+			// @ts-expect-error
+			return null;
+		}
+
+		// Try again `RETRY_ATTEMPTS` times
+		if (attempt < parseInt(RETRY_ATTEMPTS)) {
+			console.warn("Waiting for retry: POST", endpoint);
+			await delay(parseInt(RETRY_WAIT_SECONDS) * 1000);
+
+			// Lets try again!
+			return postApi({ endpoint, body, headers, cached, attempt: attempt + 1 });
+		} else {
+			throw new Error("Error in postApi()");
+		}
+	}
+}
+
+/**
+ * Shows an API error through the terminal.
+ */
+function showApiError(
+	error: Error,
+	callInfo: {
+		endpoint?: string;
+		// TODO: Remove any's
+		body?: any;
+		headers?: any;
+		attempt?: number;
+	} = {},
+	breakProcess = true
+) {
+	const { response, message, stack } = error;
+	const { status, statusText, data } = response || {};
+	const callInfoArray = [];
+
+	for (const item of Object.keys(callInfo)) {
+		const itemCasted = item as keyof typeof callInfo;
+		callInfoArray.push(
+			`${item}: ${
+				typeof callInfo[itemCasted] === "object"
+					? JSON.stringify(callInfo[itemCasted])
+					: callInfo[itemCasted]
+			}`
+		);
+	}
+
+	// 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(
+		chalk.bold.red(`
+=============
+
+{ Call info }
+${callInfoStr}
+
+{ API Response }
+${apiResponseStr}
+
+{ Error details }
+${errorDetailsStr}
+
+=============
+`)
+	);
+
+	if (
+		breakProcess &&
+		(typeof callInfo?.attempt !== "number" ||
+			callInfo.attempt >= parseInt(RETRY_ATTEMPTS))
+	) {
+		process.exit(1);
+	}
+}
+
+export { getApi as get, putApi as put, postApi as post };