@griddo/cx 11.9.12-rc.0 → 11.9.13

package/exporter/services/navigation.ts

@@ -1,12 +1,12 @@
-import type { Footer, Header } from "../shared/types/navigation";
-import type { APIPageObject } from "../shared/types/pages";
+import type { Footer, Header } from "../types/navigation";
+import type { APIPageObject } from "../types/pages";
 
 class NavigationService {
 	private _defaultHeaders: Record<string, Header>;
 	private _defaultFooters: Record<string, Footer>;
 	private _navigations: {
-		headers: Header[];
-		footers: Footer[];
+		headers: Array<Header>;
+		footers: Array<Footer>;
 	};
 
 	constructor() {
@@ -53,11 +53,11 @@ class NavigationService {
 	}
 
 	getRightLanguage(
-		list: {
+		list: Array<{
 			language: number;
-			navigationLanguages: { navigationId: number }[];
+			navigationLanguages: Array<{ navigationId: number }>;
 			id: number;
-		}[],
+		}>,
 		id: number,
 		language: number,
 	) {
@@ -68,7 +68,9 @@ class NavigationService {
 		const rightLanguageItem = list.find(
 			(item) =>
 				item.language === language &&
-				item.navigationLanguages?.find((version) => version.navigationId === id),
+				item.navigationLanguages?.find(
+					(version) => version.navigationId === id,
+				),
 		);
 
 		const result = rightLanguageItem || list.find((item) => item.id === id);
@@ -85,15 +87,19 @@ class NavigationService {
 	}
 
 	getPageNavigations(page: APIPageObject) {
-		const { header: pageHeader, footer: pageFooter, language, template, templateConfig } = page;
-		const { templateType } = template;
-		const { defaultHeader, defaultFooter, templates } = templateConfig;
+		const {
+			header: pageHeader,
+			footer: pageFooter,
+			language,
+			template: { templateType },
+			templateConfig: { defaultHeader, defaultFooter, templates },
+		} = page;
 
 		// The navigations would be:
 		// - The one with the page or ...
 		// - The one defined for that template or ...
 		// - The one you have defined for that data package
-		const getValidNavigation = (values: (number | unknown)[]) => {
+		const getValidNavigation = (values: Array<number | unknown>) => {
 			const fineNavigation = values.find((item) => typeof item === "number");
 
 			return typeof fineNavigation === "number" ? fineNavigation : null;

package/exporter/services/reference-fields.ts

@@ -1,9 +1,9 @@
+import type { FetchDataProps } from "../types/global";
+import type { APIPageObject } from "../types/pages";
 import type { Core, Fields } from "@griddo/core";
-import type { FetchDataProps } from "../shared/types/global";
-import type { APIPageObject } from "../shared/types/pages";
 
-import { GriddoLog } from "../core/GriddoLog";
 import { getReferenceFieldSiteData } from "./sites";
+import { boxLog } from "../utils/loggin";
 
 /**
  * Get the body data from a ReferenceField.
@@ -54,7 +54,9 @@ function getBody(data: Fields.Reference<unknown>, page: Core.Page) {
 		};
 	}
 
-	GriddoLog.error(`ReferenceField mode: ${mode} is not recognized on page ${page?.id}.`);
+	console.log(
+		`Error: ReferenceField mode: ${mode} is not recognized on page ${page?.id}.`,
+	);
 
 	return data;
 }
@@ -69,13 +71,17 @@ function getBody(data: Fields.Reference<unknown>, page: Core.Page) {
  * @returns The ContentType data.
  */
 async function fetchContentTypeData(props: FetchDataProps) {
-	const { page, component, cacheKey } = props;
-	const { data } = component;
+	const {
+		page,
+		component: { data },
+		cacheKey,
+	} = props;
 
 	// Distrubutor with `hasDistributorData: true` / `getStaticData: true` but without `data` prop
 	if (!data) {
-		GriddoLog.info(
+		boxLog(
 			`Error: Page ${page.id} has \`hasDistributorData: true\` or \`getStaticData: true\` but it doesn't have a \`data\` property.`,
+			"No `data` in `ReferenceField`",
 		);
 
 		return [];
@@ -83,8 +89,9 @@ async function fetchContentTypeData(props: FetchDataProps) {
 
 	// Avoid fetch ReferenceField with empty `data.sources`
 	if (Array.isArray(data.sources) && data.sources.length < 1) {
-		GriddoLog.info(
+		boxLog(
 			`Warning: Page with id: ${page.id} has a ReferenceField with empty \`data.sources\``,
+			"Empty data.sources in ReferenceField",
 		);
 
 		return [];
@@ -94,14 +101,21 @@ async function fetchContentTypeData(props: FetchDataProps) {
 
 	// Inform that the ReferenceField has not `data.sources`
 	if (!data.sources && data.mode === "auto") {
-		GriddoLog.info(
+		boxLog(
 			`Warning: Page with id: ${page.id} has a ReferenceField with \`undefined\` \`data.sources\``,
+			"undefined data.sources in ReferenceField",
 		);
 	}
 
 	const body = getBody(data, page);
 
-	const response = await getReferenceFieldSiteData(page, body, cacheKey, site, lang);
+	const response = await getReferenceFieldSiteData(
+		page,
+		body,
+		cacheKey,
+		site,
+		lang,
+	);
 
 	return response;
 }
@@ -151,7 +165,10 @@ async function getReferenceFieldData({
 					continue;
 				}
 
-				const _key = key as "hasDistributorData" | "queriedItems" | "getStaticData";
+				const _key = key as
+					| "hasDistributorData"
+					| "queriedItems"
+					| "getStaticData";
 				const component = templateChunk[_key] as unknown as {
 					data: Fields.Reference<unknown>;
 					queriedItems: Fields.QueriedData<unknown>;
@@ -164,7 +181,8 @@ async function getReferenceFieldData({
 					continue;
 				}
 
-				const componentHasRequestForData = component.hasDistributorData || component.getStaticData;
+				const componentHasRequestForData =
+					component.hasDistributorData || component.getStaticData;
 
 				if (componentHasRequestForData) {
 					component.queriedItems = await fetchContentTypeData({
@@ -190,9 +208,9 @@ async function getReferenceFieldData({
 
 		return response;
 	} catch (err) {
-		GriddoLog.error("Error in getReferenceFieldData:", err);
+		console.error(`Error in getReferenceFieldData ${err}`);
 
-		throw err;
+		process.exit(1);
 	}
 }
 

package/exporter/services/register.ts

@@ -0,0 +1,113 @@
+import fsx from "fs-extra";
+
+type Entry = Record<string, unknown>;
+
+type EntryData = {
+	title: string;
+	description: string;
+	entries: Array<Entry>;
+};
+
+type Entries = Record<string, EntryData>;
+
+interface RegisterBase<T extends Entries> {
+	insert(name: keyof T, entry: Entry): void;
+	get(name: keyof T): EntryData;
+	getAll(): T;
+}
+
+class MemoryRegister<T extends Entries> implements RegisterBase<T> {
+	entries: T;
+
+	constructor(entries: T) {
+		this.entries = entries;
+	}
+
+	insert(name: keyof T, entry: Entry) {
+		this.entries[name].entries.push(entry);
+	}
+
+	get(name: keyof T) {
+		return this.entries[name];
+	}
+
+	getAll() {
+		return this.entries;
+	}
+}
+
+class FileRegister<T extends Entries> implements RegisterBase<T> {
+	private readonly filePath: string;
+	entries: T;
+
+	constructor(filePath: string, entries: T) {
+		this.entries = entries;
+		this.filePath = filePath;
+		try {
+			fsx.writeJSONSync(this.filePath, this.entries);
+		} catch (e) {
+			console.error(`Error writing ${this.filePath}`, e);
+		}
+	}
+
+	private getCurrentEntries(): T {
+		return fsx.readJSONSync(this.filePath, "utf8") as T;
+	}
+
+	insert(name: keyof T, entry: Entry) {
+		try {
+			const currentEntries = this.getCurrentEntries();
+			currentEntries[name].entries.push(entry);
+			fsx.writeJSONSync(this.filePath, currentEntries);
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	get(name: keyof T) {
+		try {
+			return fsx.readJSONSync(this.filePath, "utf8")[name] as EntryData;
+		} catch (e) {
+			console.error(e);
+			throw new Error(`Error reading ${this.filePath}`);
+		}
+	}
+
+	getAll() {
+		try {
+			return fsx.readJSONSync(this.filePath, "utf8") as T;
+		} catch (e) {
+			console.error(e);
+			throw new Error(`Error reading ${this.filePath}`);
+		}
+	}
+}
+
+class Register<T extends Entries> {
+	private strategy: RegisterBase<T>;
+
+	constructor(strategy: RegisterBase<T>) {
+		this.strategy = strategy;
+	}
+
+	insert<K extends keyof T>(name: K, entry: Entry) {
+		this.strategy.insert(name, entry);
+	}
+
+	get<K extends keyof T>(name: K) {
+		return this.strategy.get(name);
+	}
+
+	getAll() {
+		return this.strategy.getAll();
+	}
+}
+
+export {
+	FileRegister,
+	MemoryRegister,
+	Register,
+	type Entries,
+	type Entry,
+	type EntryData,
+};

package/exporter/services/robots.ts

@@ -1,43 +1,71 @@
-import type { Robots } from "../shared/types/global";
+import type { Robots } from "../types/global";
 
-import fsp from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
 
-import { pathExists } from "../core/fs";
-import { GriddoLog } from "../core/GriddoLog";
-import { ROBOTS } from "../shared/endpoints";
-import { get } from "./api";
-import { getRenderPathsHydratedWithDomainFromDB } from "./render";
-
-async function fetchRobots() {
-	const apiRobots = await get<Robots>({ endpoint: ROBOTS });
-	return (
-		apiRobots
-			?.filter((r) => !!r.path)
-			.map(({ path, content }) => ({
-				path,
-				content: content || "User-agent: *\n\r\n\rAllow: /",
-			})) || []
-	);
-}
+import { endpoints } from "../constants";
+import { get } from "../utils/api";
+import { getConfig } from "../utils/core-utils";
+import { verboseLog } from "../utils/loggin";
+
+const config = getConfig();
 
-async function generateRobots(domain: string) {
-	const { __root } = await getRenderPathsHydratedWithDomainFromDB({ domain });
-	const distDirectory = path.join(__root, "current-dist");
-	const robot = (await fetchRobots()).find(({ path }) => path === `/${domain}`);
+/**
+ * TODO: JSDoc
+ */
+class RobotsService {
+	robots: Robots;
+	settings: Record<string, unknown>;
 
-	if (!robot) {
-		GriddoLog.info(`Robots not found for ${domain}`);
-		return;
+	constructor() {
+		this.robots = [];
+		this.settings = {};
 	}
 
-	if (await pathExists(distDirectory)) {
-		const fileLocation = path.join(distDirectory, "robots.txt");
-		await fsp.writeFile(fileLocation, robot?.content);
-		GriddoLog.verbose(`wrote robots.txt to ${fileLocation}`);
-	} else {
-		GriddoLog.info(`${distDirectory} not found`);
+	/**
+	 * TODO: JSDoc
+	 */
+	private async getRobots() {
+		try {
+			const apiRobots = await get<Robots>({ endpoint: endpoints.ROBOTS });
+			this.robots =
+				apiRobots
+					?.filter((r) => !!r.path)
+					.map(({ path, content }) => ({
+						path,
+						content: content || "User-agent: *\n\r\n\rAllow: /",
+					})) || [];
+		} catch (e) {
+			console.warn(`${this.constructor.name}: ${(e as Error).message}`);
+		}
+	}
+
+	/**
+	 * Write robots.txt files for the domain.
+	 */
+	async writeFiles(domain: string) {
+		const { __cx } = config.paths(domain);
+		const distDirectory = path.join(__cx, "dist");
+
+		await this.getRobots();
+
+		const robot = this.robots.find(({ path }) => path === `/${domain}`);
+
+		if (!robot) {
+			console.log(`Robots not found for ${domain}`);
+			return;
+		}
+
+		if (fs.existsSync(distDirectory)) {
+			const fileLocation = path.join(distDirectory, "robots.txt");
+			fs.writeFileSync(fileLocation, robot?.content);
+			verboseLog(`wrote robots.txt to ${fileLocation}`);
+		} else {
+			console.log(`${distDirectory} not found`);
+		}
 	}
 }
 
-export { generateRobots };
+const robotsService = new RobotsService();
+
+export { robotsService as RobotsService };

package/exporter/services/settings.ts

@@ -0,0 +1,17 @@
+import type { Settings } from "../types/global";
+
+import { endpoints } from "../constants";
+import { get, post } from "../utils/api";
+
+async function getAllSettings() {
+	return get<Settings>({ endpoint: endpoints.SETTINGS });
+}
+
+async function resetRender() {
+	await post({
+		endpoint: endpoints.RESET_RENDER,
+		useApiCacheDir: false,
+	});
+}
+
+export { getAllSettings, resetRender };

package/exporter/services/sites.ts

@@ -1,4 +1,3 @@
-import type { Core } from "@griddo/core";
 import type {
 	AllSitesReponse,
 	EndPageInfoResponse,
@@ -10,28 +9,19 @@ import type {
 	SitemapAPIResponse,
 	SocialsResponse,
 	StartPageRenderResponse,
-} from "../shared/types/api";
-import type { Site } from "../shared/types/sites";
-
-import {
-	BUILD_END,
-	BUILD_START,
-	GET_ALL,
-	GET_PAGE,
-	GET_REFERENCE_FIELD_DATA,
-	GET_SITEMAP,
-	INFO,
-	LANGUAGES,
-	SOCIALS,
-} from "../shared/endpoints";
-import { get, post } from "./api";
+} from "../types/api";
+import type { Site } from "../types/sites";
+import type { Core } from "@griddo/core";
+
+import { endpoints } from "../constants";
+import { get, post } from "../utils/api";
 
 /**
  * Get a list of site objects.
  */
 async function getAllSites(domain: string) {
-	return get<AllSitesReponse>({
-		endpoint: `${GET_ALL}?domainSlug=${domain}`,
+	return await get<AllSitesReponse>({
+		endpoint: `${endpoints.GET_ALL}?domainSlug=${domain}`,
 	});
 }
 
@@ -39,7 +29,7 @@ async function getAllSites(domain: string) {
  * Get a list of site objects from a domain.
  */
 async function getAllSitesFromDomain(domain: string) {
-	const allSites = await get<AllSitesReponse>({ endpoint: GET_ALL });
+	const allSites = await get<AllSitesReponse>({ endpoint: endpoints.GET_ALL });
 
 	if (allSites.length) {
 		for (const site of allSites) {
@@ -50,7 +40,8 @@ async function getAllSitesFromDomain(domain: string) {
 			site.domains = items
 				.filter(
 					(item) =>
-						item.domain && (item.domain.slug === domain || item.domain.slug === `/${domain}`),
+						item.domain &&
+						(item.domain.slug === domain || item.domain.slug === `/${domain}`),
 				)
 				.map((item) => ({ [item.id]: `${item.domain.slug}${item.path}` }));
 		}
@@ -63,8 +54,8 @@ async function getAllSitesFromDomain(domain: string) {
  * Fetch a page object from API.
  */
 async function getPage(id: number, cacheKey: string) {
-	return get<PageResponse>({
-		endpoint: `${GET_PAGE}/${id}`,
+	return await get<PageResponse>({
+		endpoint: `${endpoints.GET_PAGE}/${id}`,
 		cacheKey,
 	});
 }
@@ -73,27 +64,27 @@ async function getPage(id: number, cacheKey: string) {
  * Get site info
  */
 async function getSiteInfo(id: number, cacheKey = "") {
-	const [prefix, suffix] = INFO;
+	const [prefix, suffix] = endpoints.INFO;
 
-	return get<Site>({
+	return await get<Site>({
 		endpoint: `${prefix}${id}${suffix}`,
 		cacheKey,
 	});
 }
 
 async function getSiteLanguages(id: number, cacheKey = "") {
-	const [prefix, suffix] = LANGUAGES;
+	const [prefix, suffix] = endpoints.LANGUAGES;
 
-	return get<LanguagesResponse>({
+	return await get<LanguagesResponse>({
 		endpoint: `${prefix}${id}${suffix}`,
 		cacheKey,
 	});
 }
 
 async function startSiteRender(id: number) {
-	const [prefix, suffix] = BUILD_START;
+	const [prefix, suffix] = endpoints.BUILD_START;
 
-	return get<StartPageRenderResponse>({
+	return await get<StartPageRenderResponse>({
 		endpoint: `${prefix}${id}${suffix}`,
 	});
 }
@@ -102,13 +93,12 @@ async function startSiteRender(id: number) {
  * Send the end signal to API for a render site.
  */
 async function endSiteRender(id: number, body: EndSiteRenderBody) {
-	const [prefix, suffix] = BUILD_END;
+	const [prefix, suffix] = endpoints.BUILD_END;
 
-	await post<EndPageInfoResponse>({
+	return await post<EndPageInfoResponse>({
 		endpoint: `${prefix}${id}${suffix}`,
 		body,
 		useApiCacheDir: false,
-		logToFile: false,
 	});
 }
 
@@ -119,11 +109,11 @@ async function getReferenceFieldSiteData(
 	dataSiteId?: number,
 	dataLangID?: number,
 ) {
-	const [prefix, suffix] = GET_REFERENCE_FIELD_DATA;
+	const [prefix, suffix] = endpoints.GET_REFERENCE_FIELD_DATA;
 	const site = dataSiteId || page.site;
 	const lang = dataLangID || page.language;
 
-	return post<ReferenceFieldResponse>({
+	return await post<ReferenceFieldResponse>({
 		endpoint: `${prefix}${site}${suffix}`,
 		body,
 		headers: { lang },
@@ -131,20 +121,18 @@ async function getReferenceFieldSiteData(
 	});
 }
 
-async function getSitemap(options: { siteId: number; headers?: Record<string, string> }) {
-	const { siteId, headers } = options;
-	const [prefix, suffix] = GET_SITEMAP;
+async function getSitemap(id: number) {
+	const [prefix, suffix] = endpoints.GET_SITEMAP;
 
 	return get<SitemapAPIResponse>({
-		endpoint: `${prefix}${siteId}${suffix}`,
-		headers,
+		endpoint: `${prefix}${id}${suffix}`,
 	});
 }
 
 async function getSiteSocials(id: number, cacheKey = "") {
-	const [prefix, suffix] = SOCIALS;
+	const [prefix, suffix] = endpoints.SOCIALS;
 
-	return get<SocialsResponse>({
+	return await get<SocialsResponse>({
 		endpoint: `${prefix}${id}${suffix}`,
 		cacheKey,
 	});