@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/server/api/microservice/extensions/{download.post.js → download.post.ts}

@@ -2,20 +2,27 @@
 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 {
   registerExtensionFile,
   targetExtensionFilePath,
-} from "@geode/opengeodeweb-front/server/utils/app_config.js";
+} from "@geode/opengeodeweb-front/server/utils/app_config.ts";
 
-export default defineEventHandler(async (event) => {
+interface DownloadExtensionBody {
+  projectName: string;
+  url: string;
+  extensionFileName: string;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
   try {
-    const body = await readBody(event);
+    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);
@@ -26,7 +33,7 @@ export default defineEventHandler(async (event) => {
     console.error("Error downloading extension:", error);
     throw createError({
       statusCode: 500,
-      statusMessage: error.message,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

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

@@ -0,0 +1,92 @@
+// Node imports
+
+// Third party imports
+import { GoogleAuth, type JWTInput } from "google-auth-library";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
+import { ServicesClient } from "@google-cloud/run";
+
+// Local imports
+import { artifactImage, requestConfig } from "@geode/opengeodeweb-front/server/utils/cloud.ts";
+
+interface RunCloudBody {
+  email: string;
+}
+
+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 { 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 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"],
+    });
+    const authClient = await auth.getClient();
+    const image = await artifactImage(parent, authClient);
+    const request = requestConfig(parent, image, email, projectName);
+    console.log({ request });
+
+    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.replace(/^https?:\/\//iu, ""),
+    };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
+    });
+  }
+});

package/server/utils/{app_config.js → 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";
@@ -9,8 +9,12 @@ import sanitize from "sanitize-filename";
 
 // Local imports
 
-function projectConf(projectName) {
-  const projectConfig = new Conf({
+interface ExtensionsConfigSchema {
+  extensions: Record<string, { path: string }>;
+}
+
+function projectConf(projectName: string): Conf<ExtensionsConfigSchema> {
+  const projectConfig = new Conf<ExtensionsConfigSchema>({
     projectName,
   });
   console.log(projectConf.name, {
@@ -18,16 +22,19 @@ function projectConf(projectName) {
   });
   return projectConfig;
 }
-function confFolderPath(projectName) {
+
+function confFolderPath(projectName: string): string {
   const projectConfig = projectConf(projectName);
   return path.dirname(projectConfig.path);
 }
-function targetExtensionFilePath(projectName, filename) {
+
+function targetExtensionFilePath(projectName: string, filename: string): string {
   const safeFilename = sanitize(filename);
   const targetPath = path.join(confFolderPath(projectName), safeFilename);
   return targetPath;
 }
-function extensionsConf(projectName) {
+
+function extensionsConf(projectName: string): ExtensionsConfigSchema["extensions"] {
   const projectConfig = projectConf(projectName);
   if (!projectConfig.has("extensions")) {
     projectConfig.set("extensions", {});
@@ -35,43 +42,58 @@ function extensionsConf(projectName) {
   const extensionsConfig = projectConfig.get("extensions");
   return extensionsConfig;
 }
-function addExtensionToConf(projectName, { extensionId, extensionPath }) {
+
+function addExtensionToConf(
+  projectName: string,
+  { extensionId, extensionPath }: { extensionId: string; extensionPath: string },
+): void {
   const projectConfig = projectConf(projectName);
   projectConfig.set(`extensions.${extensionId}.path`, extensionPath);
 }
 
-function extensionPathFromConf(projectName, extensionId) {
+function extensionPathFromConf(projectName: string, extensionId: string): string {
   const projectConfig = projectConf(projectName);
   return projectConfig.get(`extensions.${extensionId}.path`);
 }
 
-async function removeExtensionFromConf(projectName, extensionId) {
+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`);
 }
 
-async function registerExtensionFile(projectName, file) {
+interface ExtensionMetadata {
+  id: string;
+  [key: string]: unknown;
+}
+
+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);
-  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.js → cleanup.ts}

@@ -8,8 +8,17 @@ import { WebSocket } from "ws";
 import pTimeout from "p-timeout";
 import { rimraf } from "rimraf";
 
+interface Microservice {
+  type: "back" | "viewer";
+  name: string;
+  port: number;
+  url?: string;
+  method?: string;
+}
+
 const MAX_DELETE_FOLDER_RETRIES = 5;
-async function deleteFolderRecursive(folderPath) {
+
+async function deleteFolderRecursive(folderPath: string): Promise<void> {
   if (!fs.existsSync(folderPath)) {
     console.log(`Folder ${folderPath} does not exist.`);
     return;
@@ -23,7 +32,6 @@ async function deleteFolderRecursive(folderPath) {
       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
@@ -35,35 +43,54 @@ async function deleteFolderRecursive(folderPath) {
     `Failed to delete folder ${folderPath} after ${MAX_DELETE_FOLDER_RETRIES} retries`,
   );
 }
-function killHttpMicroservice(microservice) {
+
+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, {
         method: microservice.method,
       });
     } catch (error) {
-      console.log(`Expected error during kill of ${microservice.name}:`, 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) {
+
+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((resolve) => {
-      const socket = new WebSocket(microservice.url);
+    await new Promise<void>((resolve) => {
+      const socket = new WebSocket(socketUrl);
       socket.on("open", () => {
         console.log("Connected to WebSocket server");
         socket.send(
@@ -78,7 +105,7 @@ function killWebsocketMicroservice(microservice) {
           }),
         );
       });
-      socket.on("message", (data) => {
+      socket.on("message", (data: Buffer | string) => {
         const message = data.toString();
         console.log("Received from server:", message);
         if (message.includes("hello")) {
@@ -97,45 +124,55 @@ function killWebsocketMicroservice(microservice) {
         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) {
+
+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) {
+
+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];
-    microservices.splice(microservices.indexOf(microservice), 1);
-  }
+  return microservices.filter((_, index) => results[index]?.status !== "fulfilled");
 }
-function microservicesMetadatasPath(projectFolderPath) {
+
+function microservicesMetadatasPath(projectFolderPath: string): string {
   return path.join(projectFolderPath, "microservices.json");
 }
 
-function projectMicroservices(projectFolderPath) {
+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,
   });
@@ -146,10 +183,14 @@ function projectMicroservices(projectFolderPath) {
     };
     fs.writeFileSync(filePath, JSON.stringify(microservicesMetadatas, undefined, 2), "utf8");
   }
-  const content = JSON.parse(fs.readFileSync(filePath, "utf8"));
-  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) {
+
+async function cleanupBackend(projectFolderPath: string): Promise<void> {
   if (!fs.existsSync(projectFolderPath)) {
     console.log(`Folder ${projectFolderPath} does not exist. Skipping cleanup.`);
     return;
@@ -158,8 +199,13 @@ async function cleanupBackend(projectFolderPath) {
   await killMicroservices(microservices);
   await deleteFolderRecursive(projectFolderPath);
 }
-function getMicroserviceByName(microservices, name) {
-  return microservices.find((microservice) => microservice.name === name);
+
+function getMicroserviceByName(
+  microservices: readonly Microservice[],
+  name: string,
+): Microservice | undefined {
+  const found = microservices.find((microservice) => microservice.name === name);
+  return found === undefined ? undefined : { ...found };
 }
 
 export {
@@ -170,3 +216,4 @@ export {
   projectMicroservices,
   getMicroserviceByName,
 };
+export type { Microservice };

package/server/utils/{cloud.js → cloud.ts}

@@ -4,20 +4,26 @@ 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
 
+// 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, authClient) {
+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("/");
+  const [, projectId] = parent.split("/");
   const repository = `${parent}/repositories/github/packages/`;
   const name = `${repository}${projectName}/tags/${branch}`;
   console.log({ name });
@@ -25,14 +31,15 @@ async function artifactImage(parent, authClient) {
     name,
   });
   console.log({ response });
-  const digest = response.data.version.split("/").pop();
+  const version = response.data.version ?? "";
+  const digest = version.split("/").pop();
   const artifactRegistry = `europe-west9-docker.pkg.dev/${projectId}/github`;
   const image = `${artifactRegistry}/${projectName}@${digest}`;
   console.log("Found image for", projectName, image);
   return image;
 }
 
-function sanitizeLabelValue(label) {
+function sanitizeLabelValue(label: string): string {
   console.log("label", label);
   const maxLabelLength = 63;
   return label
@@ -41,14 +48,19 @@ function sanitizeLabelValue(label) {
     .slice(0, maxLabelLength);
 }
 
-function requestConfig(parent, image, email, projectName) {
+function requestConfig(
+  parent: string,
+  image: string,
+  email: string,
+  projectName: string,
+): CreateServiceRequest {
   const resources = {
     limits: {
       cpu: "2000m",
       memory: "3Gi",
     },
     cpuIdle: false,
-    startup_cpu_boost: true,
+    startupCpuBoost: true,
   };
   const labels = {
     user: sanitizeLabelValue(email),
@@ -97,7 +109,11 @@ function requestConfig(parent, image, email, projectName) {
   };
 }
 
-function addSupervisorProgram(name, command, executableArgs) {
+function addSupervisorProgram(
+  name: string,
+  command: string,
+  executableArgs: readonly string[],
+): void {
   const conf = `
 [program:${name}]
 command=${command} ${executableArgs.join(" ")}
@@ -116,7 +132,7 @@ stderr_logfile_maxbytes=0
   console.log("addSupervisorProgram", stdout);
 }
 
-function buildLocationBlock(routePath, port) {
+function buildLocationBlock(routePath: string, port: number): string {
   if (!routePath.startsWith("/") || !routePath.endsWith("/")) {
     throw new Error(`routePath must start and end with '/', got: ${routePath}`);
   }
@@ -139,16 +155,16 @@ location ~ "^${routePath}" {
     add_header 'Content-Length'                   0;
     return 204;
   }
- 
+
   limit_except ${limitMethods} { deny all; }
- 
+
   add_header 'Access-Control-Allow-Origin'      $allow_origin always;
   add_header 'Access-Control-Allow-Credentials' 'true' always;
   add_header 'Access-Control-Allow-Methods'     '${methods}' always;
   add_header 'Access-Control-Allow-Headers'     'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,X-CSRF-Token' always;
   add_header 'Access-Control-Expose-Headers'    'Content-Length,Content-Range' always;
   add_header 'Vary'                             'Origin' always;
- 
+
   rewrite "^${routePath}(.*)" /$1 break;
   proxy_pass http://localhost:${port};
   proxy_http_version 1.1;
@@ -160,16 +176,16 @@ location ~ "^${routePath}" {
 `;
 }
 
-function nginxConfigFile(name) {
+function nginxConfigFile(name: string): string {
   return path.join(LOCATIONS_DIR, `${name}.conf`);
 }
 
-function nginxReload() {
+function nginxReload(): void {
   execFileSync("nginx", ["-t"]);
   execFileSync("nginx", ["-s", "reload"]);
 }
 
-function addNginxLocation(name, port) {
+function addNginxLocation(name: string, port: number): string {
   fs.mkdirSync(LOCATIONS_DIR, { recursive: true });
   const filePath = nginxConfigFile(name);
   if (fs.existsSync(filePath)) {
@@ -185,8 +201,8 @@ function addNginxLocation(name, port) {
   return filePath;
 }
 
-function removeNginxLocation(name) {
-  const filePath = filePathFor(name);
+function removeNginxLocation(name: string): boolean {
+  const filePath = nginxConfigFile(name);
   if (!fs.existsSync(filePath)) {
     return false;
   }

package/server/utils/{extension.js → extension.ts}

@@ -1,14 +1,27 @@
 // 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";
 
 // Local imports
-import { extensionFrontendPath } from "@geode/opengeodeweb-front/server/utils/path.js";
+import { extensionFrontendPath } from "@geode/opengeodeweb-front/server/utils/path.ts";
 
-async function readExtensionMetadata(unzippedExtensionPath) {
+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");
   const metadataContent = await fs.readFile(metadataPath, "utf8");
   if (!metadataContent) {
@@ -17,7 +30,17 @@ async function readExtensionMetadata(unzippedExtensionPath) {
       statusMessage: "Invalid extension file: missing metadata.json",
     });
   }
-  const metadata = JSON.parse(metadataContent);
+
+  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({
@@ -35,7 +58,11 @@ async function readExtensionMetadata(unzippedExtensionPath) {
   return metadata;
 }
 
-async function readExtensionFrontend(unzippedExtensionPath, frontendFile, id) {
+async function readExtensionFrontend(
+  unzippedExtensionPath: string,
+  frontendFile: string,
+  id: string,
+): Promise<string> {
   console.log("readExtensionFrontend", { id });
   const frontendFilePath = await extensionFrontendPath(
     unzippedExtensionPath,