@geode/opengeodeweb-front 10.35.0-rc.4 → 10.35.0-rc.6

package/.build/server/utils/app_config.js

@@ -2,11 +2,12 @@ import path from "node:path";
 import { unlink } from "node:fs/promises";
 import Conf from "conf";
 import StreamZip from "node-stream-zip";
+import { consola } from "consola";
 import sanitize from "sanitize-filename";
 //#region server/utils/app_config.ts
 function projectConf(projectName) {
 	const projectConfig = new Conf({ projectName });
-	console.log(projectConf.name, { projectConfig });
+	consola.debug(projectConf.name, { projectConfig });
 	return projectConfig;
 }
 function confFolderPath(projectName) {
@@ -30,9 +31,9 @@ async function removeExtensionFromConf(projectName, extensionId) {
 	const projectConfig = projectConf(projectName);
 	const extensionArchivePath = extensionPathFromConf(projectName, extensionId);
 	await unlink(extensionArchivePath);
-	console.log(`${extensionArchivePath} was deleted`);
+	consola.info(`${extensionArchivePath} was deleted`);
 	projectConfig.delete(`extensions.${extensionId}`);
-	console.log(`${extensionId} was deleted from ${projectName} config`);
+	consola.info(`${extensionId} was deleted from ${projectName} config`);
 }
 function isExtensionMetadata(value) {
 	return typeof value === "object" && value !== null && "id" in value && typeof value.id === "string";

package/.build/server/utils/cleanup.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { consola } from "consola";
 import fs from "node:fs";
 import { setTimeout } from "node:timers/promises";
 import { WebSocket } from "ws";
@@ -8,19 +9,19 @@ import { rimraf } from "rimraf";
 const MAX_DELETE_FOLDER_RETRIES = 5;
 async function deleteFolderRecursive(folderPath) {
 	if (!fs.existsSync(folderPath)) {
-		console.log(`Folder ${folderPath} does not exist.`);
+		consola.info(`Folder ${folderPath} does not exist.`);
 		return;
 	}
 	for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) try {
-		console.log(`Deleting folder: ${folderPath}`);
+		consola.info(`Deleting folder: ${folderPath}`);
 		await rimraf(folderPath);
-		console.log(`Deleted folder: ${folderPath}`);
+		consola.info(`Deleted folder: ${folderPath}`);
 		return;
 	} catch (error) {
-		console.error(`Error deleting folder ${folderPath}:`, error);
+		consola.error(`Error deleting folder ${folderPath}:`, error);
 		const DELAY = 1e3 * (i + 1);
 		await setTimeout(DELAY);
-		console.log("Retrying delete folder");
+		consola.info("Retrying delete folder");
 	}
 	throw new Error(`Failed to delete folder ${folderPath} after ${MAX_DELETE_FOLDER_RETRIES} retries`);
 }
@@ -28,7 +29,7 @@ function isErrorWithMessage(error) {
 	return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
 }
 async function killHttpMicroservice(microservice) {
-	console.log("killHttpMicroservice", { ...microservice });
+	consola.debug("killHttpMicroservice", { ...microservice });
 	const failMessage = `Failed to kill ${microservice.name}`;
 	async function do_kill() {
 		if (microservice.url === void 0) return;
@@ -36,7 +37,7 @@ async function killHttpMicroservice(microservice) {
 			await fetch(microservice.url, { method: microservice.method });
 		} catch (error) {
 			const message = isErrorWithMessage(error) ? error.message : String(error);
-			console.log(`Expected error during kill of ${microservice.name}:`, message);
+			consola.info(`Expected error during kill of ${microservice.name}:`, message);
 		}
 	}
 	await pTimeout(do_kill(), {
@@ -45,7 +46,7 @@ async function killHttpMicroservice(microservice) {
 	});
 }
 async function killWebsocketMicroservice(microservice) {
-	console.log("killWebsocketMicroservice", { ...microservice });
+	consola.debug("killWebsocketMicroservice", { ...microservice });
 	const failMessage = `Failed to kill ${microservice.name}`;
 	const successMessage = `Disconnected from ${microservice.name} WebSocket server`;
 	async function do_kill() {
@@ -54,7 +55,7 @@ async function killWebsocketMicroservice(microservice) {
 		await new Promise((resolve) => {
 			const socket = new WebSocket(socketUrl);
 			socket.on("open", () => {
-				console.log("Connected to WebSocket server");
+				consola.info("Connected to WebSocket server");
 				socket.send(JSON.stringify({
 					id: "system:hello",
 					method: "wslink.hello",
@@ -63,23 +64,23 @@ async function killWebsocketMicroservice(microservice) {
 			});
 			socket.on("message", (data) => {
 				const message = data.toString();
-				console.log("Received from server:", message);
+				consola.debug("Received from server:", message);
 				if (message.includes("hello")) {
 					socket.send(JSON.stringify({
 						id: "application.exit",
 						method: "application.exit"
 					}));
-					console.log(successMessage);
+					consola.info(successMessage);
 					socket.close();
 					resolve();
 				}
 			});
 			socket.on("close", () => {
-				console.log(successMessage);
+				consola.info(successMessage);
 				resolve();
 			});
 			socket.on("error", (error) => {
-				console.error("WebSocket error:", error);
+				consola.error("WebSocket error:", error);
 				socket.close();
 				resolve();
 			});
@@ -99,7 +100,7 @@ async function killMicroservice(microservice) {
 	}
 }
 async function killMicroservices(microservices) {
-	console.log("killMicroservices", { microservices });
+	consola.debug("killMicroservices", { microservices });
 	const results = await Promise.allSettled(microservices.map(async (microservice) => {
 		await killMicroservice(microservice);
 	}));
@@ -112,7 +113,7 @@ function isMicroservicesMetadatas(value) {
 	return typeof value === "object" && value !== null && Array.isArray(value.microservices);
 }
 function projectMicroservices(projectFolderPath) {
-	console.log("projectMicroservices", { projectFolderPath });
+	consola.debug("projectMicroservices", { projectFolderPath });
 	const filePath = microservicesMetadatasPath(projectFolderPath);
 	if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, JSON.stringify({ microservices: [] }, void 0, 2), "utf8");
 	const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
@@ -121,7 +122,7 @@ function projectMicroservices(projectFolderPath) {
 }
 async function cleanupBackend(projectFolderPath) {
 	if (!fs.existsSync(projectFolderPath)) {
-		console.log(`Folder ${projectFolderPath} does not exist. Skipping cleanup.`);
+		consola.info(`Folder ${projectFolderPath} does not exist. Skipping cleanup.`);
 		return;
 	}
 	await killMicroservices(projectMicroservices(projectFolderPath));

package/.build/server/utils/cloud.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { consola } from "consola";
 import fs from "node:fs";
 import { execFileSync } from "node:child_process";
 //#region server/utils/cloud.ts
@@ -19,7 +20,7 @@ stderr_logfile_maxbytes=0
 	execFileSync("supervisorctl", ["reread"]);
 	execFileSync("supervisorctl", ["update"]);
 	const stdout = execFileSync("supervisorctl", ["start", name]);
-	console.log("addSupervisorProgram", stdout);
+	consola.info("addSupervisorProgram", stdout);
 }
 function buildLocationBlock(routePath, port) {
 	if (!routePath.startsWith("/") || !routePath.endsWith("/")) throw new Error(`routePath must start and end with '/', got: ${routePath}`);

package/.build/server/utils/microservices.js

@@ -3,6 +3,7 @@ import { addNginxLocation, addSupervisorProgram } from "./cloud.js";
 import { getAvailablePort, waitForReady } from "./scripts.js";
 import { executablePath } from "./path.js";
 import path from "node:path";
+import { consola } from "consola";
 import fs from "node:fs";
 import child_process from "node:child_process";
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
@@ -13,7 +14,7 @@ const MAX_PORT_RETRIES = 1;
 const DEFAULT_RUN_ARGS = { projectFolderPath: "" };
 async function runScript(execPath, execName, args, expectedResponse, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS) {
 	const command = executablePath(execPath, execName);
-	console.log("runScript", command, args);
+	consola.debug("runScript", command, args);
 	const child = child_process.spawn(command, args, { stdio: [
 		"ignore",
 		"pipe",
@@ -21,7 +22,7 @@ async function runScript(execPath, execName, args, expectedResponse, timeoutSeco
 	] });
 	child.name = command.replace(/^.*[\\/]/u, "");
 	child.on("spawn", () => {
-		console.log(`[${child.name}] spawned, pid=${child.pid}`);
+		consola.info(`[${child.name}] spawned, pid=${child.pid}`);
 	});
 	const controller = new AbortController();
 	const timer = setTimeout(() => {
@@ -65,16 +66,16 @@ async function runBack(execName, execPath, args = DEFAULT_RUN_ARGS, attempts = 0
 	try {
 		port = await getAvailablePort();
 		const executableArgs = backArgs(args, port);
-		console.log("runBack", execPath, execName, executableArgs);
+		consola.debug("runBack", execPath, execName, executableArgs);
 		await runScript(execPath, execName, executableArgs, "Serving Flask app");
 		return port;
 	} catch (error) {
 		if (!isPortInUseError(error)) {
-			console.log("runBack error", error);
+			consola.error("runBack error", error);
 			throw error;
 		}
 		if (attempts <= MAX_PORT_RETRIES) {
-			console.log("Retrying runBack on conflicting port", port);
+			consola.info("Retrying runBack on conflicting port", port);
 			return await runBack(execName, execPath, args, attempts + 1);
 		}
 	}
@@ -94,16 +95,16 @@ async function runViewer(execName, execPath, args = DEFAULT_RUN_ARGS, attempts =
 			"--timeout",
 			"0"
 		];
-		console.log("runViewer", execPath, execName, viewerArgs);
+		consola.debug("runViewer", execPath, execName, viewerArgs);
 		await runScript(execPath, execName, viewerArgs, "Starting factory");
 		return port;
 	} catch (error) {
 		if (!isPortInUseError(error)) {
-			console.log("runViewer error", error);
+			consola.error("runViewer error", error);
 			throw error;
 		}
 		if (attempts <= MAX_PORT_RETRIES) {
-			console.log("Retrying runViewer on conflicting port", port);
+			consola.info("Retrying runViewer on conflicting port", port);
 			return await runViewer(execName, execPath, args, attempts + 1);
 		}
 	}
@@ -115,17 +116,17 @@ async function runExtension(extensionId, execName, execPath, args = DEFAULT_RUN_
 		port = await getAvailablePort();
 		const executableArgs = backArgs(args, port);
 		const command = executablePath(execPath, execName);
-		console.log("runExtension", execPath, execName, executableArgs);
+		consola.debug("runExtension", execPath, execName, executableArgs);
 		addSupervisorProgram(extensionId, command, executableArgs);
 		addNginxLocation(extensionId, port);
 		return port;
 	} catch (error) {
 		if (!isPortInUseError(error)) {
-			console.log("runExtension error", error);
+			consola.error("runExtension error", error);
 			throw error;
 		}
 		if (attempts <= MAX_PORT_RETRIES) {
-			console.log("Retrying runExtension on conflicting port", port);
+			consola.info("Retrying runExtension on conflicting port", port);
 			return await runExtension(extensionId, execName, execPath, args, attempts + 1);
 		}
 	}

package/.build/server/utils/path.js

@@ -1,6 +1,7 @@
 import { appMode } from "../../shared/app_mode.js";
 import { commandExistsSync } from "./scripts.js";
 import path from "node:path";
+import { consola } from "consola";
 import fs from "node:fs";
 import { setTimeout } from "node:timers/promises";
 import os from "node:os";
@@ -13,22 +14,22 @@ function executableName(execName) {
 function findExecutableInDir(baseDir, execName, osExecutableName) {
 	const oneFilePath = path.join(baseDir, osExecutableName);
 	if (fs.existsSync(oneFilePath) && fs.statSync(oneFilePath).isFile()) {
-		console.log(`[executablePath] Found OneFile executable: ${oneFilePath}`);
+		consola.info(`[executablePath] Found OneFile executable: ${oneFilePath}`);
 		return oneFilePath;
 	}
 	const oneDirPath = path.join(baseDir, execName, osExecutableName);
 	if (fs.existsSync(oneDirPath) && fs.statSync(oneDirPath).isFile()) {
-		console.log(`[executablePath] Found OneDir executable: ${oneDirPath}`);
+		consola.info(`[executablePath] Found OneDir executable: ${oneDirPath}`);
 		return oneDirPath;
 	}
-	console.log(`[executablePath] Executable not found in ${baseDir} (tried OneFile and OneDir): ${execName}`);
+	consola.info(`[executablePath] Executable not found in ${baseDir} (tried OneFile and OneDir): ${execName}`);
 }
 function executablePath(execPath, execName) {
 	const osExecutableName = executableName(execName);
 	const resourcesPath = process.env.RESOURCES_PATH;
 	const mode = process.env.MODE;
 	const nodeEnv = process.env.NODE_ENV;
-	console.log("[executablePath]", {
+	consola.debug("[executablePath]", {
 		execPath,
 		execName,
 		mode,
@@ -36,7 +37,7 @@ function executablePath(execPath, execName) {
 		resourcesPath
 	});
 	if (commandExistsSync(osExecutableName)) {
-		console.log(`[executablePath] Found executable in PATH: ${osExecutableName}`);
+		consola.info(`[executablePath] Found executable in PATH: ${osExecutableName}`);
 		return osExecutableName;
 	}
 	const foundAtExecPath = findExecutableInDir(execPath, execName, osExecutableName);
@@ -53,7 +54,7 @@ function executablePath(execPath, execName) {
 function createPath(dirPath) {
 	if (!fs.existsSync(dirPath)) {
 		fs.mkdirSync(dirPath, { recursive: true });
-		console.log(`${dirPath} directory created successfully!`);
+		consola.info(`${dirPath} directory created successfully!`);
 	}
 	return dirPath;
 }
@@ -67,7 +68,7 @@ async function lookForLocalExtensionDistPath(rootPath, extentionRepoName, fronte
 	const localExtensionPath = path.join(rootPath, "..", extentionRepoName);
 	const localExtensionDistPath = path.join(localExtensionPath, "dist");
 	if (!fs.existsSync(localExtensionDistPath)) return;
-	console.log(`[extensionFrontendPath] Found existing folder: ${localExtensionDistPath}, deleting it...`);
+	consola.info(`[extensionFrontendPath] Found existing folder: ${localExtensionDistPath}, deleting it...`);
 	fs.rmSync(localExtensionDistPath, {
 		recursive: true,
 		force: true
@@ -79,15 +80,15 @@ async function lookForLocalExtensionDistPath(rootPath, extentionRepoName, fronte
 	const MILLISECONDS_PER_RETRY = 1e3;
 	for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
 		if (fs.existsSync(rebuiltFilePath)) {
-			console.log(`Found rebuilt file: ${rebuiltFilePath}`);
+			consola.info(`Found rebuilt file: ${rebuiltFilePath}`);
 			return rebuiltFilePath;
 		}
-		console.log(`Waiting for rebuild... attempt ${i}/${MAX_DELETE_FOLDER_RETRIES}`);
+		consola.info(`Waiting for rebuild... attempt ${i}/${MAX_DELETE_FOLDER_RETRIES}`);
 		await setTimeout(MILLISECONDS_PER_RETRY);
 	}
 }
 async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPath, extensionId) {
-	console.log("[extensionFrontendPath]", {
+	consola.debug("[extensionFrontendPath]", {
 		unzippedExtensionPath,
 		frontendFile,
 		rootPath,
@@ -101,7 +102,7 @@ async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPa
 }
 function extensionBackendPath(unzippedExtensionPath, backendExecutableName) {
 	const backendExecutablePath = path.join(unzippedExtensionPath, executableName(backendExecutableName));
-	console.log("runExtensions", { backendExecutablePath });
+	consola.debug("runExtensions", { backendExecutablePath });
 	return backendExecutablePath;
 }
 //#endregion

package/.build/server/utils/scripts.js

@@ -1,6 +1,7 @@
 import { appMode } from "../../shared/app_mode.js";
 import { setAppBaseUrl } from "../../shared/scripts.js";
 import path from "node:path";
+import { consola } from "consola";
 import fs from "node:fs";
 import child_process from "node:child_process";
 import { on } from "node:events";
@@ -56,23 +57,23 @@ async function waitForReady(child, expectedResponse, signal) {
 		function becomeReady() {
 			cleanup();
 			readlineStdout.on("line", (line) => {
-				console.log(`[${child.name}] ${line}`);
+				consola.info(`[${child.name}] ${line}`);
 			});
 			readlineStderr.on("line", (line) => {
-				console.log(`[${child.name}] ${line}`);
+				consola.info(`[${child.name}] ${line}`);
 			});
 			child.once("close", (code) => {
-				console.log(`[${child.name}] exited with code ${code}`);
+				consola.info(`[${child.name}] exited with code ${code}`);
 			});
 			resolve(child);
 		}
 		onLine = (lineOutput) => {
-			console.log(`[${child.name}] ${lineOutput}`);
+			consola.info(`[${child.name}] ${lineOutput}`);
 			recordOutput(lineOutput);
 			if (lineOutput.includes(expectedResponse)) becomeReady();
 		};
 		onErrLine = (line) => {
-			console.log(`[${child.name}] ${line}`);
+			consola.info(`[${child.name}] ${line}`);
 			recordOutput(line);
 			if (line.includes(expectedResponse)) becomeReady();
 		};
@@ -81,7 +82,7 @@ async function waitForReady(child, expectedResponse, signal) {
 			reject(err);
 		};
 		onClose = (code) => {
-			console.log(`[${child.name}] exited with code ${code}`);
+			consola.info(`[${child.name}] exited with code ${code}`);
 			cleanup();
 			reject(/* @__PURE__ */ new Error(`[${child.name}] exited with code ${code} before becoming ready.${recentOutput ? `\nRecent output:\n${recentOutput}` : ""}`));
 		};
@@ -98,19 +99,19 @@ async function waitForReady(child, expectedResponse, signal) {
 }
 async function waitNuxt(nuxtProcess) {
 	nuxtProcess.stderr.on("data", (data) => {
-		console.log("Nuxt STDERR:", data.toString().trim());
+		consola.info("Nuxt STDERR:", data.toString().trim());
 	});
 	nuxtProcess.on("close", (code) => {
-		console.log(`Nuxt process closed with code ${code}`);
+		consola.info(`Nuxt process closed with code ${code}`);
 	});
 	for await (const [data] of on(nuxtProcess.stdout, "data")) {
 		const output = String(data);
-		console.log("Nuxt STDOUT:", output.trim());
+		consola.info("Nuxt STDOUT:", output.trim());
 		const port = /Listening on http:\/\/\[::\]:(?<port>\d+)/u.exec(output)?.groups?.port;
 		if (port !== void 0) {
-			console.log("Nuxt listening on port", port);
+			consola.info("Nuxt listening on port", port);
 			nuxtProcess.stdout.on("data", (newData) => {
-				console.log("Nuxt STDOUT:", newData.toString().trim());
+				consola.info("Nuxt STDOUT:", newData.toString().trim());
 			});
 			return port;
 		}

package/.build/server/utils/server.js

@@ -1,4 +1,5 @@
 import path from "node:path";
+import { consola } from "consola";
 import fs from "node:fs";
 import JSZip from "jszip";
 import { extract } from "tar";
@@ -28,15 +29,15 @@ async function extractTarArchive(archivePath, outputDir) {
 	});
 }
 async function unzipFile(zipFilePath, outputDir = zipFilePath.replace(/\.[^/.]+$/u, "")) {
-	console.log("Unzipping file...", zipFilePath, outputDir);
+	consola.info("Unzipping file...", zipFilePath, outputDir);
 	try {
 		await fs.promises.mkdir(outputDir, { recursive: true });
 		if (TAR_ARCHIVE_PATTERN.test(zipFilePath)) await extractTarArchive(zipFilePath, outputDir);
 		else await extractZipArchive(zipFilePath, outputDir);
-		console.log("Extraction complete!");
+		consola.info("Extraction complete!");
 		return outputDir;
 	} catch (error) {
-		console.error("Error unzipping file:", error);
+		consola.error("Error unzipping file:", error);
 		throw error;
 	}
 }

package/.build/shared/scripts.js

@@ -1,8 +1,9 @@
 import { fetchSchema } from "./utils/fetch_schema.js";
 import { api } from "../opengeodeweb_front_schemas.js";
+import { consola } from "consola";
 //#region shared/scripts.ts
 async function setAppBaseUrl(appBaseUrl) {
-	console.log("[API] setAppBaseUrl", appBaseUrl);
+	consola.info("[API] setAppBaseUrl", appBaseUrl);
 	const schema = api.microservice.app.set_app_base_url;
 	return await fetchSchema({
 		schema,
@@ -11,7 +12,7 @@ async function setAppBaseUrl(appBaseUrl) {
 	});
 }
 async function setBackBaseUrl(appBaseUrl, backBaseUrl) {
-	console.log("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
+	consola.info("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
 	const schema = api.microservice.app.set_back_base_url;
 	return await fetchSchema({
 		schema,
@@ -20,7 +21,7 @@ async function setBackBaseUrl(appBaseUrl, backBaseUrl) {
 	});
 }
 async function setViewerBaseUrl(appBaseUrl, viewerBaseUrl) {
-	console.log("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
+	consola.info("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
 	const schema = api.microservice.app.set_viewer_base_url;
 	return await fetchSchema({
 		schema,
@@ -29,7 +30,7 @@ async function setViewerBaseUrl(appBaseUrl, viewerBaseUrl) {
 	});
 }
 async function setIsAppReady(appBaseUrl, isReady) {
-	console.log("[API] setIsAppReady", isReady);
+	consola.info("[API] setIsAppReady", isReady);
 	const schema = api.microservice.app.set_is_app_ready;
 	return await fetchSchema({
 		schema,
@@ -38,7 +39,7 @@ async function setIsAppReady(appBaseUrl, isReady) {
 	});
 }
 async function getIsAppReady(appBaseUrl) {
-	console.log("[API] getIsAppReady");
+	consola.info("[API] getIsAppReady");
 	const schema = api.microservice.app.get_is_app_ready;
 	return await fetchSchema({
 		schema,

package/.build/shared/utils/call_schema.js

@@ -1,11 +1,12 @@
 import { validateSchema } from "./validate_schema.js";
 import { callRaw } from "./call_raw.js";
+import { consola } from "consola";
 //#region shared/utils/call_schema.ts
 const ERROR_400 = 400;
 async function callSchema({ schema, params = {}, client, timeout }, { request_error_function, response_function, response_error_function, validation_error_function } = {}) {
 	const { valid, error: schema_error } = validateSchema(schema, params);
 	if (!valid) {
-		if (process.env.NODE_ENV !== "production") console.log("Bad request", schema_error, schema, params);
+		if (process.env.NODE_ENV !== "production") consola.error("Bad request", schema_error, schema, params);
 		if (validation_error_function) validation_error_function({
 			code: ERROR_400,
 			name: "Bad request",

package/.build/shared/utils/fetch_schema.js

@@ -1,11 +1,12 @@
 import { fetchRaw } from "./fetch_raw.js";
 import { validateSchema } from "./validate_schema.js";
+import { consola } from "consola";
 //#region shared/utils/fetch_schema.ts
 const ERROR_400 = 400;
 async function fetchSchema({ schema, params = {}, baseURL, headers, timeout, expectEvent = false }, { request_error_function, response_function, response_error_function, validation_error_function } = {}) {
 	const { valid, error: schema_error } = validateSchema(schema, params);
 	if (!valid) {
-		if (process.env.NODE_ENV !== "production") console.log("Bad request", schema_error, schema, params);
+		if (process.env.NODE_ENV !== "production") consola.error("Bad request", schema_error, schema, params);
 		if (validation_error_function) validation_error_function({
 			code: ERROR_400,
 			name: "Bad request",

package/.build/shared/utils/file.js

@@ -1,9 +1,10 @@
+import { consola } from "consola";
 import _ from "lodash";
 //#region shared/utils/file.ts
 const BYTES_PER_KIBIBYTE = 1024;
 const CHUNK_SIZE_BYTES = 8192 * BYTES_PER_KIBIBYTE;
 function assertFile(file) {
-	console.log("[ASSERT_FILE] Asserting file", { file });
+	consola.debug("[ASSERT_FILE] Asserting file", { file });
 	if (!(file instanceof File)) throw new Error("file must be an instance of File");
 }
 function hasBody(params) {

package/app/components/InfraConnected.vue

@@ -2,7 +2,6 @@
 import { useInfraStore } from "@ogw_front/stores/infra";
 
 const infraStore = useInfraStore();
-console.log("TEST", { infraStore });
 </script>
 
 <template>

package/app/components/Viewer/ContextMenu/InfoCard.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import GlassCard from "@ogw_front/components/GlassCard.vue";
+import { consola } from "consola";
 import { middleTruncate } from "@ogw_front/utils/string";
 import { useCopyToClipboard } from "@ogw_front/composables/copy_to_clipboard";
 import { useDataStore } from "@ogw_front/stores/data";
@@ -110,7 +111,7 @@ async function copyId(targetId: string | undefined): Promise<void> {
     await copy(targetId);
     copiedId.value = targetId;
   } catch (error) {
-    console.error("Failed to copy ID:", error);
+    consola.error("Failed to copy ID:", error);
   }
 }
 

package/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue

@@ -4,6 +4,7 @@ import type { DisplayItem } from "@ogw_front/composables/virtual_tree";
 import ObjectTreeControls from "@ogw_front/components/Viewer/ObjectTree/Base/Controls.vue";
 import ObjectTreeItemLabel from "@ogw_front/components/Viewer/ObjectTree/Base/ItemLabel.vue";
 import { compareSelections } from "@ogw_front/utils/treeview";
+import { consola } from "consola";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
 import { useHoverhighlight } from "@ogw_front/composables/hover_highlight";
@@ -105,7 +106,7 @@ watch(
           const hasCollections = await dataStore.hasCollectionComponents(model.id);
           hasCollectionsMap[model.id] = hasCollections;
         } catch (error) {
-          console.error("Failed to check collections", error);
+          consola.error("Failed to check collections", error);
         }
       }
     });

package/app/composables/hover_highlight.ts

@@ -1,4 +1,5 @@
 import type { JsonRpcSchema } from "@ogw_shared/utils/types";
+import { consola } from "consola";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import vtk_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
@@ -60,7 +61,7 @@ export function useHoverhighlight(): {
       try {
         await viewerStore.request({ schema, params });
       } catch (error) {
-        console.error(`Highlight failed for ${type} ${id}:`, error);
+        consola.error(`Highlight failed for ${type} ${id}:`, error);
       }
     }
 
@@ -95,7 +96,7 @@ export function useHoverhighlight(): {
     try {
       await viewerStore.request(request);
     } catch (error) {
-      console.error(`Unhighlight failed for ${type} ${id}:`, error);
+      consola.error(`Unhighlight failed for ${type} ${id}:`, error);
     }
   }
 

package/app/composables/project_manager.ts

@@ -46,7 +46,6 @@ function isFileDownloadData(
 }
 
 async function exportProject(): Promise<{ result: unknown }> {
-  console.log("[export triggered]");
   const appStore = useAppStore();
   const backStore = useBackStore();
   const feedbackStore = useFeedbackStore();

package/app/composables/run_function_when_microservices_connected.ts

@@ -3,7 +3,6 @@ import { useInfraStore } from "@ogw_front/stores/infra";
 export function runFunctionWhenMicroservicesConnected(functionToRun: () => void): void {
   const infraStore = useInfraStore();
   const { microservices_connected } = storeToRefs(infraStore);
-  console.log("inside microservices_connected", microservices_connected.value);
   if (microservices_connected.value) {
     functionToRun();
   }
@@ -11,7 +10,6 @@ export function runFunctionWhenMicroservicesConnected(functionToRun: () => void)
     microservices_connected,
     (value) => {
       if (value) {
-        console.log("watch microservices_connected", value);
         functionToRun();
       }
     },

package/app/composables/use_adaptive_styles.ts

@@ -1,4 +1,5 @@
 import type { MaybeComputedElementRef } from "@vueuse/core";
+import { consola } from "consola";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useTreeviewStore } from "@ogw_front/stores/treeview";
 
@@ -156,7 +157,7 @@ export function useAdaptiveStyles(
       try {
         await forceRefresh();
       } catch (error) {
-        console.error("forceRefresh failed:", error);
+        consola.error("forceRefresh failed:", error);
       }
     });
   }

package/app/composables/use_quick_colormap.ts

@@ -1,3 +1,4 @@
+import { consola } from "consola";
 import { useViewerStore } from "@ogw_front/stores/viewer";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
 
@@ -46,7 +47,7 @@ export function useQuickColormap(): {
         return true;
       }
     } catch (error) {
-      console.error("Error picking colormap:", error);
+      consola.error("Error picking colormap:", error);
     }
     return false;
   }