@griddo/cx 1.75.193 → 1.75.196

package/scripts/griddo-exporter.ts

@@ -3,20 +3,20 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 /* eslint-disable node/shebang */
 
-require("dotenv").config();
-
-// External libraries
-import chalk from "chalk";
 import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
+
+import chalk from "chalk";
+import dotenv from "dotenv";
 import pkgDir from "pkg-dir";
 
-// Utils
 import { initCache } from "../src/utils/cache";
 import { findDomains } from "../src/utils/domains";
 import { exporterLogo as splash, measureFunctions } from "../src/utils/shared";
 
+dotenv.config();
+
 // Envs
 const artifactsArchivable = ["dist", "assets", "apiCache", ".cache"];
 const artifactsDisposable = ["public", ".store"];
@@ -39,24 +39,24 @@ type Env = Record<string, unknown>;
 const getEnvRunner = (env: Env) => (command: string) => runner(command, env);
 
 const runner = (command: string, env: Env = {}) =>
-  // TODO: Cuando esto falle, ejecutar `cleanAfterFail`
-  execSync(command, {
-    cwd: workingPath,
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      ...env,
-      GRIDDO_EXPORTER: "true",
-    },
-  });
+	// TODO: Cuando esto falle, ejecutar `cleanAfterFail`
+	execSync(command, {
+		cwd: workingPath,
+		stdio: "inherit",
+		env: {
+			...process.env,
+			...env,
+			GRIDDO_EXPORTER: "true",
+		},
+	});
 
 const getAssetPrefix = (domain: string) => {
-  // TODO: Usar asset_prefix del dominio
-  if (!process.env.GRIDDO_ASSET_PREFIX || !domain) return "";
+	// TODO: Usar asset_prefix del dominio
+	if (!process.env.GRIDDO_ASSET_PREFIX || !domain) return "";
 
-  if (!domain.startsWith("pro-")) return "";
+	if (!domain.startsWith("pro-")) return "";
 
-  return `${process.env.GRIDDO_ASSET_PREFIX}/${domain}`;
+	return `${process.env.GRIDDO_ASSET_PREFIX}/${domain}`;
 };
 
 // -----------------------------------------------------------------------------
@@ -71,240 +71,241 @@ const logWarning = (...message: Array<any>) => console.log(...message);
 // Main Stuff
 // -----------------------------------------------------------------------------
 const domainExport = async (domain: string) => {
-  const runner = getDomainRunner(domain);
-  // onPreExporter
-  const endRestore = measureFunctions(runner.init, runner.restoreArtifacts);
-  logInfo(`\n⌛️ Domain ${domain} restaured: ${endRestore}s`);
+	const runner = getDomainRunner(domain);
+	// onPreExporter
+	const endRestore = measureFunctions(runner.init, runner.restoreArtifacts);
+	logInfo(`\n⌛️ Domain ${domain} restaured: ${endRestore}s`);
 
-  // Gatsby
-  runner.runExporter();
+	// Gatsby
+	runner.runExporter();
 
-  // onPostExporter
-  const endArchive = measureFunctions(runner.archiveArtifacts);
-  logInfo(`\n⌛️ Domain ${domain} archived: ${endArchive}s`);
+	// onPostExporter
+	const endArchive = measureFunctions(runner.archiveArtifacts);
+	logInfo(`\n⌛️ Domain ${domain} archived: ${endArchive}s`);
 };
 
 const launchExports = async () => {
-  splash();
-  initCache();
+	splash();
+	initCache();
 
-  const domains = await findDomains();
+	const domains = await findDomains();
 
-  for (const domain of domains) {
-    logInfo(`️🚢 Exporting domain ${chalk.underline(domain)}`);
-    await domainExport(domain);
-  }
+	for (const domain of domains) {
+		logInfo(`️🚢 Exporting domain ${chalk.underline(domain)}`);
+		await domainExport(domain);
+	}
 };
 
 const getDomainRunner = (domain: string) => {
-  const assetPrefix = getAssetPrefix(domain);
-
-  const run = getEnvRunner({
-    DOMAIN: domain,
-    GRIDDO_ASSET_PREFIX: assetPrefix,
-    HAS_ASSET_DOMAIN: assetPrefix && assetPrefix !== "",
-    RENDERID: new Date().valueOf(),
-  });
-
-  const init = () => {
-    logInfo(`🚀 Initializing ${chalk.underline(domain)} exporter`);
-
-    cleanDirtyArtifactPaths();
-    createBaseExportPaths();
-  };
-
-  const getArtifactPaths = (artifact = "") => {
-    const domainExportArchiveBasePath = path.resolve(
-      exportArchiveBasePath,
-      domain
-    );
-    const currentExportArchivePath = path.resolve(
-      domainExportArchiveBasePath,
-      artifact
-    );
-    const currentExportBackupPath = `${currentExportArchivePath}-BACKUP`;
-    const currentExportWorkingPath = path.resolve(workingPath, artifact);
-
-    return {
-      domainExportArchiveBasePath,
-      currentExportArchivePath,
-      currentExportBackupPath,
-      currentExportWorkingPath,
-    };
-  };
-
-  const cleanDirtyArtifactPaths = () => {
-    for (const artifact of [...artifactsArchivable, ...artifactsDisposable]) {
-      const { currentExportWorkingPath } = getArtifactPaths(artifact);
-
-      if (fs.existsSync(currentExportWorkingPath)) {
-        logWarning(`🧹 Cleanup dirty ${chalk.gray(currentExportWorkingPath)}`);
-        run(`rm -rf ${currentExportWorkingPath}`);
-      }
-    }
-  };
-
-  const createBaseExportPaths = () => {
-    const { domainExportArchiveBasePath } = getArtifactPaths();
-
-    if (!fs.existsSync(domainExportArchiveBasePath)) {
-      logInfo(`✨ Creating ${domainExportArchiveBasePath}`);
-      run(`mkdir -p ${domainExportArchiveBasePath}`);
-    }
-  };
-
-  const archiveExportArtifact = (artifact: string) => {
-    const { currentExportArchivePath, currentExportWorkingPath } =
-      getArtifactPaths(artifact);
-
-    logInfo(
-      `🚚 Moving files from ${chalk.gray(
-        currentExportWorkingPath
-      )} to ${chalk.gray(currentExportArchivePath)}`
-    );
-    run(`mv ${currentExportWorkingPath} ${currentExportArchivePath}`);
-  };
-
-  const archiveArtifacts = () => {
-    for (const artifact of artifactsArchivable) {
-      const { currentExportWorkingPath, currentExportArchivePath } =
-        getArtifactPaths(artifact);
-
-      if (!fs.existsSync(currentExportWorkingPath)) {
-        logError(
-          "📁 Source directory has not been created:",
-          currentExportWorkingPath
-        );
-        continue;
-      }
-
-      try {
-        createArtifactBackup(artifact);
-        archiveExportArtifact(artifact);
-        deleteArtifactBackup(artifact);
-      } catch (error) {
-        logError(
-          `🚚 Error moving files to ${currentExportArchivePath}`,
-          error.message
-        );
-        restoreArtifactBackup(artifact);
-        continue;
-      }
-    }
-  };
-
-  const restoreArtifacts = () => {
-    for (const artifact of artifactsArchivable) {
-      const { currentExportArchivePath, currentExportWorkingPath } =
-        getArtifactPaths(artifact);
-
-      if (fs.existsSync(currentExportArchivePath)) {
-        logWarning(`️♻️  Restoring ${chalk.gray(currentExportArchivePath)}`);
-        run(`cp -R ${currentExportArchivePath} ${currentExportWorkingPath}`);
-      }
-    }
-
-    moveDistToPublic();
-  };
-
-  const createArtifactBackup = (artifact: string) => {
-    const { currentExportArchivePath, currentExportBackupPath } =
-      getArtifactPaths(artifact);
-
-    if (fs.existsSync(currentExportArchivePath)) {
-      logInfo(`💿 Creating backup of ${chalk.gray(currentExportArchivePath)}`);
-      run(`mv ${currentExportArchivePath} ${currentExportBackupPath}`);
-    }
-  };
-
-  const restoreArtifactBackup = (artifact: string) => {
-    const { currentExportArchivePath, currentExportBackupPath } =
-      getArtifactPaths(artifact);
-
-    if (fs.existsSync(currentExportBackupPath)) {
-      logWarning(
-        `️♻️  Restoring backup ${chalk.gray(currentExportArchivePath)}`
-      );
-      run(`mv ${currentExportBackupPath} ${currentExportArchivePath}`);
-    }
-  };
-
-  const deleteArtifactBackup = (artifact: string) => {
-    const { currentExportArchivePath, currentExportBackupPath } =
-      getArtifactPaths(artifact);
-
-    logWarning(`️❌ Removing backup ${chalk.gray(currentExportArchivePath)}`);
-    run(`rm -rf ${currentExportBackupPath}`);
-  };
-
-  const runExporter = () => {
-    console.log(`\n${chalk.black(chalk.bgGreen(" Gatsby (start) "))}\n`);
-
-    run("yarn export");
-    logSuccess("Your sites have been exported correctly");
-
-    console.log(`\n${chalk.black(chalk.bgGreen(" Gatsby (end) "))}\n`);
-
-    removeDisposableArtifacts();
-  };
-
-  // TODO: Hacer que infra tire de `public` en vez de `dist` y quitar esto
-  const moveDistToPublic = () => {
-    const { currentExportWorkingPath: distPath } = getArtifactPaths("dist");
-    const { currentExportWorkingPath: publicPath } = getArtifactPaths("public");
-
-    if (fs.existsSync(distPath)) {
-      logWarning(
-        `🚚 Moving ${chalk.gray(distPath)} to ${chalk.gray(publicPath)}`
-      );
-      run(`mv ${distPath} ${publicPath}`);
-    }
-  };
-
-  // TODO: Esto no debería hacerse desde infra
-  const movePublicToDist = () => {
-    const { currentExportWorkingPath: publicPath } = getArtifactPaths("public");
-    const { currentExportWorkingPath: distPath } = getArtifactPaths("dist");
-
-    if (fs.existsSync(publicPath)) {
-      logWarning(`🚚 Moving ${publicPath} to ${distPath}`);
-      run(`mv ${publicPath} ${distPath}`);
-    }
-  };
-
-  const removeDisposableArtifacts = () => {
-    for (const artifact of artifactsDisposable) {
-      const { currentExportWorkingPath: artifactPath } =
-        getArtifactPaths(artifact);
-
-      if (fs.existsSync(artifactPath)) {
-        logWarning(`❌ Removing ${chalk.gray(artifactPath)}`);
-        run(`rm -rf ${artifactPath}`);
-      }
-    }
-  };
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const cleanAfterFail = () => {
-    cleanDirtyArtifactPaths();
-  };
-
-  return {
-    init,
-    getArtifactPaths,
-    archiveExportArtifact,
-    archiveArtifacts,
-    restoreArtifacts,
-    createArtifactBackup,
-    restoreArtifactBackup,
-    deleteArtifactBackup,
-    runExporter,
-  };
+	const assetPrefix = getAssetPrefix(domain);
+
+	const run = getEnvRunner({
+		DOMAIN: domain,
+		GRIDDO_ASSET_PREFIX: assetPrefix,
+		HAS_ASSET_DOMAIN: assetPrefix && assetPrefix !== "",
+		RENDERID: new Date().valueOf(),
+	});
+
+	const init = () => {
+		logInfo(`🚀 Initializing ${chalk.underline(domain)} exporter`);
+
+		cleanDirtyArtifactPaths();
+		createBaseExportPaths();
+	};
+
+	const getArtifactPaths = (artifact = "") => {
+		const domainExportArchiveBasePath = path.resolve(
+			exportArchiveBasePath,
+			domain
+		);
+		const currentExportArchivePath = path.resolve(
+			domainExportArchiveBasePath,
+			artifact
+		);
+		const currentExportBackupPath = `${currentExportArchivePath}-BACKUP`;
+		const currentExportWorkingPath = path.resolve(workingPath, artifact);
+
+		return {
+			domainExportArchiveBasePath,
+			currentExportArchivePath,
+			currentExportBackupPath,
+			currentExportWorkingPath,
+		};
+	};
+
+	const cleanDirtyArtifactPaths = () => {
+		for (const artifact of [...artifactsArchivable, ...artifactsDisposable]) {
+			const { currentExportWorkingPath } = getArtifactPaths(artifact);
+
+			if (fs.existsSync(currentExportWorkingPath)) {
+				logWarning(`🧹 Cleanup dirty ${chalk.gray(currentExportWorkingPath)}`);
+				run(`rm -rf ${currentExportWorkingPath}`);
+			}
+		}
+	};
+
+	const createBaseExportPaths = () => {
+		const { domainExportArchiveBasePath } = getArtifactPaths();
+
+		if (!fs.existsSync(domainExportArchiveBasePath)) {
+			logInfo(`✨ Creating ${domainExportArchiveBasePath}`);
+			run(`mkdir -p ${domainExportArchiveBasePath}`);
+		}
+	};
+
+	const archiveExportArtifact = (artifact: string) => {
+		const { currentExportArchivePath, currentExportWorkingPath } =
+			getArtifactPaths(artifact);
+
+		logInfo(
+			`🚚 Moving files from ${chalk.gray(
+				currentExportWorkingPath
+			)} to ${chalk.gray(currentExportArchivePath)}`
+		);
+		run(`mv ${currentExportWorkingPath} ${currentExportArchivePath}`);
+	};
+
+	const archiveArtifacts = () => {
+		for (const artifact of artifactsArchivable) {
+			const { currentExportWorkingPath, currentExportArchivePath } =
+				getArtifactPaths(artifact);
+
+			if (!fs.existsSync(currentExportWorkingPath)) {
+				logError(
+					"📁 Source directory has not been created:",
+					currentExportWorkingPath
+				);
+				continue;
+			}
+
+			try {
+				createArtifactBackup(artifact);
+				archiveExportArtifact(artifact);
+				deleteArtifactBackup(artifact);
+			} catch (error) {
+				logError(
+					`🚚 Error moving files to ${currentExportArchivePath}`,
+					error.message
+				);
+				restoreArtifactBackup(artifact);
+				continue;
+			}
+		}
+	};
+
+	const restoreArtifacts = () => {
+		for (const artifact of artifactsArchivable) {
+			const { currentExportArchivePath, currentExportWorkingPath } =
+				getArtifactPaths(artifact);
+
+			if (fs.existsSync(currentExportArchivePath)) {
+				logWarning(`️♻️  Restoring ${chalk.gray(currentExportArchivePath)}`);
+				run(`cp -R ${currentExportArchivePath} ${currentExportWorkingPath}`);
+			}
+		}
+
+		moveDistToPublic();
+	};
+
+	const createArtifactBackup = (artifact: string) => {
+		const { currentExportArchivePath, currentExportBackupPath } =
+			getArtifactPaths(artifact);
+
+		if (fs.existsSync(currentExportArchivePath)) {
+			logInfo(`💿 Creating backup of ${chalk.gray(currentExportArchivePath)}`);
+			run(`mv ${currentExportArchivePath} ${currentExportBackupPath}`);
+		}
+	};
+
+	const restoreArtifactBackup = (artifact: string) => {
+		const { currentExportArchivePath, currentExportBackupPath } =
+			getArtifactPaths(artifact);
+
+		if (fs.existsSync(currentExportBackupPath)) {
+			logWarning(
+				`️♻️  Restoring backup ${chalk.gray(currentExportArchivePath)}`
+			);
+			run(`mv ${currentExportBackupPath} ${currentExportArchivePath}`);
+		}
+	};
+
+	const deleteArtifactBackup = (artifact: string) => {
+		const { currentExportArchivePath, currentExportBackupPath } =
+			getArtifactPaths(artifact);
+
+		logWarning(`️🗑️ Removing backup ${chalk.gray(currentExportArchivePath)}`);
+		run(`rm -rf ${currentExportBackupPath}`);
+	};
+
+	const runExporter = () => {
+		console.log(`\n${chalk.black(chalk.bgGreen(" Gatsby (start) "))}\n`);
+
+		run("yarn export");
+		// run("cp build-report.json build-report-${domain}.json")
+		logSuccess("Your sites have been exported correctly");
+
+		console.log(`\n${chalk.black(chalk.bgGreen(" Gatsby (end) "))}\n`);
+
+		removeDisposableArtifacts();
+	};
+
+	// TODO: Hacer que infra tire de `public` en vez de `dist` y quitar esto
+	const moveDistToPublic = () => {
+		const { currentExportWorkingPath: distPath } = getArtifactPaths("dist");
+		const { currentExportWorkingPath: publicPath } = getArtifactPaths("public");
+
+		if (fs.existsSync(distPath)) {
+			logWarning(
+				`🚚 Moving ${chalk.gray(distPath)} to ${chalk.gray(publicPath)}`
+			);
+			run(`mv ${distPath} ${publicPath}`);
+		}
+	};
+
+	// TODO: Esto no debería hacerse desde infra
+	const movePublicToDist = () => {
+		const { currentExportWorkingPath: publicPath } = getArtifactPaths("public");
+		const { currentExportWorkingPath: distPath } = getArtifactPaths("dist");
+
+		if (fs.existsSync(publicPath)) {
+			logWarning(`🚚 Moving ${publicPath} to ${distPath}`);
+			run(`mv ${publicPath} ${distPath}`);
+		}
+	};
+
+	const removeDisposableArtifacts = () => {
+		for (const artifact of artifactsDisposable) {
+			const { currentExportWorkingPath: artifactPath } =
+				getArtifactPaths(artifact);
+
+			if (fs.existsSync(artifactPath)) {
+				logWarning(`🗑️ Removing ${chalk.gray(artifactPath)}`);
+				run(`rm -rf ${artifactPath}`);
+			}
+		}
+	};
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	const cleanAfterFail = () => {
+		cleanDirtyArtifactPaths();
+	};
+
+	return {
+		init,
+		getArtifactPaths,
+		archiveExportArtifact,
+		archiveArtifacts,
+		restoreArtifacts,
+		createArtifactBackup,
+		restoreArtifactBackup,
+		deleteArtifactBackup,
+		runExporter,
+	};
 };
 
 console.clear();
 
 launchExports().catch((err) => {
-  console.error("❌ ERROR", err?.stdout?.toString() || err);
-  process.exit(1);
+	console.error("⛔️ ERROR", err?.stdout?.toString() || err);
+	process.exit(1);
 });

package/src/components/Head.tsx

@@ -1,17 +1,10 @@
-// Types
 import type { CustomHeadProps } from "./types";
 
-// Instance elements
-import {
-	generateAutomaticDimensions,
-	// @ts-ignore
-} from "components";
-
-// External libraries
+// @ts-expect-error components is unknown
+import { generateAutomaticDimensions } from "components";
 import parse from "html-react-parser";
 import * as React from "react";
 
-// Utils
 import { cleanCommaSeparated, composeAnalytics, formatImage } from "./utils";
 
 /**

package/src/components/template.tsx

@@ -1,20 +1,10 @@
-// Types
-import type { Core } from "@griddo/core";
 import type { TemplateProps } from "./types";
+import type { Core } from "@griddo/core";
 
-// Components and functions
 import { Page as RenderGriddoPage } from "@griddo/core";
+// @ts-expect-error components is unknown
+import { components, SiteProvider, templates } from "components";
 import { Link, navigate } from "gatsby";
-
-// Instance elements
-import {
-	components,
-	SiteProvider,
-	templates,
-	// @ts-ignore
-} from "components";
-
-// External libraries
 import * as React from "react";
 import { Helmet } from "react-helmet";
 

package/src/components/types.ts

@@ -1,7 +1,7 @@
-import type { Core } from "@griddo/core";
-import type { HeadProps } from "gatsby";
 import type { AllPagesResponse } from "../types/api";
 import type { GatsbyPageObject } from "../types/pages";
+import type { Core } from "@griddo/core";
+import type { HeadProps } from "gatsby";
 
 export interface CustomHeadProps extends HeadProps {
 	pageContext: GatsbyPageObject["context"] & {

package/src/components/utils.ts

@@ -6,7 +6,6 @@
 //
 // Browserify doesn't work with the mixture of typescript + webpack 5 + SSR
 
-// Types
 import type { Fields } from "@griddo/core";
 
 /**
@@ -22,6 +21,7 @@ function cleanCommaSeparated(str: string) {
 
 /**
  * Format Cloudinary or DAM URL
+ *
  * @param image The image url
  * @param width With of the image
  * @param height Height of the image
@@ -59,7 +59,7 @@ function addGriddoDamParams(image: string, params: string) {
 }
 
 /**
- *  Take a cloudinary url and add query params.
+ * Take a cloudinary url and add query params.
  */
 function addCloudinaryParams(image: string, params: string) {
 	const plainUrl = image.replace("https://", "");
@@ -78,16 +78,13 @@ function composeAnalytics(
 			siteScript: string;
 			page: {
 				dimensions: {
-					// TODO: Type dimensions / remove any
-					values: any;
+					values: Record<string, unknown>;
 				};
 			};
 		};
 	},
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	generateAutomaticDimensions = (page: Record<string, unknown>) => {
-		return null;
-	}
+	generateAutomaticDimensions = (page: Record<string, unknown>) => null
 ) {
 	const {
 		pageContext: {
@@ -107,7 +104,8 @@ function composeAnalytics(
 	const allDimensionsValues = {
 		...dimensionValues,
 		...automaticDimensionValues,
-	};
+		// TODO: remove any
+	} as Record<string, any>;
 
 	const allDimensions = [];
 

package/src/html.tsx

@@ -1,6 +1,8 @@
-import * as React from "react";
 import type { HtmlProps } from "./components/types";
 
+import * as React from "react";
+
+// TODO: JSDoc
 export default function HTML(props: HtmlProps) {
 	return (
 		<html {...props.htmlAttributes}>

package/src/services/auth.ts

@@ -1,4 +1,3 @@
-// External libraries
 import axios from "axios";
 import chalk from "chalk";
 
@@ -43,6 +42,8 @@ class AuthService {
 				};
 			}
 
+			return this.headers;
+
 			console.log("👋 Login\n");
 		} catch (e) {
 			console.error(