@griddo/cx 1.75.179 → 1.75.181

package/src/utils/shared.ts

@@ -0,0 +1,155 @@
+// External libraries
+import chalk from "chalk";
+import dotenv from "dotenv";
+import fs from "fs-extra";
+import gradient from "gradient-string";
+import { APIResponses } from "../types/api";
+import { version } from "../../package.json";
+
+dotenv.config();
+
+// Envs
+const GRIDDO_BUILD_LOGS =
+	!!process.env.GRIDDO_BUILD_LOGS &&
+	!!JSON.parse(process.env.GRIDDO_BUILD_LOGS);
+
+/**
+ * Walk a directory and returns the file pathts.
+ *
+ * @param dir A directory path.
+ */
+function walk(dir: string) {
+	const results: Array<string> = [];
+	const list = fs.readdirSync(dir);
+	list.forEach((file) => {
+		const newLocalFile = `${dir}/${file}`;
+		results.push(newLocalFile);
+	});
+
+	return results;
+}
+
+/**
+ * Custom log inside a line-box.
+ *
+ * @param str The string to be logged.
+ */
+function logBox(str: string) {
+	const len = str.length;
+	const minWidth = str.length + 2;
+	const margin = " ".repeat(Math.floor((minWidth - len) / 2));
+	const borderTop = `╭${"─".repeat(minWidth)}╮\n`;
+	const borderBottom = `\n╰${"─".repeat(minWidth)}╯`;
+	const content = `│${margin}${str}${margin}│`;
+
+	console.log(`${borderTop}${content}${borderBottom}`);
+}
+
+/**
+ * Custom basic logging function controlled by a environment variable.
+ *
+ * @params str The string or strings separated by commans to be logged.
+ */
+function logInfo(...str: Array<unknown>) {
+	if (GRIDDO_BUILD_LOGS) {
+		console.info(...str);
+	}
+}
+
+/**
+ * Custom delay using the "promise hack",
+ *
+ * @param ms Amount of miliseconds to be delayed
+ */
+function delay(ms: number) {
+	return new Promise((res) => setTimeout(res, ms));
+}
+
+/**
+ * Return a scale size colors with a number and a measure string (KB by default).
+ *
+ * @param size The page size in KB.
+ * @param measure The measure string to be added in the log.
+ */
+function logPageSize(size: number, measure = "KB") {
+	const sizeScale = {
+		low: 50,
+		mid: 80,
+		large: 130,
+		extraLarge: 210,
+	};
+
+	// Ternary pawa!
+	const color =
+		size > sizeScale.large
+			? "red"
+			: size > sizeScale.mid
+			? "magenta"
+			: size > sizeScale.low
+			? "blue"
+			: "green";
+
+	return chalk[color].bold(`${size}${measure}`);
+}
+
+/**
+ * Converts milliseconds to seconds with a fixed number of decimals.
+ *
+ * @param ms The number in milliseconds.
+ * @param fixed The amount of fixed decimals.
+ * @returns The converted number in seconds with the fixed number of decimals.
+ */
+export function msToSec(ms: number, decimals = 3) {
+	return (ms / 1000).toFixed(decimals);
+}
+
+/**
+ * Return a siteID from a response object if exist
+ * @param response A response object
+ */
+export function getSafeSiteId(response: APIResponses) {
+	return "site" in response && response.site ? response?.site : undefined;
+}
+
+/**
+ * Print a f**king great Griddo builder logo.
+ */
+function splash() {
+	const logo = `
+··
+··     ______  ______ _____ ______  ______   _____
+··    |  ____ |_____/   |   |     \\ |     \\ |     |
+··    |_____| |    \\_ __|__ |_____/ |_____/ |_____|
+··    ______  _     _ _____        ______  _______  ______
+··    |_____] |     |   |   |      |     \\ |______ |_____/
+··    |_____] |_____| __|__ |_____ |_____/ |______ |    \\_
+··
+··    ${version}
+`;
+
+	console.log(gradient.cristal(logo));
+}
+
+function exporterLogo() {
+	const logo = `
+··
+··                                                               /
+··                                                             / //
+··       ______  ______ _____ ______  ______   _____           /· /
+··      |  ____ |_____/   |   |     \\ |     \\ |     |       / · /  /
+··      |_____| |    \\_ __|__ |_____/ |_____/ |_____|   · · /    / · /
+··      _______ _     _  _____   _____   ______ _______ _______  ______
+··      |______  \\___/  |_____] |     | |_____/    |    |______ |_____/
+··      |______ _/   \\_ |       |_____| |    \\_    |    |______ |    \\_
+··
+··      Griddo exporter orchestrator              /  / / ·  / /
+··      ${version}                                 /  / /· /
+··                                                  /· /
+··                                                /
+··
+`;
+
+	console.log(gradient.cristal(logo));
+}
+
+export { delay, exporterLogo, logBox, logInfo, logPageSize, splash, walk };

package/src/utils/sites.ts

@@ -0,0 +1,279 @@
+// Types
+import type { BuildProcessData } from "../types/global";
+import type { Site, SiteData } from "../types/sites";
+
+// External libraries
+import chalk from "chalk";
+import fs from "fs-extra";
+import { parse } from "js2xmlparser";
+import path from "path";
+
+// Services
+import { AuthService } from "../services/auth";
+import { SitesService } from "../services/sites";
+
+// Utils
+import { AllPagesResponse } from "../types/api";
+import { deleteSites } from "./folders";
+import { logInfo } from "./shared";
+
+// Envs
+const API_URL = process.env.API_URL;
+const GRIDDO_RENDER_ALL_SITES = !!process.env.GRIDDO_RENDER_ALL_SITES;
+const GRIDDO_RENDER_SITE =
+	process.env.GRIDDO_RENDER_SITE && parseInt(process.env.GRIDDO_RENDER_SITE);
+const GRIDDO_RENDER_PAGES = (process.env.GRIDDO_RENDER_PAGES || "")
+	.split(",")
+	.map((item) => parseInt(item))
+	.filter(Boolean);
+
+/**
+ * Check the instance sites and returns site prepared to be published and unpublished.
+ */
+async function checkSites() {
+	console.log(`🔗 API URL ${chalk.underline(API_URL as string)}`);
+
+	// Login to API
+	await AuthService.login();
+
+	// Get all sites. An array of Site
+	const allSites = await SitesService.getAll();
+	// Filter the array of sites to get only the ones to build/render
+	const validSites = GRIDDO_RENDER_ALL_SITES
+		? allSites.filter(
+				(site) => !GRIDDO_RENDER_SITE || site.id === GRIDDO_RENDER_SITE
+		  )
+		: allSites.filter((site) =>
+				GRIDDO_RENDER_SITE
+					? site.id === GRIDDO_RENDER_SITE
+					: !!site.shouldBeUpdated
+		  );
+
+	// If there are valid sites...
+	if (validSites.length) {
+		const promisesOfValidSites = validSites.map(async (site) => {
+			const langResponse = await SitesService.getLanguages(site.id);
+
+			return (site.domains = langResponse.items
+				.filter((item) => {
+					return (
+						item.domain &&
+						(!process.env.DOMAIN ||
+							item.domain.slug.indexOf(process.env.DOMAIN) > 0)
+					);
+				})
+				.map((item) => ({ [item.id]: `${item.domain.slug}${item.path}` })));
+		});
+
+		await Promise.all(promisesOfValidSites);
+	}
+
+	// Save sites object to publish
+	const sitesToPublish = validSites.filter((site) =>
+		GRIDDO_RENDER_SITE
+			? site.id === GRIDDO_RENDER_SITE
+			: !!site.isPublished && site.domains.length > 0
+	);
+
+	// Save sites object to unpublish
+	const sitesToUnpublish = validSites.filter(
+		(site) => !site.isPublished && site.shouldBeUpdated
+	);
+
+	return {
+		sitesToPublish,
+		sitesToUnpublish,
+	};
+}
+
+/**
+ * Unpublish an array of sites in two steps:
+ * - Sending the information to the API
+ * - Removing the files from the file system
+ *
+ * @param sites An array of sites
+ */
+async function unpublishSites(sites: Array<Site>) {
+	for (const site of sites) {
+		const buildInfo = await SitesService.startSiteRender(site.id);
+		const { siteHash } = buildInfo;
+		const body = {
+			siteHash,
+			publishHashes: [],
+			unpublishHashes: [],
+		};
+
+		logInfo("Unpublish site starts", buildInfo);
+
+		await SitesService.endSiteRender(site.id, body);
+	}
+
+	await deleteSites(sites);
+}
+
+/**
+ * Return a single site generic data.
+ *
+ * @param siteID The site id.
+ * @param cached Boolean that indicates if we want to get cache version.
+ *
+ * @see SiteData
+ */
+async function getSiteData(siteID: number, cached: boolean) {
+	const buildData = await SitesService.startSiteRender(siteID);
+	const siteInfo = await SitesService.getInfo(siteID, cached);
+	const siteLangs = await SitesService.getLanguages(siteID, cached);
+	const socials = await SitesService.getSocials(siteID, cached);
+	const siteLangsInfo = siteLangs.items;
+	const defaultLang = siteLangsInfo.find((lang) => lang.isDefault);
+	// eliminado para validar que efectivamente no rompe nada
+	// si el cambio es correcto, hay que eliminar las 7 líneas que contienen "sitePages"
+	// const sitePages = await SitesService.getPages(siteID, cached);
+	const sitePages: AllPagesResponse = [];
+
+	const { siteHash, unpublishHashes, publishIds } = buildData;
+	const { headers, footers } = siteInfo;
+	const validPagesIds = GRIDDO_RENDER_PAGES.length
+		? GRIDDO_RENDER_PAGES.filter((item) => publishIds.includes(item))
+		: publishIds;
+
+	const siteData: SiteData = {
+		siteInfo,
+		validPagesIds,
+		siteHash,
+		unpublishHashes,
+		siteLangs: siteLangsInfo,
+		defaultLang,
+		headers,
+		footers,
+		socials,
+		sitePages,
+	};
+
+	return siteData;
+}
+
+/**
+ * Send end render signal to the API for all pages.
+ *
+ * @param buildProcessData The whole build process data.
+ * @param createdPages An array of pages ids.
+ */
+async function setPagesRenderEnd(
+	buildProcessData: BuildProcessData,
+	createdPages: Array<number>
+) {
+	const promises = Object.keys(buildProcessData).map(async (siteID) => {
+		const body = buildProcessData[siteID];
+
+		logInfo(`Deploying ending call to site ${siteID}:`);
+
+		return SitesService.endSiteRender(parseInt(siteID), body);
+	});
+
+	await Promise.all(promises);
+
+	logInfo(`Set pages as deployed. Total ${createdPages.length}`);
+}
+
+/**
+ * Generate sitemaps and save them into file system.
+ *
+ * @param sites An array of sites
+ */
+async function generateSitemaps(sites: Array<Site>) {
+	const promisesOfSites = sites.map(async (site) => {
+		const { id: siteID, languages } = site;
+
+		const promisesOfLanguages = languages.map(async (lang) => {
+			if (AuthService.headers) AuthService.headers["lang"] = lang.id.toString();
+
+			const response = await SitesService.getSitemap(siteID);
+
+			if (!response) return;
+
+			const {
+				items: sitemapPagesGroup,
+				url: { home },
+			} = response;
+
+			if (!home) return;
+
+			const langDomain = site.domains.find(
+				(domain) => Object.keys(domain)[0] == lang.id.toString()
+			);
+
+			if (!langDomain) return;
+
+			const slug = Object.values(langDomain)[0];
+			const sitemaps = [];
+			const sitemapPageGroupKeys = Object.keys(sitemapPagesGroup);
+
+			for (const templateId of sitemapPageGroupKeys) {
+				const sitemapPages = sitemapPagesGroup[templateId];
+
+				if (!sitemapPages.length) continue;
+
+				const siteMap = parse("urlset", {
+					"@": {
+						xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9",
+						"xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
+						"xsi:schemaLocation":
+							"http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd",
+					},
+					url: sitemapPages,
+				});
+				const sitemapName = `/sitemap-${templateId.toLowerCase()}.xml`;
+				const exactPath = path.resolve(
+					__dirname,
+					`../../public/${slug}${sitemapName}`
+				);
+
+				saveFile(exactPath, siteMap);
+
+				sitemaps.push(
+					`${home.endsWith("/") ? home.slice(0, -1) : home}${sitemapName}`
+				);
+			}
+
+			if (!sitemaps.length) return;
+
+			const siteMap = parse("sitemapindex", {
+				"@": { xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9" },
+				sitemap: sitemaps.map((loc) => ({ loc })),
+			});
+			const exactPath = path.resolve(
+				__dirname,
+				`../../public/${slug}/sitemap.xml`
+			);
+
+			saveFile(exactPath, siteMap);
+		});
+
+		return Promise.all(promisesOfLanguages);
+	});
+
+	await Promise.all(promisesOfSites);
+}
+
+/**
+ * Saves the content to a file specified by its path. If the file exists, it will be overwritten.
+ *
+ * @param filePath The path of the file to save the content to.
+ * @param content The content to save to the file.
+ */
+function saveFile(filePath: string, content: string) {
+	try {
+		fs.writeFileSync(filePath, content);
+	} catch (err) {
+		console.error(`Error saving file: ${err}`);
+	}
+}
+
+export {
+	checkSites,
+	unpublishSites,
+	setPagesRenderEnd,
+	getSiteData,
+	generateSitemaps,
+};

package/.babelrc

@@ -1,7 +0,0 @@
-{
-  "presets": [["@babel/env", { "modules": false }], "@babel/react"],
-  "plugins": [
-    "babel-plugin-styled-components",
-    "@babel/plugin-proposal-class-properties"
-  ]
-}

package/LICENSE

@@ -1 +0,0 @@
-NO LICENSE YET

package/gatsby-browser.js

@@ -1,115 +0,0 @@
-/* eslint-disable node/no-extraneous-require */
-/* eslint-disable node/no-missing-require */
-const React = require('react');
-const { browser } = require('components');
-const { SessionProvider } = require('@griddo/core');
-
-exports.disableCorePrefetching = () => {
-  if (browser.disableCorePrefetching) {
-    browser.disableCorePrefetching();
-  }
-};
-
-exports.onClientEntry = () => {
-  if (browser.onClientEntry) {
-    browser.onClientEntry();
-  }
-};
-
-exports.onInitialClientRender = () => {
-  if (browser.onInitialClientRender) {
-    browser.onInitialClientRender();
-  }
-};
-
-exports.onPostPrefetchPathname = props => {
-  if (browser.onPostPrefetchPathname) {
-    browser.onPostPrefetchPathname(props);
-  }
-};
-
-exports.onPreRouteUpdate = props => {
-  if (browser.onPreRouteUpdate) {
-    browser.onPreRouteUpdate(props);
-  }
-};
-
-exports.onPrefetchPathname = props => {
-  if (browser.onPrefetchPathname) {
-    browser.onPrefetchPathname(props);
-  }
-};
-
-exports.onRouteUpdateDelayed = props => {
-  if (browser.onServiceWorkerActive) {
-    browser.onRouteUpdateDelayed(props);
-  }
-};
-
-exports.onServiceWorkerActive = props => {
-  if (browser.onServiceWorkerActive) {
-    browser.onServiceWorkerActive(props);
-  }
-};
-
-exports.onServiceWorkerInstalled = props => {
-  if (browser.onServiceWorkerInstalled) {
-    browser.onServiceWorkerInstalled(props);
-  }
-};
-
-exports.onServiceWorkerRedundant = props => {
-  if (browser.onServiceWorkerRedundant) {
-    browser.onServiceWorkerRedundant(props);
-  }
-};
-
-exports.onServiceWorkerUpdateFound = props => {
-  if (browser.onServiceWorkerUpdateFound) {
-    browser.onServiceWorkerUpdateFound(props);
-  }
-};
-
-exports.onServiceWorkerUpdateReady = props => {
-  if (browser.onServiceWorkerUpdateReady) {
-    browser.onServiceWorkerUpdateReady(props);
-  }
-};
-
-exports.registerServiceWorker = () => {
-  if (browser.registerServiceWorker) {
-    browser.registerServiceWorker();
-  }
-};
-
-exports.replaceHydrateFunction = () => {
-  if (browser.replaceHydrateFunction) {
-    browser.replaceHydrateFunction();
-  }
-};
-
-exports.shouldUpdateScroll = props => {
-  if (browser.shouldUpdateScroll) {
-    browser.shouldUpdateScroll(props);
-  }
-};
-
-exports.wrapPageElement = props => {
-  if (browser.wrapPageElement) {
-    return browser.wrapPageElement(props);
-  }
-};
-
-exports.wrapRootElement = props => {
-  return (
-    <SessionProvider>
-      {browser.wrapRootElement ? browser.wrapRootElement(props) : props.element}
-    </SessionProvider>
-  );
-};
-
-exports.onRouteUpdate = props => {
-  if (browser.onRouteUpdate) {
-    browser.onRouteUpdate(props);
-  }
-};

package/gatsby-config.js

@@ -1,38 +0,0 @@
-const computils = require('./src/utils/component-lib-helpers');
-
-require('dotenv').config();
-
-const assetPrefix = process.env.ASSET_PREFIX || undefined;
-
-// Gatsby configuration file from client
-const { plugins, ...gatsbyConfig } = require(computils.resolveComponentsPath(
-  'builder.config.js'
-));
-
-const CONFIG = {
-  // cliente config
-  ...gatsbyConfig,
-  plugins: [
-    // client plugins
-    ...plugins,
-
-    // defaults plugins
-    'gatsby-plugin-provide-react',
-    'gatsby-plugin-react-svg',
-    'gatsby-plugin-react-helmet',
-    'gatsby-plugin-no-sourcemaps',
-    {
-      resolve: 'gatsby-plugin-remove-generator',
-      options: {
-        content: 'Griddo',
-      },
-    },
-  ],
-};
-
-if (assetPrefix) {
-  CONFIG.assetPrefix = assetPrefix;
-  CONFIG.pathPrefix = null;
-}
-
-module.exports = CONFIG;