@griddo/cx 11.7.6-rc.2 → 11.7.6

package/exporter/utils/store.ts

@@ -3,27 +3,99 @@ import type { RenderInfo } from "../types/global";
 import type { GriddoPageObject } from "../types/pages";
 import type { Site } from "../types/sites";
 
-import fsp from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
 
-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 fsx from "fs-extra";
+
+import { throwError } from "../errors";
+import { getConfig, removeProperties, walk, walkStore } from "./core-utils";
 import { verboseLog } from "./loggin";
-import { getRenderPathsFromDB } from "./render";
+import { ReadFromStoreError, WriteToStoreError } from "../errors/errors-data";
+
+const config = getConfig();
 
 /**
- * Get the build metadata from the Store.
+ * 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.
  */
-async function getBuildMetadata(domain: string): Promise<BuildMetaData> {
-	const db = await readDB();
-	const { sitesToPublish, createdPages, buildProcessData } = db.domains[domain].renderInfo || {};
+function getBuildPagesFromCachedStore<PageType extends GriddoPageObject>(
+	domain: string,
+) {
+	const { __cache } = config.paths(domain);
+	return getBuildPagesFromStore<PageType>({
+		basePath: path.join(__cache, "store"),
+		withSizeProp: false,
+	});
+}
+
+/**
+ * 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
+ */
+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;
+			}
 
-	if (!sitesToPublish || !createdPages || !buildProcessData) {
-		throw new Error("Build metadata not found");
+			// SECURITY: Only returns valid page objects
+			if (page.path) {
+				yield page;
+			}
+		} catch (error) {
+			throwError(ReadFromStoreError, error);
+		}
 	}
+}
+
+/**
+ * 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,
@@ -36,11 +108,13 @@ async function getBuildMetadata(domain: string): Promise<BuildMetaData> {
  * Write render info into a file.
  * @param renderInfo - Data that will be saved related to the render process.
  */
-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);
+function saveRenderInfoInStore(renderInfo: RenderInfo) {
+	const { __cx } = config.paths();
+
+	fs.writeFileSync(
+		path.join(__cx, "render-metadata.json"),
+		JSON.stringify(renderInfo),
+	);
 }
 
 /**
@@ -59,49 +133,59 @@ async function saveRenderInfoInStore(renderInfo: RenderInfo, domain: string) {
 // }
 
 /**
- * Return an array of paths only from `.json` files (no dirs) in the `basePath` dir based in the file name.
+ * Return an array of ids 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.
  */
-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;
-			}
+function getPageInStoreDir(basePath: string): Array<number> {
+	const filesInStore = fs.readdirSync(basePath);
 
-			// Si es un archivo pero no tiene la extensión `.json`, no lo incluimos
-			if (path.extname(file) !== ".json") {
-				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;
+				}
 
-			// no es dir, es json.
-			return true;
-		})
-		.map((page) => {
-			return path.join(basePath, page);
-		});
+				// 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);
+			})
+	);
 }
 
 /**
  * Save the pages into the file system.
  * @param pages - An array of Griddo page objects to be saved.
  */
-async function saveSitePagesInStore(siteDirName: string, pages: Array<GriddoPageObject>) {
-	const { __root } = await getRenderPathsFromDB();
+function saveSitePagesInStore(
+	siteDirName: string,
+	pages: Array<GriddoPageObject>,
+) {
+	const { __cx } = config.paths();
 
 	try {
 		for (const page of pages) {
 			removeProperties(page, ["editorID", "parentEditorID"]);
 			const filename = `${page.context.page.id}.json`;
-			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));
+			const filePath = path.join(__cx, "store", siteDirName, filename);
+			fsx.writeJSONSync(filePath, page);
 		}
 	} catch (error) {
 		throwError(WriteToStoreError, error);
@@ -119,15 +203,23 @@ async function saveSitePagesInStore(siteDirName: string, pages: Array<GriddoPage
  * @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.
  */
-async function removeSitePagesFromStore(siteDirName: string, pageIdsArray: Array<Array<number>>) {
-	const { __root } = await getRenderPathsFromDB();
+function removeSitePagesFromStore(
+	siteDirName: string,
+	pageIdsArray: Array<Array<number>>,
+) {
+	const { __cx } = config.paths();
 
-	const processPageIdsArray = async (pageIds: Array<number>) => {
+	const processPageIdsArray = (pageIds: Array<number>) => {
 		for (const filename of pageIds) {
-			const filePath = path.join(__root, "store", siteDirName, `${filename}.json`);
+			const filePath = path.join(
+				__cx,
+				"store",
+				siteDirName,
+				`${filename}.json`,
+			);
 			try {
-				if (await pathExists(filePath)) {
-					await fsp.unlink(filePath);
+				if (fs.existsSync(filePath)) {
+					fs.unlinkSync(filePath);
 					verboseLog(`Removed file: ${filePath}`);
 				}
 			} catch (error) {
@@ -138,7 +230,7 @@ async function removeSitePagesFromStore(siteDirName: string, pageIdsArray: Array
 	};
 
 	for (const pageIds of pageIdsArray) {
-		await processPageIdsArray(pageIds);
+		processPageIdsArray(pageIds);
 	}
 }
 
@@ -147,33 +239,48 @@ async function removeSitePagesFromStore(siteDirName: string, pageIdsArray: Array
  * the domain has been changed. This is necessary because those sites will not
  * be marked as `sitesToUnpublish` so they must be removed manually.
  */
-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);
+function removeOrphanSites(sitesToPublish: Array<Site>, domain: string) {
+	const { __cx } = getConfig().paths(domain);
+	const currentSitesInStore = fs.readdirSync(path.join(__cx, "store"));
 	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) {
-		await fsp.rm(path.join(storePath, site), { recursive: true, force: true });
+		fs.rmSync(path.join(__cx, "store", 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.
  */
-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);
+function getZombiePagesInStore(siteDir: string, activePages: Array<number>) {
+	const { __cx } = getConfig().paths();
+	const storeDir = path.join(__cx, "store", siteDir);
+	const sitePages = fs.readdirSync(storeDir);
 
-	const zombiePages: Array<number> = [];
+	let zombiePages: Array<number> = [];
 	for (const pageFileName of sitePages) {
 		const pageFileNameWithoutExtension = pageFileName.split(".")[0];
 		const pageInStore = Number.parseInt(pageFileNameWithoutExtension);
@@ -192,30 +299,16 @@ async 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,
-	saveRenderInfoInStore,
 	saveSitePagesInStore,
-	writeUniqueFileSync,
+	saveRenderInfoInStore,
 };

package/gatsby-browser.tsx

@@ -2,6 +2,7 @@ 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) {
@@ -21,7 +22,9 @@ export const onInitialClientRender = () => {
 	}
 };
 
-export const onPostPrefetchPathname: GatsbyBrowser["onPostPrefetchPathname"] = (props) => {
+export const onPostPrefetchPathname: GatsbyBrowser["onPostPrefetchPathname"] = (
+	props,
+) => {
 	if (browser.onPostPrefetchPathname) {
 		browser.onPostPrefetchPathname(props);
 	}
@@ -33,61 +36,75 @@ 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,10 +1,13 @@
 import type { GatsbyConfig } from "gatsby";
 
-import { resolveComponentsPath } from "./exporter/utils/instance";
+import { resolveComponentsPath, verboseLog } from "@griddo/cx";
+import dotenv from "dotenv";
+
+dotenv.config();
 
 /**
  * Este process.env.SPAWN_ASSET_PREFIX_WITH_DOMAIN se lee porque
- * se ha introducido en el spawnSync del la función gatsbyBuild.
+ * se ha introducido en el spawnSync del la función runGatsbyBuildCommand.
  *
  *	...
  *	env: Object.assign(process.env, {
@@ -13,15 +16,18 @@ import { resolveComponentsPath } from "./exporter/utils/instance";
  *		NODE_OPTIONS: undefined,
  *	}),
  *
- * @see gatsbyBuild()
+ * @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;
 
-console.log(`set config.assetPrefix=${griddoAssetPrefixWithDomain}`);
+verboseLog(`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,38 +1,63 @@
-import type { GatsbyNode } from "gatsby";
 import type { GatsbyPageObject } from "./src/types";
+import type { GatsbyNode } from "gatsby";
 
 import path from "node:path";
 
-import { isComponentLibrary } from "./exporter/utils/instance";
-import { getBuildPagesFromStore, pageSizeLog } from "./src/gatsby-node-utils";
+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;
 
 // 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 needsAssetDomainPrefix = !!assetPrefixWithDomain && assetPrefixWithDomain !== "";
-const nodeOptions = process.env.NODE_OPTIONS;
+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 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 { __ssg } = getConfig().paths();
+const template = path.join(__ssg, "src/components/template.tsx");
 
 const pages = getBuildPagesFromStore<GatsbyPageObject>({
 	withSizeProp: showGriddoBuildLogs,
-	dbFilePath,
 });
 
 const createPages: GatsbyNode["createPages"] = async ({ actions }) => {
-	console.log(`read assetPrefixWithDomain=${assetPrefixWithDomain}`);
-	console.log(`set needsAssetDomainPrefix=${needsAssetDomainPrefix}`);
-	console.log(`using NODE_OPTIONS in gatsby-node.ts: ${nodeOptions}`);
+	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`);
+	}
 
 	for await (const page of pages) {
 		if (!page) {
 			return;
 		}
 
+		const matchPath =
+			needsAssetDomainPrefix && useMatchPaths
+				? page.context.fullPath.compose
+				: "";
+
 		page.component = template;
+		page.matchPath = matchPath;
 
 		actions.createPage(page);
 
@@ -40,9 +65,46 @@ 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) {
-			console.log(`Creating page ${path} - ${id} - ${size}`);
+			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,
+		});
 	}
 };
 

package/gatsby-ssr.tsx

@@ -1,9 +1,8 @@
 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) {