@griddo/cx 11.7.10 → 11.7.12-rc.0

package/exporter/utils/store.ts

@@ -3,99 +3,27 @@ import type { RenderInfo } from "../types/global";
 import type { GriddoPageObject } from "../types/pages";
 import type { Site } from "../types/sites";
 
-import fs from "node:fs";
+import fsp from "node:fs/promises";
 import path from "node:path";
 
-import fsx from "fs-extra";
-
-import { throwError } from "../errors";
-import { getConfig, removeProperties, walk, walkStore } from "./core-utils";
+import { WriteToStoreError } from "../constants/errors";
+import { readDB, writeDB } from "../services/db";
+import { removeProperties } from "./core-utils";
+import { throwError } from "./errors";
+import { pathExists } from "./folders";
 import { verboseLog } from "./loggin";
-import { ReadFromStoreError, WriteToStoreError } from "../errors/errors-data";
-
-const config = getConfig();
-
-/**
- * Read all path pages stored in the `store` Griddo directory and returns the
- * absolute file path.
- *
- * @param domain - The domain to get the pages from.
- */
-function getBuildPagesFromCachedStore<PageType extends GriddoPageObject>(
-	domain: string,
-) {
-	const { __cache } = config.paths(domain);
-	return getBuildPagesFromStore<PageType>({
-		basePath: path.join(__cache, "store"),
-		withSizeProp: false,
-	});
-}
+import { getRenderPathsFromDB } from "./render";
 
 /**
- * Read all pages stored in the `store` Griddo directory and returns one by one
- * with a generator.
- *
- * @param basePath - Base directory to get pages from.
- * @param options.withSizeProp - Add size prop to the page object.
- * @todo throw error if the basePath is not an store folder
+ * Get the build metadata from the Store.
  */
-function* getBuildPagesFromStore<PageType extends GriddoPageObject>(args?: {
-	basePath?: string;
-	withSizeProp?: boolean;
-}) {
-	const { basePath, withSizeProp } = args || {};
-	const { __cx } = config.paths();
-	const pagesDirPath = basePath || path.join(__cx, "store");
-
-	const jsonFilePaths = walkStore(pagesDirPath).filter(
-		(file) => path.extname(file) === ".json",
-	);
-
-	for (const filePath of jsonFilePaths) {
-		try {
-			const page = fsx.readJsonSync(filePath, {
-				encoding: "utf-8",
-			}) as PageType;
-
-			if (withSizeProp) {
-				const fileStats = fs.statSync(filePath);
-				page.size = fileStats.size / 1024;
-			}
+async function getBuildMetadata(domain: string): Promise<BuildMetaData> {
+	const db = await readDB();
+	const { sitesToPublish, createdPages, buildProcessData } = db.domains[domain].renderInfo || {};
 
-			// SECURITY: Only returns valid page objects
-			if (page.path) {
-				yield page;
-			}
-		} catch (error) {
-			throwError(ReadFromStoreError, error);
-		}
+	if (!sitesToPublish || !createdPages || !buildProcessData) {
+		throw new Error("Build metadata not found");
 	}
-}
-
-/**
- * Read all pages stored in `store` Griddo directory and return the absolute
- * path.
- */
-function getBuildPagesPath() {
-	const config = getConfig();
-	const { __cx } = config.paths();
-
-	const PAGES_DIR = path.join(__cx, "store");
-	const PAGE_FILES = walk(PAGES_DIR).filter(
-		(file) => path.extname(file) === ".json",
-	);
-
-	return PAGE_FILES;
-}
-
-/**
- * Get the build metadata from the Store.
- */
-async function getBuildMetadata(): Promise<BuildMetaData> {
-	const { __cx } = config.paths();
-	const { sitesToPublish, createdPages, buildProcessData } = fsx.readJSONSync(
-		path.join(__cx, "render-metadata.json"),
-	);
 
 	return {
 		buildProcessData,
@@ -108,13 +36,11 @@ async function getBuildMetadata(): Promise<BuildMetaData> {
  * Write render info into a file.
  * @param renderInfo - Data that will be saved related to the render process.
  */
-function saveRenderInfoInStore(renderInfo: RenderInfo) {
-	const { __cx } = config.paths();
-
-	fs.writeFileSync(
-		path.join(__cx, "render-metadata.json"),
-		JSON.stringify(renderInfo),
-	);
+async function saveRenderInfoInStore(renderInfo: RenderInfo, domain: string) {
+	const db = await readDB();
+	db.domains[domain] = db.domains[domain] || {};
+	db.domains[domain].renderInfo = renderInfo;
+	await writeDB(db);
 }
 
 /**
@@ -133,59 +59,49 @@ function saveRenderInfoInStore(renderInfo: RenderInfo) {
 // }
 
 /**
- * Return an array of ids only from `.json` files (no dirs) in the `basePath` dir based in the file name.
+ * Return an array of paths only from `.json` files (no dirs) in the `basePath` dir based in the file name.
  * @param basePath - Absolute path of the dir from which files will be read.
  * @returns A Array<number> of pages ids in `basePath` dir.
  */
-function getPageInStoreDir(basePath: string): Array<number> {
-	const filesInStore = fs.readdirSync(basePath);
+async function getPageInStoreDir(basePath: string) {
+	const filesInStore = await fsp.readdir(basePath);
+
+	return filesInStore
+		.filter(async (file) => {
+			const fullPathFile = `${basePath}/${file}`;
+			const stat = await fsp.stat(fullPathFile);
+			// Si es un directorio, no lo incluimos.
+			if (stat?.isDirectory()) {
+				return false;
+			}
 
-	return (
-		filesInStore
-			.filter((file) => {
-				const fullPathFile = `${basePath}/${file}`;
-				const stat = fs.statSync(fullPathFile);
-				// Si es un directorio, no lo incluimos.
-				if (stat?.isDirectory()) {
-					return false;
-				}
-				// Si es un archivo pero no tiene la extensión `.json`, no lo incluimos
-				if (path.extname(file) !== ".json") {
-					return false;
-				}
-				// Si es un archivo con el nombre NO pasable a número (NaN), no lo incluimos.
-				const baseFilename = path.basename(file, path.extname(file));
-				if (Number.isNaN(Number.parseInt(baseFilename))) {
-					return false;
-				}
+			// Si es un archivo pero no tiene la extensión `.json`, no lo incluimos
+			if (path.extname(file) !== ".json") {
+				return false;
+			}
 
-				// no es dir, es json y con nombre pasable a número, ok :)
-				return true;
-			})
-			// Tenemos solo jsons donde el nombre es un "número": "21345.json"
-			.map((page) => {
-				const filename = path.basename(page, path.extname(page));
-				return Number.parseInt(filename);
-			})
-	);
+			// no es dir, es json.
+			return true;
+		})
+		.map((page) => {
+			return path.join(basePath, page);
+		});
 }
 
 /**
  * Save the pages into the file system.
  * @param pages - An array of Griddo page objects to be saved.
  */
-function saveSitePagesInStore(
-	siteDirName: string,
-	pages: Array<GriddoPageObject>,
-) {
-	const { __cx } = config.paths();
+async function saveSitePagesInStore(siteDirName: string, pages: Array<GriddoPageObject>) {
+	const { __root } = await getRenderPathsFromDB();
 
 	try {
 		for (const page of pages) {
 			removeProperties(page, ["editorID", "parentEditorID"]);
 			const filename = `${page.context.page.id}.json`;
-			const filePath = path.join(__cx, "store", siteDirName, filename);
-			fsx.writeJSONSync(filePath, page);
+			const filePath = path.join(__root, "store", siteDirName, filename);
+			// En los listados estáticos y multipage los ids de las páginas son iguales
+			await writeUniqueFileSync(filePath, JSON.stringify(page));
 		}
 	} catch (error) {
 		throwError(WriteToStoreError, error);
@@ -203,23 +119,15 @@ function saveSitePagesInStore(
  * @param siteDirName - The name of the site directory containing the pages.
  * @param pageIdsArray - A two-dimensional array where each inner array contains numbers representing page files to be removed.
  */
-function removeSitePagesFromStore(
-	siteDirName: string,
-	pageIdsArray: Array<Array<number>>,
-) {
-	const { __cx } = config.paths();
+async function removeSitePagesFromStore(siteDirName: string, pageIdsArray: Array<Array<number>>) {
+	const { __root } = await getRenderPathsFromDB();
 
-	const processPageIdsArray = (pageIds: Array<number>) => {
+	const processPageIdsArray = async (pageIds: Array<number>) => {
 		for (const filename of pageIds) {
-			const filePath = path.join(
-				__cx,
-				"store",
-				siteDirName,
-				`${filename}.json`,
-			);
+			const filePath = path.join(__root, "store", siteDirName, `${filename}.json`);
 			try {
-				if (fs.existsSync(filePath)) {
-					fs.unlinkSync(filePath);
+				if (await pathExists(filePath)) {
+					await fsp.unlink(filePath);
 					verboseLog(`Removed file: ${filePath}`);
 				}
 			} catch (error) {
@@ -230,7 +138,7 @@ function removeSitePagesFromStore(
 	};
 
 	for (const pageIds of pageIdsArray) {
-		processPageIdsArray(pageIds);
+		await processPageIdsArray(pageIds);
 	}
 }
 
@@ -239,48 +147,33 @@ function removeSitePagesFromStore(
  * the domain has been changed. This is necessary because those sites will not
  * be marked as `sitesToUnpublish` so they must be removed manually.
  */
-function removeOrphanSites(sitesToPublish: Array<Site>, domain: string) {
-	const { __cx } = getConfig().paths(domain);
-	const currentSitesInStore = fs.readdirSync(path.join(__cx, "store"));
+async function removeOrphanSites(sitesToPublish: Array<Site>, domain: string) {
+	const { __root } = await getRenderPathsFromDB({ domain });
+	const storePath = path.join(__root, "store");
+
+	if (!(await pathExists(storePath))) {
+		return;
+	}
+
+	const currentSitesInStore = await fsp.readdir(storePath);
 	const sitesFromAPI = sitesToPublish.map(({ id }) => `${id}`);
-	const sitesToDelete = currentSitesInStore.filter(
-		(site) => !sitesFromAPI.includes(site),
-	);
+	const sitesToDelete = currentSitesInStore.filter((site) => !sitesFromAPI.includes(site));
 
 	for (const site of sitesToDelete) {
-		fs.rmSync(path.join(__cx, "store", site), { recursive: true, force: true });
+		await fsp.rm(path.join(storePath, site), { recursive: true, force: true });
 		verboseLog(`Removed orphan site id: ${site}`);
 	}
 }
 
-/**
- * Returns the list of `activePages` pages that do not currently exist in a
- * site's store (probably due to a failed render).
- */
-function getMissingPublishedPagesInStore(
-	siteName: string,
-	activePages: Array<number>,
-) {
-	const { __cx } = config.paths();
-	const pagesInStore = getPageInStoreDir(path.join(__cx, "store", siteName));
-	const missingActivePages: Array<number> = [];
-	for (const activePage of activePages) {
-		if (!pagesInStore.includes(activePage)) {
-			missingActivePages.push(activePage);
-		}
-	}
-	return missingActivePages;
-}
-
 /**
  * Get pages that are not active anymore but are in the store.
  */
-function getZombiePagesInStore(siteDir: string, activePages: Array<number>) {
-	const { __cx } = getConfig().paths();
-	const storeDir = path.join(__cx, "store", siteDir);
-	const sitePages = fs.readdirSync(storeDir);
+async function getZombiePagesInStore(siteDir: string, activePages: Array<number>) {
+	const { __root } = await getRenderPathsFromDB();
+	const storeDir = path.join(__root, "store", siteDir);
+	const sitePages = await fsp.readdir(storeDir);
 
-	let zombiePages: Array<number> = [];
+	const zombiePages: Array<number> = [];
 	for (const pageFileName of sitePages) {
 		const pageFileNameWithoutExtension = pageFileName.split(".")[0];
 		const pageInStore = Number.parseInt(pageFileNameWithoutExtension);
@@ -299,16 +192,30 @@ function getZombiePagesInStore(siteDir: string, activePages: Array<number>) {
 	return zombiePages;
 }
 
+async function writeUniqueFileSync(filePath: string, content: string) {
+	const dir = path.dirname(filePath);
+	const ext = path.extname(filePath);
+	const base = path.basename(filePath, ext);
+
+	let uniquePath = filePath;
+	let counter = 1;
+
+	while (await pathExists(uniquePath)) {
+		const newName = `${base}-${counter}${ext}`;
+		uniquePath = path.join(dir, newName);
+		counter++;
+	}
+
+	await fsp.writeFile(uniquePath, content);
+}
+
 export {
 	getBuildMetadata,
-	getBuildPagesFromCachedStore,
-	getBuildPagesFromStore,
-	getBuildPagesPath,
-	getMissingPublishedPagesInStore,
 	getPageInStoreDir,
 	getZombiePagesInStore,
 	removeOrphanSites,
 	removeSitePagesFromStore,
-	saveSitePagesInStore,
 	saveRenderInfoInStore,
+	saveSitePagesInStore,
+	writeUniqueFileSync,
 };

package/gatsby-browser.tsx

@@ -2,7 +2,6 @@ import type { GatsbyBrowser } from "gatsby";
 
 import { SessionProvider } from "@griddo/core";
 import { browser } from "@griddo-instance";
-import * as React from "react";
 
 export const disableCorePrefetching = () => {
 	if (browser.disableCorePrefetching) {
@@ -22,9 +21,7 @@ export const onInitialClientRender = () => {
 	}
 };
 
-export const onPostPrefetchPathname: GatsbyBrowser["onPostPrefetchPathname"] = (
-	props,
-) => {
+export const onPostPrefetchPathname: GatsbyBrowser["onPostPrefetchPathname"] = (props) => {
 	if (browser.onPostPrefetchPathname) {
 		browser.onPostPrefetchPathname(props);
 	}
@@ -36,75 +33,61 @@ export const onPreRouteUpdate: GatsbyBrowser["onPreRouteUpdate"] = (props) => {
 	}
 };
 
-export const onPrefetchPathname: GatsbyBrowser["onPrefetchPathname"] = (
-	props,
-) => {
+export const onPrefetchPathname: GatsbyBrowser["onPrefetchPathname"] = (props) => {
 	if (browser.onPrefetchPathname) {
 		browser.onPrefetchPathname(props);
 	}
 };
 
-export const onRouteUpdateDelayed: GatsbyBrowser["onRouteUpdateDelayed"] = (
-	props,
-) => {
+export const onRouteUpdateDelayed: GatsbyBrowser["onRouteUpdateDelayed"] = (props) => {
 	if (browser.onServiceWorkerActive) {
 		browser.onRouteUpdateDelayed(props);
 	}
 };
 
-export const onServiceWorkerActive: GatsbyBrowser["onServiceWorkerActive"] = (
-	props,
-) => {
+export const onServiceWorkerActive: GatsbyBrowser["onServiceWorkerActive"] = (props) => {
 	if (browser.onServiceWorkerActive) {
 		browser.onServiceWorkerActive(props);
 	}
 };
 
-export const onServiceWorkerInstalled: GatsbyBrowser["onServiceWorkerInstalled"] =
-	(props) => {
-		if (browser.onServiceWorkerInstalled) {
-			browser.onServiceWorkerInstalled(props);
-		}
-	};
-
-export const onServiceWorkerRedundant: GatsbyBrowser["onServiceWorkerRedundant"] =
-	(props) => {
-		if (browser.onServiceWorkerRedundant) {
-			browser.onServiceWorkerRedundant(props);
-		}
-	};
-
-export const onServiceWorkerUpdateFound: GatsbyBrowser["onServiceWorkerUpdateFound"] =
-	(props) => {
-		if (browser.onServiceWorkerUpdateFound) {
-			browser.onServiceWorkerUpdateFound(props);
-		}
-	};
-
-export const onServiceWorkerUpdateReady: GatsbyBrowser["onServiceWorkerUpdateReady"] =
-	(props) => {
-		if (browser.onServiceWorkerUpdateReady) {
-			browser.onServiceWorkerUpdateReady(props);
-		}
-	};
-
-export const registerServiceWorker: GatsbyBrowser["registerServiceWorker"] =
-	() => {
-		if (browser.registerServiceWorker) {
-			return browser.registerServiceWorker();
-		}
-	};
-
-export const replaceHydrateFunction: GatsbyBrowser["replaceHydrateFunction"] =
-	() => {
-		if (browser.replaceHydrateFunction) {
-			return browser.replaceHydrateFunction();
-		}
-	};
-
-export const shouldUpdateScroll: GatsbyBrowser["shouldUpdateScroll"] = (
-	props,
-) => {
+export const onServiceWorkerInstalled: GatsbyBrowser["onServiceWorkerInstalled"] = (props) => {
+	if (browser.onServiceWorkerInstalled) {
+		browser.onServiceWorkerInstalled(props);
+	}
+};
+
+export const onServiceWorkerRedundant: GatsbyBrowser["onServiceWorkerRedundant"] = (props) => {
+	if (browser.onServiceWorkerRedundant) {
+		browser.onServiceWorkerRedundant(props);
+	}
+};
+
+export const onServiceWorkerUpdateFound: GatsbyBrowser["onServiceWorkerUpdateFound"] = (props) => {
+	if (browser.onServiceWorkerUpdateFound) {
+		browser.onServiceWorkerUpdateFound(props);
+	}
+};
+
+export const onServiceWorkerUpdateReady: GatsbyBrowser["onServiceWorkerUpdateReady"] = (props) => {
+	if (browser.onServiceWorkerUpdateReady) {
+		browser.onServiceWorkerUpdateReady(props);
+	}
+};
+
+export const registerServiceWorker: GatsbyBrowser["registerServiceWorker"] = () => {
+	if (browser.registerServiceWorker) {
+		return browser.registerServiceWorker();
+	}
+};
+
+export const replaceHydrateFunction: GatsbyBrowser["replaceHydrateFunction"] = () => {
+	if (browser.replaceHydrateFunction) {
+		return browser.replaceHydrateFunction();
+	}
+};
+
+export const shouldUpdateScroll: GatsbyBrowser["shouldUpdateScroll"] = (props) => {
 	if (browser.shouldUpdateScroll) {
 		return browser.shouldUpdateScroll(props);
 	}

package/gatsby-config.ts

@@ -1,33 +1,26 @@
 import type { GatsbyConfig } from "gatsby";
 
-import { resolveComponentsPath, verboseLog } from "@griddo/cx";
-import dotenv from "dotenv";
-
-dotenv.config();
+import { resolveComponentsPath } from "./exporter/utils/instance";
 
 /**
  * Este process.env.SPAWN_ASSET_PREFIX_WITH_DOMAIN se lee porque
- * se ha introducido en el spawnSync del la función runGatsbyBuildCommand.
+ * se ha introducido en el spawnSync del la función gatsbyBuild.
  *
  *	...
- *	env: Object.assign(process.env, {
- *		GRIDDO_EXPORTER: "true",
+ *	env: {
+ *		...process.env,
  *		SPAWN_ASSET_PREFIX_WITH_DOMAIN: assetPrefixWithDomain, <--------------
  *		NODE_OPTIONS: undefined,
- *	}),
- *
- * @see runGatsbyBuildCommand()
- * @todo quiar el `... || undefined`
+ *	},
  */
-const griddoAssetPrefixWithDomain =
-	process.env.SPAWN_ASSET_PREFIX_WITH_DOMAIN || undefined;
+const griddoAssetPrefixWithDomain = process.env.SPAWN_ASSET_PREFIX_WITH_DOMAIN || undefined;
 
-verboseLog(`set config.assetPrefix=${griddoAssetPrefixWithDomain}`);
+if (process.env.GRIDDO_SSG_VERBOSE_LOGS) {
+	console.log(`set config.assetPrefix=${griddoAssetPrefixWithDomain}`);
+}
 
 // Gatsby configuration file from client
-const { plugins, ...gatsbyConfig } = require(
-	resolveComponentsPath("builder.config.js"),
-);
+const { plugins, ...gatsbyConfig } = require(resolveComponentsPath("builder.config.js"));
 
 const config: GatsbyConfig = {
 	// Client config

package/gatsby-node.ts

@@ -1,49 +1,33 @@
-import type { GatsbyPageObject } from "./src/types";
 import type { GatsbyNode } from "gatsby";
+import type { GatsbyPageObject } from "./src/types";
 
 import path from "node:path";
 
-import {
-	buildLog,
-	debugLog,
-	envs,
-	getBuildPagesFromStore,
-	getConfig,
-	pageSizeLog,
-	verboseLog,
-} from "@griddo/cx";
-
-import { gatsbyRegister } from "./exporter/registers";
-import { insertAlert } from "./exporter/utils/alerts";
-
-const showGriddoBuildLogs = envs.GRIDDO_BUILD_LOGS;
+import { isComponentLibrary } from "./exporter/utils/instance";
+import { appendLogToFile } from "./exporter/utils/loggin";
+import { getBuildPagesFromStore, pageSizeLog } from "./src/gatsby-node-utils";
 
 // process.env available through gatsbyBuildCommand.
+const showGriddoBuildLogs = JSON.parse(process.env.GRIDDO_BUILD_LOGS || "false");
 const assetPrefixWithDomain = process.env.SPAWN_ASSET_PREFIX_WITH_DOMAIN;
-const sendAlertActive = JSON.parse(process.env.GRIDDO_ALERT_FEATURE || "false");
-const avoidMatchPath = JSON.parse(
-	process.env.GRIDDO_EXPERIMENTAL_DO_NOT_USE_MATCH_PATH || "false",
-);
-const useMatchPaths = !avoidMatchPath;
-const needsAssetDomainPrefix =
-	!!assetPrefixWithDomain && assetPrefixWithDomain !== "";
+const needsAssetDomainPrefix = !!assetPrefixWithDomain && assetPrefixWithDomain !== "";
+const nodeOptions = process.env.NODE_OPTIONS;
 
-const { __ssg } = getConfig().paths();
-const template = path.join(__ssg, "src/components/template.tsx");
+const template = path.resolve("./src/components/template.tsx");
+const dbFilePath = isComponentLibrary
+	? path.resolve(__dirname, "../../..", ".cx-cache", "db.json")
+	: path.resolve(__dirname, "../..", ".cx-cache", "db.json");
 
 const pages = getBuildPagesFromStore<GatsbyPageObject>({
 	withSizeProp: showGriddoBuildLogs,
+	dbFilePath,
 });
 
 const createPages: GatsbyNode["createPages"] = async ({ actions }) => {
-	verboseLog(`read assetPrefixWithDomain=${assetPrefixWithDomain}`);
-	verboseLog(`set needsAssetDomainPrefix=${needsAssetDomainPrefix}`);
-	console.log(
-		`using this NODE_OPTIONS in gatsby-node.ts: ${process.env.NODE_OPTIONS}`,
-	);
-
-	if (avoidMatchPath) {
-		console.log(`[!] GRIDDO EXPERIMENTAL: Avoiding use of matchPath`);
+	if (process.env.GRIDDO_VERBOSE_SSG) {
+		console.log(`read assetPrefixWithDomain=${assetPrefixWithDomain}`);
+		console.log(`set needsAssetDomainPrefix=${needsAssetDomainPrefix}`);
+		console.log(`using NODE_OPTIONS in gatsby-node.ts: ${nodeOptions}`);
 	}
 
 	for await (const page of pages) {
@@ -51,13 +35,7 @@ const createPages: GatsbyNode["createPages"] = async ({ actions }) => {
 			return;
 		}
 
-		const matchPath =
-			needsAssetDomainPrefix && useMatchPaths
-				? page.context.fullPath.compose
-				: "";
-
 		page.component = template;
-		page.matchPath = matchPath;
 
 		actions.createPage(page);
 
@@ -65,46 +43,7 @@ const createPages: GatsbyNode["createPages"] = async ({ actions }) => {
 		const id = page.context.id;
 		const size = pageSizeLog(Math.round(page.size || 0));
 
-		if (sendAlertActive && page.size) {
-			const pageMaxSizeReached =
-				page.size >
-				Number.parseInt(process.env.GRIDDO_SSG_MAX_PAGE_SIZE || "524288") /
-					1024;
-
-			if (pageMaxSizeReached) {
-				gatsbyRegister.insert("GATSBY_PAGE_SIZE_TOO_BIG", {
-					path: page.path,
-					size: `${Math.round(page.size)}KB`,
-				});
-			}
-		}
-
-		if (showGriddoBuildLogs) {
-			buildLog(`Creating page ${path} - ${id} - ${size}`);
-		}
-	}
-
-	if (sendAlertActive) {
-		const registerContent = gatsbyRegister.get("GATSBY_PAGE_SIZE_TOO_BIG");
-
-		if (registerContent.entries.length < 1) {
-			return;
-		}
-
-		debugLog("\nRender register report\n");
-		debugLog(registerContent);
-		debugLog();
-
-		await insertAlert({
-			description: "Render register report",
-			area: "Griddo",
-			level: "W",
-			fullData: {
-				output: registerContent,
-				date: new Date().toISOString(),
-			},
-			instantNotification: false,
-		});
+		await appendLogToFile(`Creating page ${path} - ${id} - ${size}`);
 	}
 };
 

package/gatsby-ssr.tsx

@@ -1,8 +1,9 @@
 import type { GatsbySSR } from "gatsby";
 
+import * as React from "react";
+
 import { SessionProvider } from "@griddo/core";
 import { ssr } from "@griddo-instance";
-import * as React from "react";
 
 export const wrapPageElement: GatsbySSR["wrapPageElement"] = (props) => {
 	if (ssr.wrapPageElement) {