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

package/server/api/microservice/app/get_is_app_ready.get.ts

@@ -4,17 +4,16 @@ import { createError, defineEventHandler } from "h3";
 // Local imports
 import { getIsAppReady } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
 
-export default defineEventHandler(async () => {
+export default defineEventHandler(() => {
   try {
-    const isReady = await getIsAppReady();
+    const isReady = getIsAppReady();
     console.log(`IS_APP_READY is ${isReady}`);
     return { statusCode: 200, isReady };
   } catch (error) {
     console.log(error);
-    const err = error as { statusCode?: number; statusMessage?: string; message?: string };
     throw createError({
-      statusCode: err.statusCode,
-      statusMessage: err.statusMessage ?? err.message,
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/microservice/app/set_app_base_url.post.ts

@@ -1,5 +1,5 @@
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import { setAppBaseUrl } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
@@ -8,23 +8,22 @@ interface SetAppBaseUrlBody {
   baseUrl: string;
 }
 
-export default defineEventHandler(async (event) => {
+export default defineEventHandler(async (event: H3Event) => {
   try {
     const { baseUrl } = await readBody<SetAppBaseUrlBody>(event);
     if (!baseUrl) {
       throw createError({ statusCode: 400, statusMessage: "baseUrl is required" });
     }
 
-    await setAppBaseUrl(baseUrl);
+    setAppBaseUrl(baseUrl);
     console.log(`Updated APP_BASE_URL to ${baseUrl}`);
 
     return { statusCode: 200, baseUrl };
   } catch (error) {
     console.log(error);
-    const err = error as { statusCode?: number; statusMessage?: string; message?: string };
     throw createError({
-      statusCode: err.statusCode,
-      statusMessage: err.statusMessage ?? err.message,
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/microservice/app/set_back_base_url.post.ts

@@ -1,5 +1,5 @@
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import { setBackBaseUrl } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
@@ -8,20 +8,19 @@ interface SetBackBaseUrlBody {
   baseUrl: string;
 }
 
-export default defineEventHandler(async (event) => {
+export default defineEventHandler(async (event: H3Event) => {
   try {
     const { baseUrl } = await readBody<SetBackBaseUrlBody>(event);
     if (!baseUrl) {
       throw createError({ statusCode: 400, statusMessage: "baseUrl is required" });
     }
-    await setBackBaseUrl(baseUrl);
+    setBackBaseUrl(baseUrl);
     return { statusCode: 200, baseUrl };
   } catch (error) {
     console.log(error);
-    const err = error as { statusCode?: number; message?: string };
     throw createError({
-      statusCode: err.statusCode,
-      statusMessage: err.message,
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/microservice/app/set_is_app_ready.post.ts

@@ -1,5 +1,5 @@
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import { setIsAppReady } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
@@ -8,23 +8,22 @@ interface SetIsAppReadyBody {
   isReady: boolean;
 }
 
-export default defineEventHandler(async (event) => {
+export default defineEventHandler(async (event: H3Event) => {
   try {
     const { isReady } = await readBody<SetIsAppReadyBody>(event);
     if (!isReady) {
       throw createError({ statusCode: 400, statusMessage: "isReady is required" });
     }
 
-    await setIsAppReady(isReady);
+    setIsAppReady(isReady);
     console.log(`Updated IS_APP_READY to ${isReady}`);
 
     return { statusCode: 200, isReady };
   } catch (error) {
     console.log(error);
-    const err = error as { statusCode?: number; statusMessage?: string; message?: string };
     throw createError({
-      statusCode: err.statusCode,
-      statusMessage: err.statusMessage ?? err.message,
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/microservice/app/set_viewer_base_url.post.ts

@@ -1,5 +1,5 @@
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import { setViewerBaseUrl } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
@@ -8,20 +8,19 @@ interface SetViewerBaseUrlBody {
   baseUrl: string;
 }
 
-export default defineEventHandler(async (event) => {
+export default defineEventHandler(async (event: H3Event) => {
   try {
     const { baseUrl } = await readBody<SetViewerBaseUrlBody>(event);
     if (!baseUrl) {
       throw createError({ statusCode: 400, statusMessage: "baseUrl is required" });
     }
-    await setViewerBaseUrl(baseUrl);
+    setViewerBaseUrl(baseUrl);
     return { statusCode: 200, baseUrl };
   } catch (error) {
     console.log(error);
-    const err = error as { statusCode?: number; message?: string };
     throw createError({
-      statusCode: err.statusCode,
-      statusMessage: err.message,
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/microservice/extensions/download.post.ts

@@ -2,7 +2,7 @@
 import { promises as fs } from "node:fs";
 
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import {
@@ -16,12 +16,13 @@ interface DownloadExtensionBody {
   extensionFileName: string;
 }
 
-export default defineEventHandler(async (event) => {
+export default defineEventHandler(async (event: H3Event) => {
   try {
     const body = await readBody<DownloadExtensionBody>(event);
     const { projectName, url, extensionFileName } = body;
     console.log({ projectName, url, extensionFileName });
-    const fileBuffer = await fetch(url).then((file) => file.arrayBuffer());
+    const response: Response = await fetch(url);
+    const fileBuffer = await response.arrayBuffer();
     const filePath = targetExtensionFilePath(projectName, extensionFileName);
     await fs.writeFile(filePath, Buffer.from(fileBuffer));
     await registerExtensionFile(projectName, filePath);
@@ -32,7 +33,7 @@ export default defineEventHandler(async (event) => {
     console.error("Error downloading extension:", error);
     throw createError({
       statusCode: 500,
-      statusMessage: (error as Error).message,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/serverless/run_cloud.post.ts

@@ -1,8 +1,8 @@
 // Node imports
 
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
-import { GoogleAuth } from "google-auth-library";
+import { GoogleAuth, type JWTInput } from "google-auth-library";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 import { ServicesClient } from "@google-cloud/run";
 
 // Local imports
@@ -12,17 +12,52 @@ interface RunCloudBody {
   email: string;
 }
 
-export default defineEventHandler(async (event) => {
+function isServiceAccountCredentials(value: unknown): value is JWTInput {
+  return (
+    typeof value === "object" && value !== null && "client_email" in value && "private_key" in value
+  );
+}
+
+export default defineEventHandler(async (event: H3Event) => {
   try {
     const { email } = await readBody<RunCloudBody>(event);
     console.log("[RUN CLOUD] Received request to create backend for email:", email);
-    const credentials = JSON.parse(process.env.GOOGLE_CLOUD_KEY as string);
+
+    const { GOOGLE_CLOUD_KEY, GOOGLE_CLOUD_PROJECT, PROJECT } = process.env;
+
+    if (
+      GOOGLE_CLOUD_KEY === undefined ||
+      GOOGLE_CLOUD_KEY === "" ||
+      GOOGLE_CLOUD_PROJECT === undefined ||
+      GOOGLE_CLOUD_PROJECT === "" ||
+      PROJECT === undefined ||
+      PROJECT === ""
+    ) {
+      throw createError({
+        statusCode: 500,
+        statusMessage:
+          "Missing required environment variables: GOOGLE_CLOUD_KEY, GOOGLE_CLOUD_PROJECT, or PROJECT",
+      });
+    }
+
+    const projectId: string = GOOGLE_CLOUD_PROJECT;
+    const projectName: string = PROJECT;
+
+    const parsedKey: unknown = JSON.parse(GOOGLE_CLOUD_KEY);
+    if (!isServiceAccountCredentials(parsedKey)) {
+      throw createError({
+        statusCode: 500,
+        statusMessage: "GOOGLE_CLOUD_KEY is not a valid service account credentials JSON",
+      });
+    }
+    const credentials: JWTInput = parsedKey;
+
     const location = "europe-west9";
-    const projectId = process.env.GOOGLE_CLOUD_PROJECT;
-    const projectName = process.env.PROJECT as string;
     const parent = `projects/${projectId}/locations/${location}`;
     console.log({ parent });
+
     const auth = new GoogleAuth({
+      // oxlint-disable-next-line typescript/no-deprecated
       credentials,
       scopes: ["https://www.googleapis.com/auth/cloud-platform"],
     });
@@ -30,21 +65,28 @@ export default defineEventHandler(async (event) => {
     const image = await artifactImage(parent, authClient);
     const request = requestConfig(parent, image, email, projectName);
     console.log({ request });
-    // @google-cloud/run bundles its own copy of google-auth-library's auth-client types,
-    // Which isn't nominally assignable to the AuthClient from our direct dependency.
-    const runClient = new ServicesClient({ authClient: authClient as never });
+
+    const runClient = new ServicesClient({ authClient });
     const [operation] = await runClient.createService(request);
     const [response] = await operation.promise();
+
+    if (response.uri === null || response.uri === undefined || response.uri === "") {
+      throw createError({
+        statusCode: 500,
+        statusMessage: "Cloud Run service created but no URI was returned",
+      });
+    }
+
     console.log("Service URL created:", response.uri);
     return {
       statusCode: 200,
-      url: (response.uri as string).replace(/^https?:\/\//iu, ""),
+      url: response.uri.replace(/^https?:\/\//iu, ""),
     };
   } catch (error) {
     console.log(error);
     throw createError({
       statusCode: 500,
-      statusMessage: (error as Error).message,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/utils/app_config.ts

@@ -1,6 +1,6 @@
 // Node.js imports
 import path from "node:path";
-import { unlink } from "node:fs";
+import { unlink } from "node:fs/promises";
 
 // Third party imports
 import Conf from "conf";
@@ -13,7 +13,7 @@ interface ExtensionsConfigSchema {
   extensions: Record<string, { path: string }>;
 }
 
-function projectConf(projectName: string) {
+function projectConf(projectName: string): Conf<ExtensionsConfigSchema> {
   const projectConfig = new Conf<ExtensionsConfigSchema>({
     projectName,
   });
@@ -22,45 +22,42 @@ function projectConf(projectName: string) {
   });
   return projectConfig;
 }
-function confFolderPath(projectName: string) {
+
+function confFolderPath(projectName: string): string {
   const projectConfig = projectConf(projectName);
   return path.dirname(projectConfig.path);
 }
-function targetExtensionFilePath(projectName: string, filename: string) {
+
+function targetExtensionFilePath(projectName: string, filename: string): string {
   const safeFilename = sanitize(filename);
   const targetPath = path.join(confFolderPath(projectName), safeFilename);
   return targetPath;
 }
-function extensionsConf(projectName: string) {
+
+function extensionsConf(projectName: string): ExtensionsConfigSchema["extensions"] {
   const projectConfig = projectConf(projectName);
-  if (!projectConfig.has("extensions")) {
-    projectConfig.set("extensions", {});
-  }
-  const extensionsConfig = projectConfig.get("extensions");
-  return extensionsConfig;
+  // Read-only: concurrent app instances share this file and racing writes fail on Windows (EPERM)
+  return projectConfig.get("extensions", {});
 }
+
 function addExtensionToConf(
   projectName: string,
   { extensionId, extensionPath }: { extensionId: string; extensionPath: string },
-) {
+): void {
   const projectConfig = projectConf(projectName);
   projectConfig.set(`extensions.${extensionId}.path`, extensionPath);
 }
 
 function extensionPathFromConf(projectName: string, extensionId: string): string {
   const projectConfig = projectConf(projectName);
-  return projectConfig.get(`extensions.${extensionId}.path`) as string;
+  return projectConfig.get(`extensions.${extensionId}.path`);
 }
 
-async function removeExtensionFromConf(projectName: string, extensionId: string) {
+async function removeExtensionFromConf(projectName: string, extensionId: string): Promise<void> {
   const projectConfig = projectConf(projectName);
   const extensionArchivePath = extensionPathFromConf(projectName, extensionId);
-  await unlink(extensionArchivePath, (error) => {
-    if (error) {
-      throw error;
-    }
-    console.log(`${extensionArchivePath} was deleted`);
-  });
+  await unlink(extensionArchivePath);
+  console.log(`${extensionArchivePath} was deleted`);
   projectConfig.delete(`extensions.${extensionId}`);
   console.log(`${extensionId} was deleted from ${projectName} config`);
 }
@@ -70,20 +67,30 @@ interface ExtensionMetadata {
   [key: string]: unknown;
 }
 
-async function registerExtensionFile(projectName: string, file: string) {
+function isExtensionMetadata(value: unknown): value is ExtensionMetadata {
+  return (
+    typeof value === "object" && value !== null && "id" in value && typeof value.id === "string"
+  );
+}
+
+async function registerExtensionFile(projectName: string, file: string): Promise<void> {
   const StreamZipAsync = StreamZip.async;
   const zip = new StreamZipAsync({
     file,
     storeEntries: true,
   });
   const metadataJson = await zip.entryData("metadata.json");
-  const metadata = JSON.parse(metadataJson.toString("utf8")) as ExtensionMetadata;
-  const { id } = metadata;
+  const parsedMetadata: unknown = JSON.parse(metadataJson.toString("utf8"));
+  if (!isExtensionMetadata(parsedMetadata)) {
+    throw new TypeError("metadata.json does not match the expected ExtensionMetadata shape");
+  }
+  const { id } = parsedMetadata;
   addExtensionToConf(projectName, {
     extensionId: id,
     extensionPath: file,
   });
 }
+
 export {
   addExtensionToConf,
   confFolderPath,

package/server/utils/cleanup.ts

@@ -1,4 +1,3 @@
-/// <reference path="../types/vendor.d.ts" />
 // Node imports
 import fs from "node:fs";
 import path from "node:path";
@@ -18,6 +17,7 @@ interface Microservice {
 }
 
 const MAX_DELETE_FOLDER_RETRIES = 5;
+
 async function deleteFolderRecursive(folderPath: string): Promise<void> {
   if (!fs.existsSync(folderPath)) {
     console.log(`Folder ${folderPath} does not exist.`);
@@ -32,7 +32,6 @@ async function deleteFolderRecursive(folderPath: string): Promise<void> {
       return;
     } catch (error) {
       console.error(`Error deleting folder ${folderPath}:`, error);
-      // Wait before retrying
       const MILLISECONDS_PER_RETRY = 1000;
       const DELAY = MILLISECONDS_PER_RETRY * (i + 1);
       // oxlint-disable-next-line no-await-in-loop
@@ -44,35 +43,54 @@ async function deleteFolderRecursive(folderPath: string): Promise<void> {
     `Failed to delete folder ${folderPath} after ${MAX_DELETE_FOLDER_RETRIES} retries`,
   );
 }
-function killHttpMicroservice(microservice: Microservice): Promise<void> {
+
+function isErrorWithMessage(error: unknown): error is { message: string } {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "message" in error &&
+    typeof error.message === "string"
+  );
+}
+
+async function killHttpMicroservice(microservice: Microservice): Promise<void> {
   console.log("killHttpMicroservice", {
     ...microservice,
   });
   const failMessage = `Failed to kill ${microservice.name}`;
-  async function do_kill() {
+  async function do_kill(): Promise<void> {
+    if (microservice.url === undefined) {
+      return;
+    }
     try {
-      await fetch(microservice.url as string, {
+      await fetch(microservice.url, {
         method: microservice.method,
       });
     } catch (error) {
-      console.log(`Expected error during kill of ${microservice.name}:`, (error as Error).message);
+      const message = isErrorWithMessage(error) ? error.message : String(error);
+      console.log(`Expected error during kill of ${microservice.name}:`, message);
     }
   }
-  return pTimeout(do_kill(), {
+  await pTimeout(do_kill(), {
     milliseconds: 5000,
     message: failMessage,
   });
 }
-function killWebsocketMicroservice(microservice: Microservice): Promise<void> {
+
+async function killWebsocketMicroservice(microservice: Microservice): Promise<void> {
   console.log("killWebsocketMicroservice", {
     ...microservice,
   });
   const failMessage = `Failed to kill ${microservice.name}`;
   const successMessage = `Disconnected from ${microservice.name} WebSocket server`;
-  function do_kill() {
+  async function do_kill(): Promise<void> {
+    if (microservice.url === undefined) {
+      return;
+    }
+    const socketUrl = microservice.url;
     // oxlint-disable-next-line promise/avoid-new
-    return new Promise<void>((resolve) => {
-      const socket = new WebSocket(microservice.url as string);
+    await new Promise<void>((resolve) => {
+      const socket = new WebSocket(socketUrl);
       socket.on("open", () => {
         console.log("Connected to WebSocket server");
         socket.send(
@@ -87,7 +105,7 @@ function killWebsocketMicroservice(microservice: Microservice): Promise<void> {
           }),
         );
       });
-      socket.on("message", (data) => {
+      socket.on("message", (data: Buffer | string) => {
         const message = data.toString();
         console.log("Received from server:", message);
         if (message.includes("hello")) {
@@ -106,46 +124,54 @@ function killWebsocketMicroservice(microservice: Microservice): Promise<void> {
         console.log(successMessage);
         resolve();
       });
-      socket.on("error", (error) => {
+      socket.on("error", (error: Error) => {
         console.error("WebSocket error:", error);
         socket.close();
         resolve();
       });
     });
   }
-  return pTimeout(do_kill(), {
+  await pTimeout(do_kill(), {
     milliseconds: 5000,
     message: failMessage,
   });
 }
+
 async function killMicroservice(microservice: Microservice): Promise<void> {
   if (microservice.type === "back") {
     await killHttpMicroservice(microservice);
   } else if (microservice.type === "viewer") {
     await killWebsocketMicroservice(microservice);
   } else {
-    throw new Error(`Unknown microservice type: ${microservice.type}`);
+    const exhaustiveCheck: never = microservice.type;
+    throw new Error(`Unknown microservice type: ${String(exhaustiveCheck)}`);
   }
 }
-async function killMicroservices(microservices: Microservice[]): Promise<void> {
+
+async function killMicroservices(microservices: readonly Microservice[]): Promise<Microservice[]> {
   console.log("killMicroservices", {
     microservices,
   });
   const results = await Promise.allSettled(
-    microservices.map((microservice) => killMicroservice(microservice)),
+    microservices.map(async (microservice) => {
+      await killMicroservice(microservice);
+    }),
   );
-  const killed = microservices.filter((_, index) => results[index]?.status === "fulfilled");
-  for (let i = 0; i < killed.length; i += 1) {
-    const microservice = microservices[i];
-    if (microservice) {
-      microservices.splice(microservices.indexOf(microservice), 1);
-    }
-  }
+  return microservices.filter((_, index) => results[index]?.status !== "fulfilled");
 }
+
 function microservicesMetadatasPath(projectFolderPath: string): string {
   return path.join(projectFolderPath, "microservices.json");
 }
 
+function isMicroservicesMetadatas(value: unknown): value is { microservices: Microservice[] } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    Array.isArray((value as { microservices?: unknown }).microservices)
+  );
+}
+
 function projectMicroservices(projectFolderPath: string): Microservice[] {
   console.log("projectMicroservices", {
     projectFolderPath,
@@ -157,11 +183,13 @@ function projectMicroservices(projectFolderPath: string): Microservice[] {
     };
     fs.writeFileSync(filePath, JSON.stringify(microservicesMetadatas, undefined, 2), "utf8");
   }
-  const content = JSON.parse(fs.readFileSync(filePath, "utf8")) as {
-    microservices: Microservice[];
-  };
-  return content.microservices;
+  const parsed: unknown = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  if (!isMicroservicesMetadatas(parsed)) {
+    throw new Error(`Invalid microservices metadata file: ${filePath}`);
+  }
+  return parsed.microservices;
 }
+
 async function cleanupBackend(projectFolderPath: string): Promise<void> {
   if (!fs.existsSync(projectFolderPath)) {
     console.log(`Folder ${projectFolderPath} does not exist. Skipping cleanup.`);
@@ -171,11 +199,13 @@ async function cleanupBackend(projectFolderPath: string): Promise<void> {
   await killMicroservices(microservices);
   await deleteFolderRecursive(projectFolderPath);
 }
+
 function getMicroserviceByName(
-  microservices: Microservice[],
+  microservices: readonly Microservice[],
   name: string,
 ): Microservice | undefined {
-  return microservices.find((microservice) => microservice.name === name);
+  const found = microservices.find((microservice) => microservice.name === name);
+  return found === undefined ? undefined : { ...found };
 }
 
 export {

package/server/utils/cloud.ts

@@ -4,25 +4,23 @@ import fs from "node:fs";
 import path from "node:path";
 
 // Third party imports
+import type { AuthClient, OAuth2Client } from "google-auth-library";
 import { google } from "googleapis";
 import type { protos } from "@google-cloud/run";
 
 // Local imports
 
-// The googleapis package's per-API-version `auth` option types don't line up with the concrete client returned by `GoogleAuth.getClient()` (they're structurally close but not nominally assignable). `any` matches how googleapis treats it at runtime (duck typed).
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type GoogleAuthClient = any;
-// `v2` is a namespace segment in the `@google-cloud/run` package's own generated protobuf types, not a name this codebase declares.
 // oxlint-disable-next-line eslint/id-length
 type CreateServiceRequest = protos.google.cloud.run.v2.ICreateServiceRequest;
 
 const LOCATIONS_DIR = "/etc/nginx/locations";
 
-async function artifactImage(parent: string, authClient: GoogleAuthClient): Promise<string> {
+async function artifactImage(parent: string, authClient: AuthClient): Promise<string> {
   const projectName = process.env.PROJECT;
   const registry = google.artifactregistry({
     version: "v1",
-    auth: authClient,
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+    auth: authClient as OAuth2Client,
   });
   const branch = process.env.NETLIFY_BRANCH;
   const [, projectId] = parent.split("/");
@@ -86,7 +84,6 @@ function requestConfig(
             image,
             ports: [
               {
-                name: "h2c",
                 containerPort: 80,
               },
             ],
@@ -112,7 +109,11 @@ function requestConfig(
   };
 }
 
-function addSupervisorProgram(name: string, command: string, executableArgs: string[]): void {
+function addSupervisorProgram(
+  name: string,
+  command: string,
+  executableArgs: readonly string[],
+): void {
   const conf = `
 [program:${name}]
 command=${command} ${executableArgs.join(" ")}