@geode/opengeodeweb-front 10.5.1 → 10.6.0

package/app/utils/local/microservices.js

@@ -0,0 +1,259 @@
+// Node imports
+import child_process from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+
+// Third party imports
+import { WebSocket } from "ws"
+import { getPort } from "get-port-please"
+import pTimeout from "p-timeout"
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" }
+
+// Local imports
+import {
+  deleteFolderRecursive,
+  executablePath,
+  executableName,
+} from "./path.js"
+import { commandExistsSync, waitForReady } from "./scripts.js"
+
+const DEFAULT_TIMEOUT_SECONDS = 30
+const MILLISECONDS_PER_SECOND = 1000
+
+function getAvailablePort() {
+  return getPort({
+    host: "localhost",
+    random: true,
+  })
+}
+
+async function runScript(
+  execName,
+  execPath,
+  args,
+  expectedResponse,
+  timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
+) {
+  const command = commandExistsSync(execName)
+    ? execName
+    : path.join(await executablePath(execPath), executableName(execName))
+  console.log("runScript", command, args)
+  const child = child_process.spawn(command, args, {
+    encoding: "utf8",
+    shell: true,
+  })
+
+  child.stdout.on("data", (data) =>
+    console.log(`[${execName}] ${data.toString()}`),
+  )
+  child.stderr.on("data", (data) =>
+    console.log(`[${execName}] ${data.toString()}`),
+  )
+
+  child.on("error", async (error) => {
+    const electron = await import("electron")
+    electron.dialog.showMessageBox({
+      title: "Title",
+      type: "warning",
+      message: `Error occured.\r\n${error}`,
+    })
+  })
+
+  child.on("close", (code) =>
+    console.log(`[${execName}] exited with code ${code}`),
+  )
+  child.on("kill", () => {
+    console.log(`[${execName}] process killed`)
+  })
+  child.name = command.replace(/^.*[\\/]/, "")
+
+  try {
+    return await pTimeout(waitForReady(child, expectedResponse), {
+      milliseconds: timeoutSeconds * MILLISECONDS_PER_SECOND,
+      message: `Timed out after ${timeoutSeconds} seconds`,
+    })
+  } catch (error) {
+    child.kill()
+    throw error
+  }
+}
+
+async function runBack(execName, execPath, args = {}) {
+  const { projectFolderPath } = args
+  if (!projectFolderPath) {
+    throw new Error("projectFolderPath is required")
+  }
+  let { uploadFolderPath } = args
+  if (!uploadFolderPath) {
+    uploadFolderPath = path.join(projectFolderPath, "uploads")
+  }
+  const port = await getAvailablePort()
+  const backArgs = [
+    `--port ${port}`,
+    `--data_folder_path ${projectFolderPath}`,
+    `--upload_folder_path ${uploadFolderPath}`,
+    `--allowed_origin http://localhost:*`,
+    `--timeout ${0}`,
+  ]
+  if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
+    backArgs.push("--debug")
+  }
+  console.log("runBack", execName, execPath, backArgs)
+  await runScript(execName, execPath, backArgs, "Serving Flask app")
+  return port
+}
+
+async function runViewer(execName, execPath, args = {}) {
+  const { projectFolderPath } = args
+  if (!projectFolderPath) {
+    throw new Error("projectFolderPath is required")
+  }
+  const port = await getAvailablePort()
+  const viewerArgs = [
+    `--port ${port}`,
+    `--data_folder_path ${projectFolderPath}`,
+    `--timeout ${0}`,
+  ]
+  console.log("runViewer", execName, execPath, viewerArgs)
+  await runScript(execName, execPath, viewerArgs, "Starting factory")
+  return port
+}
+
+function killHttpMicroservice(microservice) {
+  console.log("killHttpMicroservice", { ...microservice })
+  const failMessage = `Failed to kill ${microservice.name}`
+  async function do_kill() {
+    try {
+      await fetch(microservice.url, {
+        method: microservice.method,
+      })
+      throw new Error(failMessage)
+    } catch (error) {
+      console.log(`${microservice.name} closed`, error)
+    }
+  }
+  return pTimeout(do_kill(), {
+    milliseconds: 5000,
+    message: failMessage,
+  })
+}
+
+function killWebsocketMicroservice(microservice) {
+  console.log("killWebsocketMicroservice", { ...microservice })
+  const failMessage = `Failed to kill ${microservice.name}`
+  const successMessage = `Disconnected from ${microservice.name} WebSocket server`
+  function do_kill() {
+    return new Promise((resolve) => {
+      const socket = new WebSocket(microservice.url)
+      socket.on("open", () => {
+        console.log("Connected to WebSocket server")
+        socket.send(
+          JSON.stringify({
+            id: "system:hello",
+            method: "wslink.hello",
+            args: [{ secret: "wslink-secret" }],
+          }),
+        )
+      })
+      socket.on("message", (data) => {
+        const message = data.toString()
+        console.log("Received from server:", message)
+        if (message.includes("hello")) {
+          socket.send(
+            JSON.stringify({
+              id: "application.exit",
+              method: "application.exit",
+            }),
+          )
+          console.log(successMessage)
+          socket.close()
+          resolve()
+        }
+      })
+      socket.on("close", () => {
+        console.log(successMessage)
+        resolve()
+      })
+      socket.on("error", (error) => {
+        console.error("WebSocket error:", error)
+        socket.close()
+        resolve()
+      })
+    })
+  }
+  return pTimeout(do_kill(), {
+    milliseconds: 5000,
+    message: failMessage,
+  })
+}
+
+function killMicroservice(microservice) {
+  if (microservice.type === "back") {
+    return killHttpMicroservice(microservice)
+  } else if (microservice.type === "viewer") {
+    return killWebsocketMicroservice(microservice)
+  } else {
+    throw new Error(`Unknown microservice type: ${microservice.type}`)
+  }
+}
+
+function killMicroservices(microservices) {
+  console.log("killMicroservices", { microservices })
+  return Promise.all(
+    microservices.map(
+      async (microservice) => await killMicroservice(microservice),
+    ),
+  )
+}
+function projectMicroservices(projectFolderPath) {
+  console.log("projectMicroservices", { projectFolderPath })
+  const filePath = microservicesMetadatasPath(projectFolderPath)
+
+  if (!fs.existsSync(filePath)) {
+    const microservicesMetadatas = { microservices: [] }
+    fs.writeFileSync(
+      filePath,
+      JSON.stringify(microservicesMetadatas, null, 2),
+      "utf-8",
+    )
+  }
+  const content = JSON.parse(fs.readFileSync(filePath, "utf-8"))
+  return content.microservices
+}
+
+async function cleanupBackend(projectFolderPath) {
+  const microservices = projectMicroservices(projectFolderPath)
+  await killMicroservices(microservices)
+  await deleteFolderRecursive(projectFolderPath)
+}
+
+function microservicesMetadatasPath(projectFolderPath) {
+  return path.join(projectFolderPath, "microservices.json")
+}
+
+function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
+  const microservices = projectMicroservices(projectFolderPath)
+  if (serviceObj.type === "back") {
+    const schema = back_schemas.opengeodeweb_back.kill
+    serviceObj.url = `http://localhost:${serviceObj.port}/${schema.$id}`
+    serviceObj.method = schema.methods[0]
+  } else if (serviceObj.type === "viewer") {
+    serviceObj.url = `ws://localhost:${serviceObj.port}/ws`
+  }
+
+  microservices.push(serviceObj)
+  fs.writeFileSync(
+    microservicesMetadatasPath(projectFolderPath),
+    JSON.stringify({ microservices }, null, 2),
+  )
+}
+
+export {
+  addMicroserviceMetadatas,
+  cleanupBackend,
+  getAvailablePort,
+  killMicroservices,
+  projectMicroservices,
+  runBack,
+  runViewer,
+}

package/app/utils/local/path.js

@@ -0,0 +1,86 @@
+// Node imports
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { setTimeout } from "node:timers/promises"
+
+// Third party imports
+import isElectron from "is-electron"
+import { rimraf } from "rimraf"
+import { v4 as uuidv4 } from "uuid"
+
+const MAX_DELETE_FOLDER_RETRIES = 5
+
+function venvScriptPath(microservicePath) {
+  const venvPath = path.join(microservicePath, "venv")
+  let scriptPath = ""
+  if (process.platform === "win32") {
+    scriptPath = path.join(venvPath, "Scripts")
+  } else {
+    scriptPath = path.join(venvPath, "bin")
+  }
+  return scriptPath
+}
+
+async function executablePath(microservicePath) {
+  if (isElectron()) {
+    const electron = await import("electron")
+    if (electron.app.isPackaged) {
+      return process.resourcesPath
+    } else {
+      return venvScriptPath(microservicePath)
+    }
+  } else {
+    return venvScriptPath(microservicePath)
+  }
+}
+
+function executableName(name) {
+  if (process.platform === "win32") {
+    return `${name}.exe`
+  }
+  return name
+}
+
+function createPath(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true })
+    console.log(`${dirPath} directory created successfully!`)
+  }
+  return dirPath
+}
+
+function generateProjectFolderPath(projectName) {
+  return path.join(os.tmpdir(), projectName.replace(/\//g, "_"), uuidv4())
+}
+
+async function deleteFolderRecursive(folderPath) {
+  if (!fs.existsSync(folderPath)) {
+    console.log(`Folder ${folderPath} does not exist.`)
+    return
+  }
+  for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
+    try {
+      console.log(`Deleting folder: ${folderPath}`)
+      // oxlint-disable-next-line no-await-in-loop
+      await rimraf(folderPath)
+      console.log(`Deleted folder: ${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
+      await setTimeout(DELAY)
+      console.log("Retrying delete folder")
+    }
+  }
+}
+export {
+  createPath,
+  executablePath,
+  executableName,
+  deleteFolderRecursive,
+  generateProjectFolderPath,
+}

package/app/utils/local/scripts.js

@@ -0,0 +1,49 @@
+// Node imports
+import { on } from "node:events"
+import child_process from "node:child_process"
+import fs from "node:fs"
+import path from "node:path"
+
+function commandExistsSync(execName) {
+  const envPath = process.env.PATH || ""
+  return envPath.split(path.delimiter).some((dir) => {
+    const filePath = path.join(dir, execName)
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile()
+  })
+}
+
+async function waitForReady(child, expectedResponse) {
+  for await (const [data] of on(child.stdout, "data")) {
+    if (data.toString().includes(expectedResponse)) {
+      return child
+    }
+  }
+  throw new Error("Process closed before signal")
+}
+
+async function waitNuxt(nuxtProcess) {
+  for await (const [data] of on(nuxtProcess.stdout, "data")) {
+    const output = data.toString()
+    console.log("Nuxt:", output)
+    const portMatch = output.match(/Listening on http:\/\/\[::\]:(\d+)/)
+    if (portMatch) {
+      const [, nuxtPort] = portMatch
+
+      console.log("Nuxt listening on port", nuxtPort)
+      return nuxtPort
+    }
+  }
+  throw new Error("Nuxt process closed without accepting connections")
+}
+
+async function runBrowser(scriptName) {
+  process.env.BROWSER = true
+
+  const nuxtProcess = child_process.spawn("npm", ["run", scriptName], {
+    shell: true,
+    FORCE_COLOR: true,
+  })
+  return await waitNuxt(nuxtProcess)
+}
+
+export { runBrowser, waitForReady, commandExistsSync }

package/app/utils/server.js

@@ -0,0 +1,45 @@
+// Node imports
+import fs from "node:fs"
+import path from "node:path"
+
+// Third party imports
+import JSZip from "jszip"
+
+async function unzipFile(
+  zipFilePath,
+  outputDir = zipFilePath.replace(/\.[^/.]+$/, ""), // Remove the file extension
+) {
+  console.log("Unzipping file...", zipFilePath, outputDir)
+  try {
+    const data = await fs.promises.readFile(zipFilePath)
+    const zip = await JSZip.loadAsync(data)
+    await fs.promises.mkdir(outputDir, { recursive: true })
+    const promises = []
+
+    zip.forEach((relativePath, zipEntry) => {
+      const outputPath = path.join(outputDir, relativePath)
+
+      if (zipEntry.dir) {
+        promises.push(fs.promises.mkdir(outputPath, { recursive: true }))
+      } else {
+        promises.push(
+          zipEntry.async("nodebuffer").then(async (content) => {
+            await fs.promises.mkdir(path.dirname(outputPath), {
+              recursive: true,
+            })
+            await fs.promises.writeFile(outputPath, content)
+          }),
+        )
+      }
+    })
+
+    await Promise.all(promises)
+    console.log("Extraction complete!")
+    return outputDir
+  } catch (error) {
+    console.error("Error unzipping file:", error)
+    throw error
+  }
+}
+
+export { unzipFile }

package/{app → internal}/utils/upload_file.js

@@ -1,12 +1,12 @@
-import { useFeedbackStore } from "@ogw_front/stores/feedback"
-import { useGeodeStore } from "@ogw_front/stores/geode"
+import { useFeedbackStore } from "@ogw_front/stores/feedback.js"
 
 async function upload_file(
+  microservice,
   { route, file },
   { request_error_function, response_function, response_error_function } = {},
 ) {
+  console.log("[UPLOAD_FILE] Uploading file", { route, file })
   const feedbackStore = useFeedbackStore()
-  const geodeStore = useGeodeStore()
   if (!(file instanceof File)) {
     throw new Error("file must be a instance of File")
   }
@@ -18,12 +18,12 @@ async function upload_file(
     method: "PUT",
     body: body,
   }
-  geodeStore.start_request()
+  microservice.start_request()
   return $fetch(route, {
-    baseURL: geodeStore.base_url,
+    baseURL: microservice.base_url || "",
     ...request_options,
     onRequestError({ error }) {
-      geodeStore.stop_request()
+      microservice.stop_request()
       feedbackStore.add_error(error.code, route, error.message, error.stack)
       if (request_error_function) {
         request_error_function(error)
@@ -31,14 +31,14 @@ async function upload_file(
     },
     onResponse({ response }) {
       if (response.ok) {
-        geodeStore.stop_request()
+        microservice.stop_request()
         if (response_function) {
           response_function(response)
         }
       }
     },
     onResponseError({ response }) {
-      geodeStore.stop_request()
+      microservice.stop_request()
       feedbackStore.add_error(
         response.status,
         route,

package/nuxt.config.js

@@ -1,18 +1,36 @@
+// Node imports
 import path, { dirname } from "node:path"
 import { fileURLToPath } from "node:url"
 
+// Local imports
+import package_json from "./package.json"
+
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
 export default defineNuxtConfig({
   runtimeConfig: {
     public: {
       API_URL: "api.geode-solutions.com",
+      BACK_COMMAND: "opengeodeweb-back",
+      BACK_PATH: path.join(
+        __dirname,
+        "tests",
+        "integration",
+        "microservices",
+        "back",
+      ),
+      BROWSER: process.env.BROWSER ?? false,
+      PROJECT: package_json.name,
       SITE_BRANCH:
         process.env.NODE_ENV === "production" ? process.env.SITE_BRANCH : "",
-      PROJECT: process.env.NODE_ENV === "production" ? process.env.PROJECT : "",
-      BROWSER: process.env.BROWSER ?? false,
-      GEODE_PORT: process.env.GEODE_PORT ?? undefined,
-      VIEWER_PORT: process.env.VIEWER_PORT ?? undefined,
+      VIEWER_COMMAND: "opengeodeweb-viewer",
+      VIEWER_PATH: path.join(
+        __dirname,
+        "tests",
+        "integration",
+        "microservices",
+        "viewer",
+      ),
     },
   },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.5.1",
+  "version": "10.6.0",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -41,15 +41,20 @@
     "@vueuse/nuxt": "13.1.0",
     "@vueuse/rxjs": "^14.1.0",
     "ajv": "8.17.1",
+    "busboy": "1.6.0",
+    "conf": "15.1.0",
     "dexie": "4.2.1",
     "get-port-please": "3.2.0",
     "is-electron": "2.2.2",
     "js-file-download": "0.4.12",
+    "jszip": "3.10.1",
+    "node-stream-zip": "1.15.0",
     "nuxt": "4.2.2",
     "p-timeout": "7.0.1",
     "pinia": "3.0.4",
     "rimraf": "6.1.3",
     "rxjs": "7.8.2",
+    "sanitize-filename": "1.6.3",
     "sass": "1.87.0",
     "semver": "7.7.1",
     "uuid": "11.1.0",
@@ -62,7 +67,7 @@
   "devDependencies": {
     "@nuxt/test-utils": "3.21.0",
     "@pinia/testing": "1.0.3",
-    "@vitejs/plugin-vue": "5.2.4",
+    "@vitejs/plugin-vue": "6.0.4",
     "@vue/test-utils": "2.4.6",
     "eslint": "9.26.0",
     "eslint-plugin-import": "2.31.0",
@@ -77,11 +82,11 @@
     "prettier": "3.3.3",
     "resize-observer-polyfill": "1.5.1",
     "unplugin-auto-import": "20.0.0",
-    "vite": "6.3.5",
+    "vite": "7.3.1",
     "vite-plugin-vuetify": "2.1.1",
     "vitest": "4.0.15",
     "vitest-environment-nuxt": "1.0.1",
-    "vitest-indexeddb": "^0.0.1"
+    "vitest-indexeddb": "0.0.1"
   },
   "peerDependencies": {
     "electron": "36.4.0"

package/server/api/app/kill.post.js

@@ -0,0 +1,11 @@
+// Node imports
+
+// Third party imports
+import { defineEventHandler } from "h3"
+
+// Local imports
+
+export default defineEventHandler(() => {
+  console.log("Killing node server process")
+  process.exit()
+})

package/server/api/app/project_folder_path.post.js

@@ -0,0 +1,29 @@
+// Node imports
+
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3"
+
+// Local imports
+import {
+  createPath,
+  generateProjectFolderPath,
+} from "@geode/opengeodeweb-front/app/utils/local/path.js"
+
+export default defineEventHandler(async (event) => {
+  try {
+    const { PROJECT } = await readBody(event)
+    const projectFolderPath = generateProjectFolderPath(PROJECT)
+    await createPath(projectFolderPath)
+
+    return {
+      statusCode: 200,
+      projectFolderPath,
+    }
+  } catch (error) {
+    console.log(error)
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message,
+    })
+  }
+})

package/server/api/app/run_back.post.js

@@ -0,0 +1,33 @@
+// Node imports
+
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3"
+
+// Local imports
+import {
+  addMicroserviceMetadatas,
+  runBack,
+} from "@geode/opengeodeweb-front/app/utils/local/microservices.js"
+
+export default defineEventHandler(async (event) => {
+  try {
+    const { BACK_COMMAND, BACK_PATH, args } = await readBody(event)
+    const port = await runBack(BACK_COMMAND, BACK_PATH, args)
+    await addMicroserviceMetadatas(args.projectFolderPath, {
+      type: "back",
+      name: BACK_COMMAND,
+      port,
+    })
+
+    return {
+      statusCode: 200,
+      port,
+    }
+  } catch (error) {
+    console.log(error)
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message,
+    })
+  }
+})

package/server/api/app/run_viewer.post.js

@@ -0,0 +1,33 @@
+// Node imports
+
+// Third party imports
+import { createError, defineEventHandler, readBody } from "h3"
+
+// Local imports
+import {
+  addMicroserviceMetadatas,
+  runViewer,
+} from "@geode/opengeodeweb-front/app/utils/local/microservices.js"
+
+export default defineEventHandler(async (event) => {
+  try {
+    const { VIEWER_COMMAND, VIEWER_PATH, args } = await readBody(event)
+    const port = await runViewer(VIEWER_COMMAND, VIEWER_PATH, args)
+    await addMicroserviceMetadatas(args.projectFolderPath, {
+      type: "viewer",
+      name: VIEWER_COMMAND,
+      port,
+    })
+
+    return {
+      statusCode: 200,
+      port,
+    }
+  } catch (error) {
+    console.log(error)
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message,
+    })
+  }
+})