@griddo/cx 10.4.12 → 10.4.13

package/src/browser/README.md

@@ -0,0 +1,3 @@
+# browser code
+
+browser/index.ts can't contain nodejs code, only browser compatible.

package/src/browser/index.ts

@@ -0,0 +1,46 @@
+import { Core } from "@griddo/core";
+
+function filterBodyIntegrationFromPosition(
+	integrations: Array<Core.PageIntegration>,
+	position: "start" | "end"
+) {
+	return (
+		integrations
+			?.filter(
+				(integration) =>
+					integration.contentBody !== null &&
+					integration.contentBody !== "" &&
+					integration.contentBodyPosition === position
+			)
+			.map((integration) => integration.contentBody!) || []
+	);
+}
+
+function filterHeadIntegrations(integrations: Array<Core.PageIntegration>) {
+	return (
+		integrations
+			?.filter(
+				(integration) =>
+					integration.contentHead !== null && integration.contentHead !== ""
+			)
+			.map((integration) => integration.contentHead!) || []
+	);
+}
+
+function filterPositionIntegrations(
+	integrations: Array<Core.PageIntegration>,
+	position: "head" | "start" | "end"
+) {
+	switch (position) {
+		case "head":
+			return filterHeadIntegrations(integrations);
+		default:
+			return filterBodyIntegrationFromPosition(integrations, position);
+	}
+}
+
+export {
+	filterBodyIntegrationFromPosition,
+	filterHeadIntegrations,
+	filterPositionIntegrations,
+};

package/src/index.ts

@@ -0,0 +1,48 @@
+/**
+ *
+ * Griddo CX library main export file.
+ *
+ * This file exports functions to use in both: adapters and SSG's frameworks.
+ * Turning CX basically in a javascript library.
+ *
+ * # Browser context.
+ * There is another export in the `/browser` directory to use exclusivelly in
+ * the browser context where nodejs (path, fs, etc..) is not available.
+ *
+ * # Render script (bin)
+ * The binary file of the package is `run-start-render.ts`.
+ *
+ * # Separate scripts.
+ * There are some separate .ts files as build-complete.ts or reset-render.ts
+ * that are intended to be used by infra via npm script like `npm run
+ * build-complete`
+ *
+ */
+
+/* prettier-ignore */ import type { SocialsResponse } from "./types/api";
+/* prettier-ignore */ import type { AdditionalInfo, GriddoListPage, GriddoMultiPage, GriddoPageObject, GriddoSinglePage, } from "./types/pages";
+/* prettier-ignore */ import type { Site } from "./types/sites";
+
+/* prettier-ignore */ import { startRender } from "./start-render";
+/* prettier-ignore */ import { IS_COMPONENT_LIBRARY, PROJECT_ALIASES, resolveComponentsPath } from "./utils/instance";
+/* prettier-ignore */ import { logInfo, logPageSize } from "./utils/shared";
+/* prettier-ignore */ import { getBuildPages } from "./utils/store";
+/* prettier-ignore */ import { getConfig } from "./utils/temp-utils";
+
+export {
+	AdditionalInfo,
+	GriddoListPage,
+	GriddoMultiPage,
+	GriddoPageObject,
+	GriddoSinglePage,
+	IS_COMPONENT_LIBRARY,
+	PROJECT_ALIASES,
+	Site,
+	SocialsResponse,
+	getBuildPages,
+	getConfig,
+	logInfo,
+	logPageSize,
+	resolveComponentsPath,
+	startRender,
+};

package/src/move-assets.ts

@@ -0,0 +1,8 @@
+import { execSync } from "child_process";
+import path from "path";
+
+const domainName = "pro-griddo";
+const domainPath = path.resolve(__dirname, `../../exports/sites/${domainName}`);
+
+execSync(`mkdir -p ${domainPath}/assets/${domainName}`);
+execSync(`cp -R ${domainPath}/assets/* ${domainPath}/assets/${domainName}`);

package/src/react/index.ts

@@ -0,0 +1,5 @@
+function Foo() {
+	return null;
+}
+
+export { Foo };

package/src/run-start-render.ts

@@ -0,0 +1,3 @@
+import { startRender } from "./start-render";
+
+startRender();

package/{exporter → src}/services/robots.ts

@@ -64,11 +64,7 @@ class RobotsService {
 		}
 
 		if (fs.existsSync(distDirectory)) {
-			const fileLocation = JSON.parse(
-				process.env.GRIDDO_EXPORT_STRIP_DOMAIN_FROM_PATH || "false"
-			)
-				? path.join(distDirectory, "robots.txt")
-				: path.join(distDirectory, robot.path, "robots.txt");
+			const fileLocation = path.join(distDirectory, "robots.txt");
 			fs.writeFileSync(fileLocation, robot?.content);
 		} else {
 			console.log(`${distDirectory} not found`);

package/{exporter → src}/services/store.ts

@@ -7,6 +7,9 @@ import type {
 	PageAdditionalInfo,
 } from "../types/pages";
 
+import fs from "node:fs";
+import path from "node:path";
+
 import dotenv from "dotenv";
 import pLimit from "p-limit";
 
@@ -14,7 +17,6 @@ import { DistributorService } from "./distributors";
 import { NavigationService } from "./navigation";
 import { SettingsService } from "./settings";
 import { SitesService } from "./sites";
-import { version as griddoVersion } from "../../package.json";
 import { updatedSiteHash } from "../utils/cache";
 import {
 	createGriddoListPages,
@@ -47,6 +49,9 @@ dotenv.config();
  */
 async function createStore(storeDir: string, domain: string) {
 	console.info(`API calls with ${API_CONCURRENCY_COUNT} threads`);
+	const { version: griddoVersion } = JSON.parse(
+		fs.readFileSync(path.resolve(__dirname, "../package.json"), "utf-8")
+	);
 
 	try {
 		// Vars to save later in the report file

package/src/start-render.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/* eslint-disable node/shebang */
+
+import { runGatsbyAdapter } from "./adapters";
+import { logBox, measureExecutionTime } from "./utils/shared";
+
+async function startRender() {
+	const exeTime = await measureExecutionTime(runGatsbyAdapter).catch((e) => {
+		console.log(e);
+		console.log("<[ Render will be reset ]>");
+		process.exit(1);
+	});
+
+	logBox(`All domains rendered in ${exeTime}s.`, "", 1, 0);
+
+	process.exit(0);
+}
+
+export { startRender };

package/{exporter → src}/types/global.ts

@@ -84,11 +84,12 @@ type LifeCyclesNames =
 	| "Relocation"
 	| "Meta"
 	| "Archive"
-	| "Clean";
+	| "Clean"
+	| "__DEBUG__";
 
 type CXDir =
 	| "__exports"
-	| "__cache"
+	| "__caches"
 	| "__cx"
 	| "__ssg"
 	| "__components"
@@ -98,7 +99,7 @@ interface CXConfig {
 	proDomain: string;
 	CXDir: {
 		EXPORTS: "__exports";
-		CACHE: "__cache";
+		CACHE: "__caches";
 		CX: "__cx";
 		SSG: "__ssg";
 		COMPONENTS: "__components";

package/src/utils/folders.ts

@@ -0,0 +1,268 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import fsx, { MakeDirectoryOptions } from "fs-extra";
+
+import { CXRootDir } from "./shared";
+import { getPageInStoreDir, removePagesFromStore } from "./store";
+import { getConfig } from "./temp-utils";
+
+/**
+ * Remove an empty directory from the basePath recursively.
+ * If the directory has only .xml files it will handle as empty too (empty site)
+ *
+ * @param baseDir - The base directory.
+ */
+const clearEmptyDirs = (baseDir?: string) => {
+	const dir = baseDir || path.resolve(CXRootDir, "dist");
+
+	const isDir = fsx.statSync(dir).isDirectory();
+	if (!isDir) {
+		return;
+	}
+
+	// archivos o direvtorios dentro de `dir`
+	let children = fsx.readdirSync(dir);
+	// let children = childrenRaw.filter((file) => {
+	// 	return path.extname(file).toLowerCase() !== ".xml";
+	// });
+	const dirHasChildren = children.length > 0;
+
+	// Por cada uno de ellos miramos si tiene hijos, enviamos cada uno de ellos
+	// a `clearEmptyDirsWithXML`
+	if (dirHasChildren) {
+		const childrenCount = children.length;
+		const xmlCount = children.filter((file) => {
+			return path.extname(file).toLowerCase() === ".xml";
+		}).length;
+
+		// Todos los hijos son archivos .xml
+		// Podemos borrarlos y dejar el dir vacío.
+		if (childrenCount === xmlCount) {
+			children.forEach(function (xmlFile) {
+				const fullPath = path.join(dir, xmlFile);
+				fsx.rmSync(fullPath);
+			});
+			children = fsx.readdirSync(dir);
+		}
+
+		children.forEach(function (file) {
+			const fullPath = path.join(dir, file);
+			clearEmptyDirs(fullPath);
+		});
+
+		// re-evaluate files; after deleting subdir we may have parent dir
+		// empty now...
+		children = fsx.readdirSync(dir);
+	}
+
+	// Si no tiene hijos, lo borramos
+	if (children.length === 0) {
+		fsx.rmdirSync(dir);
+		return;
+	}
+};
+
+/**
+ * Creates multiple directories.
+ *
+ * @param dirs - An array of directory paths.
+ * @param options - Same option as `fs.mkdirSync()`
+ */
+function createDirsSync(dirs: Array<string>, options?: MakeDirectoryOptions) {
+	for (const dir of dirs) {
+		if (!fs.existsSync(dir)) {
+			fs.mkdirSync(dir, { recursive: true, ...options });
+		}
+	}
+}
+
+/**
+ * Copy multiple directories with backup option.
+ *
+ * @param src - Source directory.
+ * @param dst - Destination directory.
+ * @param dirs - Directories to copy.
+ * @param options.withBackup - Create a previous backup before copy.
+ */
+function copyDirsSync(
+	src: string,
+	dst: string,
+	dirs: Array<string>,
+	options = {
+		withBackup: false,
+	}
+) {
+	const { withBackup } = options;
+	for (const dir of dirs) {
+		const srcCompose = path.join(src, dir);
+		const dstCompose = path.join(dst, dir);
+
+		// The dir we want to copy, doesn't exist.
+		if (!fsx.existsSync(srcCompose)) {
+			console.log(`Source directory does not exist: ${srcCompose}`);
+			continue;
+		}
+
+		// Create the backup
+		if (withBackup) {
+			createBackup(dstCompose);
+		}
+
+		// Copy directory
+		try {
+			// First clean destination
+			if (fsx.existsSync(dstCompose)) {
+				fs.rmSync(dstCompose, { recursive: true, force: true });
+			}
+			// Then copy src to dst
+			fs.cpSync(srcCompose, dstCompose, { recursive: true });
+			if (withBackup) {
+				deleteBackup(dstCompose);
+			}
+		} catch (e) {
+			console.log("Copy failed!");
+			if (withBackup) {
+				restoreBackup(dstCompose);
+				console.log("Backup has been restored.");
+			}
+		}
+	}
+}
+
+/**
+ * Move artifacts between CX valid directories.
+ *
+ * @param src - Source directory.
+ * @param dst - Destination directory.
+ * @param dirs - Directories to move.
+ * @param options - Options.
+ */
+function moveDirsSync(
+	src: string,
+	dst: string,
+	dirs: Array<string>,
+	options?: { withBackup?: boolean; override?: boolean }
+) {
+	const { override, withBackup } = options || {};
+
+	for (const dir of dirs) {
+		const srcCompose = path.join(src, dir);
+		const dstCompose = path.join(dst, dir);
+
+		if (!fsx.existsSync(srcCompose)) {
+			continue;
+		}
+
+		if (withBackup) {
+			createBackup(dstCompose);
+		}
+
+		try {
+			// Clean destination
+			if (override && fsx.existsSync(dstCompose)) {
+				fs.rmSync(dstCompose, { recursive: true, force: true });
+			}
+			fs.renameSync(srcCompose, dstCompose);
+			if (withBackup) {
+				deleteBackup(dstCompose);
+			}
+		} catch (e) {
+			console.log("Move failed!");
+			if (withBackup) {
+				restoreBackup(dstCompose);
+				console.log("Backup has been restored.");
+			}
+		}
+	}
+}
+
+/**
+ * Remove directories from `basePath` directory.
+ *
+ * @param basePath - Base directory.
+ * @param dirs - Directory to remove.
+ */
+function removeDirsSync(basePath: string, dirs: Array<string>) {
+	for (const dir of dirs) {
+		if (!dir) continue;
+
+		const composePath = path.join(basePath, dir);
+
+		if (fsx.existsSync(composePath)) {
+			fs.rmSync(composePath, { recursive: true, force: true });
+		}
+	}
+}
+
+function restoreBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+	try {
+		fs.renameSync(dst, src);
+		console.log(`Backup ${dst} has been restored`);
+	} catch (e) {
+		console.log(`Error while delete ${dst} backup`);
+	}
+}
+
+function deleteBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+
+	if (!fsx.existsSync(dst)) {
+		return;
+	}
+
+	try {
+		fs.rmSync(dst, { recursive: true, force: true });
+		console.log(`Backup ${dst} has been deleted`);
+	} catch (e) {
+		console.log(`Error while delete ${dst} backup`);
+	}
+}
+
+function createBackup(src: string, suffix = "-BACKUP") {
+	const dst = src + suffix;
+
+	if (!fsx.existsSync(src)) {
+		return;
+	}
+
+	if (fsx.existsSync(dst)) {
+		console.log(`Destination ${dst} already exists`);
+		return;
+	}
+
+	try {
+		fs.renameSync(src, dst);
+		console.log(`Backup of ${src} has been created in ${dst}`);
+	} catch (e) {
+		console.log(`Error while coping ${src} to ${dst} backup`);
+	}
+}
+
+function isVirtualPage(id: number) {
+	return Number.isInteger(id) && id < 0;
+}
+
+async function removeVirtualPagesFromStore() {
+	const config = getConfig();
+	const dirs = config.dirs();
+	const storePath = path.join(dirs.__cx, "store");
+	try {
+		const multiPageFiles = getPageInStoreDir(storePath).filter(isVirtualPage);
+		removePagesFromStore(storePath, multiPageFiles);
+	} catch (e) {
+		console.info(
+			"`store` folder does not exist. Skipping multipage or static list template cleaning."
+		);
+	}
+}
+
+export {
+	clearEmptyDirs,
+	copyDirsSync,
+	createDirsSync,
+	moveDirsSync,
+	removeDirsSync,
+	removeVirtualPagesFromStore,
+};

package/{exporter → src}/utils/instance.ts

@@ -62,9 +62,9 @@ function getComponentsLibAliases() {
 			};
 		},
 		{
-			// Por este motivo se puede hacer `... import from "components" en
+			// Por este motivo se puede hacer `... import from "@components" en
 			// los packages del monorepo.
-			components: `${resolveComponentsPath()}/src/index.js`,
+			"@components": `${resolveComponentsPath()}/src/index.js`,
 		}
 	);
 }

package/{exporter → src}/utils/pages.ts

@@ -13,15 +13,10 @@ import type { Core, Fields } from "@griddo/core";
 
 import dotenv from "dotenv";
 
-import { formatImage } from "../../src/utils";
+import { formatImage } from "../adapters/gatsby/utils";
 
 dotenv.config();
 
-// Envs
-const STRIP_DOMAIN_FROM_PATH = JSON.parse(
-	process.env.GRIDDO_EXPORT_STRIP_DOMAIN_FROM_PATH || "false"
-);
-
 // Consts
 const DEFAULT_ITEMS_PER_PAGE_FOR_LIST_TEMPLATES = 25;
 
@@ -159,9 +154,7 @@ async function createGriddoPageObject(
 		socialTitle,
 	});
 
-	const pagePath = STRIP_DOMAIN_FROM_PATH
-		? fullPath.compose
-		: `${fullPath.domain}${fullPath.compose}`;
+	const pagePath = fullPath.compose;
 
 	const renderDate = new Date().toString();
 

package/{exporter → src}/utils/searches.ts

@@ -109,21 +109,18 @@ function stripSpaces(str: string) {
 async function uploadSearchContentToAPI() {
 	// Extraemos el path de la carpeta store
 	const storeDir = path.resolve(__dirname, `../store`);
-	// Convertimos el string que nos devuelve el env en un booleano
-	const isDomainStrippedFromPath: boolean = JSON.parse(
-		process.env.GRIDDO_EXPORT_STRIP_DOMAIN_FROM_PATH || "false"
-	);
 
 	for await (const store of getBuildPages(storeDir)) {
 		const {
 			context: { page, openGraph },
 		} = store;
 
-		const { compose, domain } = page.fullPath;
+		const { compose } = page.fullPath;
 
-		const contextPath = isDomainStrippedFromPath
-			? path.resolve(__dirname, `../dist/${compose}/index.html`)
-			: path.resolve(__dirname, `../dist${domain}${compose}/index.html`);
+		const contextPath = path.resolve(
+			__dirname,
+			`../dist/${compose}/index.html`
+		);
 
 		const content = fs.readFileSync(contextPath).toString();
 

package/{exporter → src}/utils/shared.ts

@@ -4,14 +4,14 @@ import type { LifeCyclesNames } from "../types/global";
 import type { APIPageObject } from "../types/pages";
 import type { Site } from "../types/sites";
 
+import path from "node:path";
+
 import chalk from "chalk";
 import dotenv from "dotenv";
 import fs from "fs-extra";
 import gradient from "gradient-string";
 import pkgDir from "pkg-dir";
 
-import { version } from "../../package.json";
-
 dotenv.config();
 
 const GRIDDO_DEBUG_LOGS =
@@ -188,6 +188,9 @@ function siteList(sites: Array<Site>) {
  * Print the great Griddo Exporter logo in ASCII.
  */
 function printExporterLogo(adapter: Adapters) {
+	const { version } = JSON.parse(
+		fs.readFileSync(path.resolve(__dirname, "../package.json"), "utf-8")
+	);
 	const logo = `
 ··
 ··      Griddo Exporter ${version}

package/{exporter → src}/utils/sites.ts

@@ -29,10 +29,6 @@ const GRIDDO_RENDER_PAGES = (
 	.map((item) => parseInt(item))
 	.filter(Boolean);
 
-const STRIP_DOMAIN_FROM_PATH = JSON.parse(
-	process.env.GRIDDO_EXPORT_STRIP_DOMAIN_FROM_PATH || "false"
-);
-
 /**
  * Check the instance sites and returns site prepared to be published and unpublished.
  */
@@ -215,10 +211,7 @@ async function generateSitemaps() {
 			const sitemaps: Array<string> = [];
 			const sitemapPageGroupKeys = Object.keys(sitemapPagesGroup);
 
-			const sitemapBasePath = path.join(
-				basePath,
-				`${STRIP_DOMAIN_FROM_PATH ? slug.replace(domain, "") : slug}`
-			);
+			const sitemapBasePath = path.join(basePath, slug.replace(domain, ""));
 
 			for (const templateId of sitemapPageGroupKeys) {
 				const sitemapPages = sitemapPagesGroup[templateId];

package/{exporter → src}/utils/temp-utils.ts

@@ -2,14 +2,18 @@ import path from "node:path";
 
 import fsx from "fs-extra";
 
-function getConfig() {
+import { createDirsSync, removeDirsSync } from "./folders";
+import { CXConfig } from "../types/global";
+
+function getConfig(): CXConfig {
 	try {
 		// eslint-disable-next-line @typescript-eslint/no-var-requires, node/no-missing-require, node/no-unpublished-require
-		const configModule = require("../cx.config.js");
+		const configModule = require("../../cx.config.js");
 		const config = configModule.default;
 
 		return config;
 	} catch (error) {
+		console.log("Error while reading configuration file");
 		process.exit(1);
 	}
 }
@@ -42,7 +46,7 @@ async function legacy__createDistFromGatsbyPublic(
 	const pageDataSrc = `${publicDir}/page-data`;
 	const pageDataDest = `${cxAssetsDir}/page-data`;
 
-	const projectStaticSrc = path.resolve(dirs.__cx, "./static");
+	const projectStaticSrc = path.resolve(dirs.__ssg, "./static");
 	const projectStaticDest = cxAssetsDir;
 
 	const gatsbyStaticSrc = `${cxDistDir}/static`;
@@ -54,12 +58,17 @@ async function legacy__createDistFromGatsbyPublic(
 
 		if (needsAssetPrefix) {
 			fsx.copySync(pageDataSrc, pageDataDest);
-			fsx.copySync(projectStaticSrc, projectStaticDest, { overwrite: false });
+			if (fsx.existsSync(projectStaticSrc)) {
+				fsx.copySync(projectStaticSrc, projectStaticDest, { overwrite: false });
+			}
 			fsx.copySync(gatsbyStaticSrc, gatsbyStaticDest, { overwrite: false });
-			fsx.copySync(projectStaticSrc, cxDistDirWithDomain, {
-				overwrite: false,
-			});
+			if (fsx.existsSync(projectStaticSrc)) {
+				fsx.copySync(projectStaticSrc, cxDistDirWithDomain, {
+					overwrite: false,
+				});
+			}
 
+			// Copia el resto de archivos...
 			validFiles.map(async (file) => {
 				const fileSrc = `${publicDir}/${file}`;
 				const fileDest = `${cxAssetsDir}/${file}`;
@@ -71,4 +80,22 @@ async function legacy__createDistFromGatsbyPublic(
 	}
 }
 
-export { legacy__createDistFromGatsbyPublic, getConfig };
+async function griddoCreateInitialDirectories(domain: string) {
+	const config = getConfig();
+	const { __exports, __caches } = config.dirs(domain);
+	createDirsSync([__exports]);
+	createDirsSync([__caches]);
+}
+
+async function griddoCleanDisposableDirectories(domain: string) {
+	const config = getConfig();
+	const { __cx } = config.dirs(domain);
+	removeDirsSync(__cx, ["store", "apiCache", "dist"]);
+}
+
+export {
+	getConfig,
+	griddoCleanDisposableDirectories,
+	griddoCreateInitialDirectories,
+	legacy__createDistFromGatsbyPublic,
+};

package/ssg/README.md

@@ -0,0 +1 @@
+# SGG Directory