@geode/opengeodeweb-front 10.34.0-rc.9 → 10.34.0

package/server/utils/extension.ts

@@ -1,6 +1,7 @@
 // Node imports
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { z } from "zod";
 
 // Third party imports
 import { createError } from "h3";
@@ -8,14 +9,17 @@ import { createError } from "h3";
 // Local imports
 import { extensionFrontendPath } from "@geode/opengeodeweb-front/server/utils/path.ts";
 
-interface ExtensionMetadata {
-  id: string;
-  name: string;
-  version: string;
-  frontendFile: string;
-  backendExecutable: string;
-  [key: string]: unknown;
-}
+const extensionMetadataSchema = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    version: z.string(),
+    frontendFile: z.string(),
+    backendExecutable: z.string(),
+  })
+  .loose();
+
+type ExtensionMetadata = z.infer<typeof extensionMetadataSchema>;
 
 async function readExtensionMetadata(unzippedExtensionPath: string): Promise<ExtensionMetadata> {
   const metadataPath = path.join(unzippedExtensionPath, "metadata.json");
@@ -26,7 +30,17 @@ async function readExtensionMetadata(unzippedExtensionPath: string): Promise<Ext
       statusMessage: "Invalid extension file: missing metadata.json",
     });
   }
-  const metadata = JSON.parse(metadataContent) as ExtensionMetadata;
+
+  const parsed: unknown = JSON.parse(metadataContent);
+  const result = extensionMetadataSchema.safeParse(parsed);
+  if (!result.success) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid extension file: malformed metadata.json",
+    });
+  }
+  const metadata = result.data;
+
   console.log("readExtensionMetadata", { metadata });
   if (!metadata.frontendFile) {
     throw createError({

package/server/utils/microservices.ts

@@ -1,5 +1,3 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
 // Node imports
 import child_process from "node:child_process";
 import fs from "node:fs";
@@ -9,13 +7,9 @@ import path from "node:path";
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
 
 // Local imports
+import { type Microservice, microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
+import { type NamedChildProcess, getAvailablePort, waitForReady } from "./scripts.js";
 import { addNginxLocation, addSupervisorProgram } from "./cloud.js";
-import { getAvailablePort, waitForReady } from "./scripts.js";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { NamedChildProcess } from "./scripts.js";
-import { microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { Microservice } from "./cleanup.js";
 import { executablePath } from "./path.js";
 
 interface RunArgs {
@@ -28,10 +22,11 @@ const MILLISECONDS_PER_SECOND = 1000;
 const DEFAULT_TIMEOUT_SECONDS = 45;
 const MAX_PORT_RETRIES = 1;
 const DEFAULT_RUN_ARGS: RunArgs = { projectFolderPath: "" };
+
 async function runScript(
   execPath: string,
   execName: string,
-  args: string[],
+  args: readonly string[],
   expectedResponse: string,
   timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
 ): Promise<NamedChildProcess> {
@@ -45,7 +40,9 @@ async function runScript(
     console.log(`[${child.name}] spawned, pid=${child.pid}`);
   });
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutSeconds * MILLISECONDS_PER_SECOND);
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeoutSeconds * MILLISECONDS_PER_SECOND);
   if (typeof timer.unref === "function") {
     timer.unref();
   }
@@ -59,6 +56,7 @@ async function runScript(
     throw error;
   }
 }
+
 function isPortInUseError(error: unknown): boolean {
   return /EADDRINUSE|address already in use|port already in use/iu.test(String(error));
 }
@@ -68,7 +66,10 @@ function backArgs(args: RunArgs, port: number): string[] {
   if (!projectFolderPath) {
     throw new Error("projectFolderPath is required");
   }
-  const uploadFolderPath = args.uploadFolderPath || path.join(projectFolderPath, "uploads");
+  const uploadFolderPath =
+    args.uploadFolderPath !== undefined && args.uploadFolderPath !== ""
+      ? args.uploadFolderPath
+      : path.join(projectFolderPath, "uploads");
   const executableArgs = [
     "--port",
     String(port),
@@ -81,7 +82,7 @@ function backArgs(args: RunArgs, port: number): string[] {
     "--timeout",
     "0",
   ];
-  if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
+  if (process.env.NODE_ENV === undefined || process.env.NODE_ENV === "development") {
     executableArgs.push("--debug");
   }
   return executableArgs;
@@ -92,7 +93,7 @@ async function runBack(
   execPath: string,
   args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
-): Promise<number | undefined> {
+): Promise<number> {
   let port: number | undefined = undefined;
   try {
     port = await getAvailablePort();
@@ -111,7 +112,7 @@ async function runBack(
       return newPort;
     }
   }
-  return undefined;
+  throw new Error(`runBack failed to run ${execName}`);
 }
 
 async function runViewer(
@@ -119,7 +120,7 @@ async function runViewer(
   execPath: string,
   args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
-): Promise<number | undefined> {
+): Promise<number> {
   const { projectFolderPath } = args;
   if (!projectFolderPath) {
     throw new Error("projectFolderPath is required");
@@ -140,7 +141,7 @@ async function runViewer(
     return port;
   } catch (error) {
     if (!isPortInUseError(error)) {
-      console.log("runBack error", error);
+      console.log("runViewer error", error);
       throw error;
     }
     if (attempts <= MAX_PORT_RETRIES) {
@@ -149,7 +150,7 @@ async function runViewer(
       return newPort;
     }
   }
-  return undefined;
+  throw new Error(`runViewer failed to run ${execName}`);
 }
 
 async function runExtension(
@@ -158,7 +159,7 @@ async function runExtension(
   execPath: string,
   args: RunArgs = DEFAULT_RUN_ARGS,
   attempts = 0,
-): Promise<number | undefined> {
+): Promise<number> {
   let port: number | undefined = undefined;
   try {
     port = await getAvailablePort();
@@ -170,7 +171,7 @@ async function runExtension(
     return port;
   } catch (error) {
     if (!isPortInUseError(error)) {
-      console.log("runBack error", error);
+      console.log("runExtension error", error);
       throw error;
     }
     if (attempts <= MAX_PORT_RETRIES) {
@@ -179,19 +180,26 @@ async function runExtension(
       return newPort;
     }
   }
-  return undefined;
+  throw new Error(`runExtension failed to run ${extensionId}`);
 }
 function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microservice): void {
   const microservices = projectMicroservices(projectFolderPath);
+  let enriched: Microservice = { ...serviceObj };
   if (serviceObj.type === "back") {
     const schema = back_schemas.opengeodeweb_back.kill;
-    serviceObj.url = `http://localhost:${serviceObj.port}/${schema.$id}`;
     const [method] = schema.methods;
-    serviceObj.method = method;
+    enriched = {
+      ...enriched,
+      url: `http://localhost:${serviceObj.port}/${schema.$id}`,
+      method,
+    };
   } else if (serviceObj.type === "viewer") {
-    serviceObj.url = `ws://localhost:${serviceObj.port}/ws`;
+    enriched = {
+      ...enriched,
+      url: `ws://localhost:${serviceObj.port}/ws`,
+    };
   }
-  microservices.push(serviceObj);
+  microservices.push(enriched);
   fs.writeFileSync(
     microservicesMetadatasPath(projectFolderPath),
     JSON.stringify(
@@ -203,4 +211,5 @@ function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microse
     ),
   );
 }
+
 export { addMicroserviceMetadatas, runBack, runExtension, runViewer };

package/server/utils/path.ts

@@ -53,13 +53,13 @@ function executablePath(execPath: string, execName: string): string {
   }
 
   const foundAtExecPath = findExecutableInDir(execPath, execName, osExecutableName);
-  if (foundAtExecPath) {
+  if (foundAtExecPath !== undefined && foundAtExecPath !== "") {
     return foundAtExecPath;
   }
   if (mode === appMode.DESKTOP && nodeEnv === "production") {
-    if (resourcesPath) {
+    if (resourcesPath !== undefined && resourcesPath !== "") {
       const foundInResources = findExecutableInDir(resourcesPath, execName, osExecutableName);
-      if (foundInResources) {
+      if (foundInResources !== undefined && foundInResources !== "") {
         return foundInResources;
       }
     }
@@ -140,7 +140,7 @@ async function extensionFrontendPath(
     extentionRepoName,
     frontendFile,
   );
-  if (localFilePath) {
+  if (localFilePath !== undefined && localFilePath !== "") {
     return localFilePath;
   }
   const unzippedfrontendFilePath = path.join(unzippedExtensionPath, frontendFile);

package/server/utils/scripts.ts

@@ -1,12 +1,10 @@
-// Not auto-fixable (eslint's sort-imports core rule has no autofixer) and this file's import order doesn't match its syntax-kind-then-alphabetical requirement - left as-is rather than manually reordered across the codebase for a purely cosmetic rule.
-// oxlint-disable eslint/sort-imports
 // Node imports
+import type { Readable } from "node:stream";
 import child_process from "node:child_process";
 import fs from "node:fs";
 import { on } from "node:events";
 import path from "node:path";
 import readline from "node:readline";
-import type { Readable } from "node:stream";
 
 // Third party imports
 import { getPort } from "get-port-please";
@@ -18,19 +16,23 @@ import { setAppBaseUrl } from "@geode/opengeodeweb-front/shared/scripts.ts";
 const BYTES_PER_KIBIBYTE = 1024;
 const MAX_ERROR_BUFFER_KIBIBYTES = 64;
 const MAX_ERROR_BUFFER_BYTES = MAX_ERROR_BUFFER_KIBIBYTES * BYTES_PER_KIBIBYTE;
-function getAvailablePort(): Promise<number> {
-  return getPort({
+
+async function getAvailablePort(): Promise<number> {
+  const port = await getPort({
     host: "localhost",
     random: true,
   });
+  return port;
 }
+
 function commandExistsSync(execName: string): boolean {
-  const envPath = process.env.PATH || "";
+  const envPath = process.env.PATH ?? "";
   return envPath.split(path.delimiter).some((directory) => {
     const filePath = path.join(directory, execName);
     return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
   });
 }
+
 const encoder = new TextEncoder();
 function byteLength(str: string): number {
   return encoder.encode(str).byteLength;
@@ -40,8 +42,8 @@ interface NamedChildProcess extends child_process.ChildProcessByStdio<null, Read
   name?: string;
 }
 
-// oxlint-disable-next-line max-lines-per-function
-function waitForReady(
+// oxlint-disable-next-line max-lines-per-function typescript/prefer-readonly-parameter-types eslint/require-await
+async function waitForReady(
   child: NamedChildProcess,
   expectedResponse: string,
   signal?: AbortSignal,
@@ -55,7 +57,7 @@ function waitForReady(
       input: child.stderr,
     });
     let recentOutput = "";
-    function recordOutput(lineOutput: string) {
+    function recordOutput(lineOutput: string): void {
       const safeLine =
         byteLength(lineOutput) > MAX_ERROR_BUFFER_BYTES / 2
           ? `${lineOutput.slice(0, MAX_ERROR_BUFFER_BYTES / 2)}…[truncated]`
@@ -76,7 +78,7 @@ function waitForReady(
     let onClose: ((code: number | null) => void) | undefined = undefined;
     let onAbort: (() => void) | undefined = undefined;
 
-    function cleanup() {
+    function cleanup(): void {
       if (onLine) {
         readlineStdout.removeListener("line", onLine);
       }
@@ -94,7 +96,7 @@ function waitForReady(
       }
     }
 
-    function becomeReady() {
+    function becomeReady(): void {
       cleanup();
       readlineStdout.on("line", (line) => {
         console.log(`[${child.name}] ${line}`);
@@ -108,7 +110,7 @@ function waitForReady(
       resolve(child);
     }
 
-    onLine = (lineOutput) => {
+    onLine = (lineOutput): void => {
       console.log(`[${child.name}] ${lineOutput}`);
       recordOutput(lineOutput);
       if (lineOutput.includes(expectedResponse)) {
@@ -116,7 +118,7 @@ function waitForReady(
       }
     };
 
-    onErrLine = (line) => {
+    onErrLine = (line): void => {
       console.log(`[${child.name}] ${line}`);
       recordOutput(line);
       if (line.includes(expectedResponse)) {
@@ -124,12 +126,12 @@ function waitForReady(
       }
     };
 
-    onError = (err) => {
+    onError = (err): void => {
       cleanup();
       reject(err);
     };
 
-    onClose = (code) => {
+    onClose = (code): void => {
       console.log(`[${child.name}] exited with code ${code}`);
       cleanup();
       reject(
@@ -139,7 +141,7 @@ function waitForReady(
       );
     };
 
-    onAbort = () => {
+    onAbort = (): void => {
       cleanup();
       reject(new Error(`[${child.name}] timed out waiting for "${expectedResponse}"`));
     };
@@ -157,22 +159,23 @@ function waitForReady(
 async function waitNuxt(
   nuxtProcess: child_process.ChildProcessWithoutNullStreams,
 ): Promise<string> {
-  nuxtProcess.stderr.on("data", (data) => {
+  nuxtProcess.stderr.on("data", (data: Buffer) => {
     console.log("Nuxt STDERR:", data.toString().trim());
   });
   nuxtProcess.on("close", (code) => {
     console.log(`Nuxt process closed with code ${code}`);
   });
   for await (const [data] of on(nuxtProcess.stdout, "data")) {
-    const output = data.toString();
+    const output = String(data);
     console.log("Nuxt STDOUT:", output.trim());
-    const portMatch = output.match(/Listening on http:\/\/\[::\]:(?<port>\d+)/u);
-    if (portMatch?.groups) {
-      console.log("Nuxt listening on port", portMatch.groups.port);
-      nuxtProcess.stdout.on("data", (newData) => {
+    const portMatch = /Listening on http:\/\/\[::\]:(?<port>\d+)/u.exec(output);
+    const port = portMatch?.groups?.port;
+    if (port !== undefined) {
+      console.log("Nuxt listening on port", port);
+      nuxtProcess.stdout.on("data", (newData: Buffer) => {
         console.log("Nuxt STDOUT:", newData.toString().trim());
       });
-      return portMatch.groups.port as string;
+      return port;
     }
   }
   throw new Error("Nuxt process closed");

package/server/utils/server.ts

@@ -18,13 +18,13 @@ async function extractZipArchive(zipFilePath: string, outputDir: string): Promis
 
     if (zipEntry.dir) {
       promises.push(
-        (async () => {
+        (async (): Promise<void> => {
           await fs.promises.mkdir(outputPath, { recursive: true });
         })(),
       );
     } else {
       promises.push(
-        (async () => {
+        (async (): Promise<void> => {
           const content = await zipEntry.async("nodebuffer");
           await fs.promises.mkdir(path.dirname(outputPath), {
             recursive: true,

package/server/utils/server_config.ts

@@ -1,50 +1,64 @@
-import { createServerWsRpcClient } from "./ws_client.js";
-// oxlint-disable-next-line eslint/no-duplicate-imports
-import type { ServerWsRpcClient } from "./ws_client.js";
+import { type ServerWsRpcClient, createServerWsRpcClient } from "./ws_client.js";
 
-const storage = new Map<string, unknown>();
-function getAppBaseUrl(): unknown {
-  return storage.get("APP_BASE_URL");
+const stringStorage = new Map<string, string>();
+const booleanStorage = new Map<string, boolean>();
+const clientStorage = new Map<string, ServerWsRpcClient>();
+
+function getAppBaseUrl(): string {
+  const value = stringStorage.get("APP_BASE_URL");
+  if (value === undefined) {
+    throw new Error("APP_BASE_URL is not set");
+  }
+  return value;
 }
-function setAppBaseUrl(baseUrl: string) {
-  return storage.set("APP_BASE_URL", baseUrl);
+function setAppBaseUrl(baseUrl: string): void {
+  stringStorage.set("APP_BASE_URL", baseUrl);
 }
-function getBackBaseUrl(): unknown {
-  return storage.get("BACK_BASE_URL");
+function getBackBaseUrl(): string {
+  const value = stringStorage.get("BACK_BASE_URL");
+  if (value === undefined) {
+    throw new Error("BACK_BASE_URL is not set");
+  }
+  return value;
 }
-function setBackBaseUrl(baseUrl: string) {
-  return storage.set("BACK_BASE_URL", baseUrl);
+function setBackBaseUrl(baseUrl: string): void {
+  stringStorage.set("BACK_BASE_URL", baseUrl);
 }
-function getViewerBaseUrl(): unknown {
-  return storage.get("VIEWER_BASE_URL");
+function getViewerBaseUrl(): string {
+  const value = stringStorage.get("VIEWER_BASE_URL");
+  if (value === undefined) {
+    throw new Error("VIEWER_BASE_URL is not set");
+  }
+  return value;
 }
-function setViewerBaseUrl(baseUrl: string) {
-  return storage.set("VIEWER_BASE_URL", baseUrl);
+function setViewerBaseUrl(baseUrl: string): void {
+  stringStorage.set("VIEWER_BASE_URL", baseUrl);
 }
-function getIsAppReady(): unknown {
-  return storage.get("IS_APP_READY") ?? false;
+function getIsAppReady(): boolean {
+  return booleanStorage.get("IS_APP_READY") ?? false;
 }
-function setIsAppReady(isAppReady: boolean) {
-  return storage.set("IS_APP_READY", isAppReady);
+function setIsAppReady(isAppReady: boolean): void {
+  booleanStorage.set("IS_APP_READY", isAppReady);
 }
 async function setViewerWebSocketClient(baseUrl: string): Promise<ServerWsRpcClient> {
   const client = createServerWsRpcClient(baseUrl);
   client.onConnectionClose(() => {
-    if (storage.get("VIEWER_CLIENT") === client) {
-      storage.delete("VIEWER_CLIENT");
+    if (clientStorage.get("VIEWER_CLIENT") === client) {
+      clientStorage.delete("VIEWER_CLIENT");
     }
   });
   await client.ready;
-  storage.set("VIEWER_CLIENT", client);
+  clientStorage.set("VIEWER_CLIENT", client);
   return client;
 }
 async function getViewerWebSocketClient(): Promise<ServerWsRpcClient> {
-  const viewerClient = (storage.get("VIEWER_CLIENT") as ServerWsRpcClient | undefined) ?? undefined;
-  if (viewerClient?.isOpen()) {
+  const viewerClient = clientStorage.get("VIEWER_CLIENT");
+  if (viewerClient !== undefined && viewerClient.isOpen()) {
     return viewerClient;
   }
-  const viewerBaseUrl = (await getViewerBaseUrl()) as string;
-  return setViewerWebSocketClient(viewerBaseUrl);
+  const viewerBaseUrl = getViewerBaseUrl();
+  const client = await setViewerWebSocketClient(viewerBaseUrl);
+  return client;
 }
 export {
   getAppBaseUrl,

package/server/utils/stream.ts

@@ -0,0 +1,6 @@
+import type { ReadableStream as NodeReadableStream } from "node:stream/web";
+
+export function toNodeWebStream(stream: ReadableStream): NodeReadableStream {
+  // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+  return stream as NodeReadableStream;
+}

package/server/utils/ws_client.ts

@@ -1,4 +1,3 @@
-/// <reference path="../types/vendor.d.ts" />
 // Third party imports
 import { WebSocket } from "ws";
 import { v4 as uuidv4 } from "uuid";
@@ -19,9 +18,29 @@ interface WsRpcMessage {
   result?: unknown;
 }
 
+function isWsRpcMessage(value: unknown): value is WsRpcMessage {
+  return typeof value === "object" && value !== null;
+}
+
+// oxlint-disable-next-line prefer-readonly-parameter-types
+function rawDataToString(raw: WebSocket.RawData): string {
+  if (Buffer.isBuffer(raw)) {
+    return raw.toString();
+  }
+  if (Array.isArray(raw)) {
+    return Buffer.concat(raw).toString();
+  }
+  return Buffer.from(raw).toString();
+}
+
 interface ServerWsRpcClient {
   call: (rpc: string, params?: Record<string, unknown>) => Promise<unknown>;
   close: () => void;
+  getConnection: () => {
+    getSession: () => {
+      call: (rpc: string, params: readonly [Record<string, unknown>]) => Promise<unknown>;
+    };
+  };
   isOpen: () => boolean;
   onConnectionClose: (callback: () => void) => void;
   onConnectionError: (callback: (error: unknown) => void) => void;
@@ -35,7 +54,7 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
   let onCloseCallback: (() => void) | undefined = undefined;
   let onErrorCallback: ((error: unknown) => void) | undefined = undefined;
 
-  //oxlint-disable-next-line promise/avoid-new
+  //oxlint-disable-next-line promise/avoid-new max-lines-per-function
   const ready = new Promise<void>((resolve, reject) => {
     socket.on("open", () => {
       socket.send(
@@ -47,11 +66,15 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
       );
     });
 
-    socket.on("message", (raw) => {
-      console.log("RAW WS MESSAGE:", raw.toString());
+    // oxlint-disable-next-line prefer-readonly-parameter-types
+    socket.on("message", (raw: WebSocket.RawData) => {
       let message: WsRpcMessage | undefined = undefined;
       try {
-        message = JSON.parse(raw.toString()) as WsRpcMessage;
+        const parsed: unknown = JSON.parse(rawDataToString(raw));
+        if (!isWsRpcMessage(parsed)) {
+          return;
+        }
+        message = parsed;
       } catch {
         return;
       }
@@ -71,13 +94,13 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
       }
       pending.delete(message.id);
       if (message.error) {
-        entry.reject(new Error(message.error.message || "wslink RPC error"));
+        entry.reject(new Error(message.error.message ?? "wslink RPC error"));
       } else {
         entry.resolve(message.result);
       }
     });
 
-    socket.on("error", (error) => {
+    socket.on("error", (error: Error) => {
       onErrorCallback?.(error);
       reject(error);
     });
@@ -113,6 +136,17 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
     socket.close();
   }
 
+  function getConnection(): ReturnType<ServerWsRpcClient["getConnection"]> {
+    return {
+      getSession: () => ({
+        call: async (rpc: string, [params]: readonly [Record<string, unknown>]) => {
+          const result = await call(rpc, params);
+          return result;
+        },
+      }),
+    };
+  }
+
   function isOpen(): boolean {
     return socket.readyState === WebSocket.OPEN;
   }
@@ -127,7 +161,7 @@ function createServerWsRpcClient(baseUrl: string): ServerWsRpcClient {
     onErrorCallback = callback;
   }
 
-  return { call, close, isOpen, onConnectionClose, onConnectionError, ready };
+  return { call, close, getConnection, isOpen, onConnectionClose, onConnectionError, ready };
 }
 
 export { createServerWsRpcClient };

package/shared/scripts.ts

@@ -7,38 +7,43 @@ import { fetchSchema } from "./utils/fetch_schema.js";
 
 import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
 
-function setAppBaseUrl(appBaseUrl: string) {
+async function setAppBaseUrl(appBaseUrl: string): Promise<unknown> {
   console.log("[API] setAppBaseUrl", appBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_app_base_url;
   const params = { baseUrl: appBaseUrl };
-  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
+  return result;
 }
 
-function setBackBaseUrl(appBaseUrl: string, backBaseUrl: string) {
+async function setBackBaseUrl(appBaseUrl: string, backBaseUrl: string): Promise<unknown> {
   console.log("[API] setBackBaseUrl", appBaseUrl, backBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_back_base_url;
   const params = { baseUrl: backBaseUrl };
-  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
+  return result;
 }
 
-function setViewerBaseUrl(appBaseUrl: string, viewerBaseUrl: string) {
+async function setViewerBaseUrl(appBaseUrl: string, viewerBaseUrl: string): Promise<unknown> {
   console.log("[API] setViewerBaseUrl", appBaseUrl, viewerBaseUrl);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_viewer_base_url;
   const params = { baseUrl: viewerBaseUrl };
-  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
+  return result;
 }
 
-function setIsAppReady(appBaseUrl: string, isReady: boolean) {
+async function setIsAppReady(appBaseUrl: string, isReady: boolean): Promise<unknown> {
   console.log("[API] setIsAppReady", isReady);
   const schema = opengeodeweb_front_schemas.api.microservice.app.set_is_app_ready;
   const params = { isReady };
-  return fetchSchema({ schema, params, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, params, baseURL: appBaseUrl });
+  return result;
 }
 
-function getIsAppReady(appBaseUrl: string) {
+async function getIsAppReady(appBaseUrl: string): Promise<unknown> {
   console.log("[API] getIsAppReady");
   const schema = opengeodeweb_front_schemas.api.microservice.app.get_is_app_ready;
-  return fetchSchema({ schema, baseURL: appBaseUrl });
+  const result = await fetchSchema({ schema, baseURL: appBaseUrl });
+  return result;
 }
 
 export { getIsAppReady, setAppBaseUrl, setBackBaseUrl, setIsAppReady, setViewerBaseUrl };