@griddo/cx 1.75.178 → 1.75.180

package/src/utils/cache.ts

@@ -0,0 +1,114 @@
+// Types
+import type { Petition } from "../types/global";
+import type { HashSites, SiteHash } from "../types/sites";
+
+// External libraries
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+// Constants
+const API_CACHE_DIR_PATH = path.resolve(__dirname, "./../../apiCache");
+const SITE_HASH_FILENAME = `${API_CACHE_DIR_PATH}/siteHash.json`;
+
+/**
+ *  Creates an `apiCache` folder to store pages from API
+ */
+function initCache() {
+	if (!fs.existsSync(API_CACHE_DIR_PATH)) {
+		fs.mkdirSync(API_CACHE_DIR_PATH);
+	}
+
+	console.log("\n🪄 Cache initialized");
+}
+
+/**
+ * Generate a filename with a hash using a Petition object
+ * TODO: Merge with createSha256
+ *
+ * @param petition An object
+ */
+function generateFilenameWithHash(petition: Petition) {
+	const hashSum = crypto.createHash("sha256");
+	hashSum.update(JSON.stringify(petition));
+
+	return `${API_CACHE_DIR_PATH}/${hashSum.digest("hex")}`;
+}
+
+/**
+ * Generate a filename with a hash using a string.
+ * TODO: Merge with generateFilenameWithHash
+ *
+ * @param data A string to create a sha256 based on.
+ */
+function createSha256(data: string) {
+	const hash = crypto.createHash("sha256");
+	hash.update(data);
+
+	return hash.digest("hex");
+}
+
+/**
+ * Save a file using a hash name.
+ *
+ * @param petition An object.
+ * @param content Content to be saved.
+ */
+const saveCache = <T>(petition: Petition, content: T) => {
+	const stringContent =
+		typeof content === "string" ? content : JSON.stringify(content);
+	fs.writeFileSync(generateFilenameWithHash(petition), stringContent, "utf8");
+};
+
+/**
+ * Read a cache file and return it as an object
+ *
+ * @param petition An object
+ */
+function getCache<T>(petition: Petition) {
+	try {
+		const content = fs.readFileSync(generateFilenameWithHash(petition), {
+			encoding: "utf-8",
+		});
+
+		return JSON.parse(content) as T;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get site hashes from the file as an object
+ */
+function getHashSites(): HashSites {
+	try {
+		const content = fs.readFileSync(SITE_HASH_FILENAME, { encoding: "utf-8" });
+
+		return JSON.parse(content) || {};
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Update (write) the site hash file.
+ *
+ * @param siteId The id of the site.
+ * @param siteHash The has of the site.
+ */
+function updatedSiteHash(siteId: number, siteHash: SiteHash) {
+	const allHash = getHashSites();
+	const lastHash = allHash[siteId];
+	const currentHash = siteHash || lastHash || new Date().valueOf();
+
+	if (currentHash !== lastHash) {
+		allHash[siteId] = currentHash;
+		fs.writeFileSync(SITE_HASH_FILENAME, JSON.stringify(allHash), {
+			encoding: "utf-8",
+		});
+	}
+
+	return currentHash;
+}
+
+export { createSha256, updatedSiteHash, getCache, saveCache, initCache };

package/src/utils/domains.ts

@@ -0,0 +1,32 @@
+// Types
+import type { Domains } from "../types/global";
+
+// Services
+import { AuthService } from "../services/auth";
+import { DomainsService } from "../services/domains";
+
+/**
+ * Return an array of slug domains.
+ */
+async function findDomains() {
+	await AuthService.login();
+	const domains = await DomainsService.getAll();
+
+	return getDomainSlugs(domains);
+}
+
+/**
+ * Return an unique array of domains, filtered without "/".
+ *
+ * @param domains An array of domains
+ * @see Domains
+ */
+function getDomainSlugs(domains: Domains) {
+	const filteredDomains = domains
+		.filter(({ slug }) => !!slug)
+		.map(({ slug }) => slug.replace("/", ""));
+
+	return [...new Set(filteredDomains)];
+}
+
+export { findDomains };

package/src/utils/folders.ts

@@ -0,0 +1,147 @@
+// Types
+import type { Site } from "../types/sites";
+
+// External libraries
+import fs from "fs-extra";
+import path from "path";
+
+// Utils
+import { resolveComponentsPath } from "./instance";
+import { logInfo } from "./shared";
+
+/**
+ * Delete sites folders that will be updated from de file system.
+ *
+ * @param updateSites An array of sites to be updated.
+ */
+async function deleteSites(updatedSites: Array<Site>) {
+	for await (const site of updatedSites) {
+		for (const domain of site.domains) {
+			const mappedDomain = Object.values(domain)[0];
+			const dir = path.resolve(__dirname, `../../dist${mappedDomain}`);
+			const pageDataDir = path.resolve(
+				__dirname,
+				`../../assets/page-data${mappedDomain}`
+			);
+
+			logInfo("Site dir", dir);
+			logInfo("Page data dir", pageDataDir);
+
+			// delete directory recursively
+			if (!fs.existsSync(dir)) return;
+
+			try {
+				await fs.rm(dir, { recursive: true });
+				logInfo(`${dir} is deleted!`);
+			} catch (err) {
+				console.log(err);
+			}
+
+			if (!fs.existsSync(pageDataDir)) return;
+
+			try {
+				await fs.rm(pageDataDir, { recursive: true });
+				console.log(`${pageDataDir} is deleted!`);
+			} catch (err) {
+				console.log(err);
+			}
+		}
+	}
+}
+
+/**
+ * Update the Griddo's `/dist` folder with the contents from `/public` only with files of type:
+ * - js
+ * - json
+ * - css
+ */
+async function updateDist() {
+	const isGriddoExporter =
+		process.env.GRIDDO_EXPORTER && process.env.GRIDDO_EXPORTER === "on";
+
+	const src = "./public";
+	const dest = "./dist";
+
+	const domainDestPath = `${dest}/${process.env.DOMAIN}`;
+
+	const files = fs
+		.readdirSync(src)
+		.filter(
+			(file) =>
+				path.extname(file) === ".js" ||
+				path.extname(file) === ".json" ||
+				path.extname(file) === ".css"
+		);
+
+	const assetsDest = "./assets";
+
+	const pageDataSrc = `${src}/page-data`;
+	const pageDataDest = `${assetsDest}/page-data`;
+
+	const projectStaticSrc = "./static";
+	const projectStaticDest = assetsDest;
+
+	const gatsbyStaticSrc = `${dest}/static`;
+	const gatsbyStaticDest = `${assetsDest}/static`;
+
+	try {
+		fs.mkdirSync(assetsDest, { recursive: true });
+		fs.copySync(src, dest);
+
+		if (process.env.HAS_ASSET_DOMAIN) {
+			fs.copySync(pageDataSrc, pageDataDest);
+			fs.copySync(projectStaticSrc, projectStaticDest, { overwrite: false });
+			fs.copySync(gatsbyStaticSrc, gatsbyStaticDest, { overwrite: false });
+			fs.copySync(projectStaticSrc, domainDestPath, { overwrite: false });
+
+			files.map(async (file) => {
+				const fileSrc = `${src}/${file}`;
+				const fileDest = `${assetsDest}/${file}`;
+				fs.copySync(fileSrc, fileDest);
+			});
+		}
+
+		if (isGriddoExporter) fs.rmSync(src, { recursive: true });
+	} catch (err) {
+		console.error(err);
+	}
+}
+
+/**
+ * Copy the Griddo's `/dist` folder into the Griddo's `/public` folder.
+ */
+async function prepareServe() {
+	const src = "./dist";
+	const dest = "./public";
+
+	try {
+		await fs.copy(src, dest);
+		logInfo("Public copied");
+	} catch (err) {
+		console.warn("error", err);
+	}
+}
+
+/**
+ * Copy the instance's `/static` folder into the Gatsby's to take it into account for bundle.
+ */
+function prepareStaticFolder() {
+	const src = resolveComponentsPath("static");
+	const dest = "./static";
+
+	const files = fs.readdirSync(src);
+
+	try {
+		files.map(async (file) => {
+			const fileSrc = `${src}/${file}`;
+			const fileDest = `${dest}/${file}`;
+			fs.copySync(fileSrc, fileDest);
+		});
+
+		console.log("📁 Components static folder copied");
+	} catch (err) {
+		console.error(err);
+	}
+}
+
+export { deleteSites, updateDist, prepareServe, prepareStaticFolder };

package/src/utils/instance.ts

@@ -0,0 +1,71 @@
+// External libraries
+import findUp from "find-up";
+import path from "path";
+import pkgDir from "pkg-dir";
+
+// Envs
+const isComponentLibraryEnv = __dirname.includes("node_modules");
+const projectAliases = getComponentsLibAliases();
+
+/**
+ * Returns the instance or monorepo paths.
+ *
+ * @param customPath The path for the instance components
+ */
+function resolveComponentsPath(customPath = "") {
+	return isComponentLibraryEnv
+		? path.resolve(pkgDir.sync(__dirname) as string, "../../../", customPath)
+		: path.resolve(
+				pkgDir.sync(__dirname) as string,
+				"../griddo-components",
+				customPath
+		  );
+}
+
+/**
+ * Return the instance or monorepo components {t|j}sconfig.json file.
+ */
+function getComponentsJSConfig() {
+	const jsConfigPath = findUp.sync("jsconfig.json", {
+		cwd: resolveComponentsPath(),
+	});
+	const tsConfigPath = findUp.sync("tsconfig.json", {
+		cwd: resolveComponentsPath(),
+	});
+
+	return tsConfigPath || jsConfigPath;
+}
+
+/**
+ * Get the instance webpack aliases
+ */
+function getComponentsLibAliases() {
+	const xsConfig = require(getComponentsJSConfig() as string);
+
+	return Object.keys(xsConfig?.compilerOptions?.paths).reduce(
+		(currentAlias, pathKey) => {
+			const [aliasKey] = pathKey.split("/");
+			const [pathAtJsConfig] = xsConfig?.compilerOptions?.paths[pathKey];
+
+			const [relativePathToDir] = pathAtJsConfig.split("/*");
+
+			const absolutePath = resolveComponentsPath(relativePathToDir);
+
+			return {
+				...currentAlias,
+				[aliasKey]: absolutePath,
+			};
+		},
+		{
+			components: `${resolveComponentsPath()}/src/index.js`,
+		}
+	);
+}
+
+export {
+	getComponentsJSConfig,
+	getComponentsLibAliases,
+	isComponentLibraryEnv,
+	projectAliases,
+	resolveComponentsPath,
+};