@griddo/cx 1.75.192 → 1.75.193

package/scripts/griddo-exporter.ts

@@ -15,7 +15,7 @@ import pkgDir from "pkg-dir";
 // Utils
 import { initCache } from "../src/utils/cache";
 import { findDomains } from "../src/utils/domains";
-import { exporterLogo as splash } from "../src/utils/shared";
+import { exporterLogo as splash, measureFunctions } from "../src/utils/shared";
 
 // Envs
 const artifactsArchivable = ["dist", "assets", "apiCache", ".cache"];
@@ -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,208 +71,240 @@ const logWarning = (...message: Array<any>) => console.log(...message);
 // Main Stuff
 // -----------------------------------------------------------------------------
 const domainExport = async (domain: string) => {
-	const runner = getDomainRunner(domain);
-	runner.init();
-	runner.restoreArtifacts();
-	runner.runExporter();
-	runner.archiveArtifacts();
+  const runner = getDomainRunner(domain);
+  // onPreExporter
+  const endRestore = measureFunctions(runner.init, runner.restoreArtifacts);
+  logInfo(`\n⌛️ Domain ${domain} restaured: ${endRestore}s`);
+
+  // Gatsby
+  runner.runExporter();
+
+  // 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
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	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");
+    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/utils/shared.ts

@@ -111,6 +111,18 @@ export function getSafeSiteId(response: APIResponses) {
 	return "site" in response && response.site ? response?.site : undefined;
 }
 
+/**
+ * Execute functions and return time it takes for functions to execute
+ * @param funcs Array of functions
+ * @returns seconds it takes for functions to execute
+ */
+function measureFunctions(...funcs: Array<() => void>) {
+	const start = performance.now();
+	funcs.forEach((func) => func());
+
+	return msToSec(performance.now() - start);
+}
+
 /**
  * Print a f**king great Griddo builder logo.
  */
@@ -152,4 +164,13 @@ function exporterLogo() {
 	console.log(gradient.cristal(logo));
 }
 
-export { delay, exporterLogo, logBox, logInfo, logPageSize, splash, walk };
+export {
+	delay,
+	exporterLogo,
+	logBox,
+	logInfo,
+	logPageSize,
+	measureFunctions,
+	splash,
+	walk,
+};