@geode/opengeodeweb-front 10.3.0 → 10.3.1

package/app/utils/local.js

@@ -1,19 +1,23 @@
-// Node.js imports
-import fs from "fs"
-import path from "path"
-import child_process from "child_process"
-import WebSocket from "ws"
+import { on, once } from "node:events"
+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 back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" }
 import { getPort } from "get-port-please"
 import isElectron from "is-electron"
 import pTimeout from "p-timeout"
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" }
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json" with { type: "json" }
 
+const MAX_DELETE_FOLDER_RETRIES = 5
+const DEFAULT_TIMEOUT_SECONDS = 30
+const MILLISECONDS_PER_SECOND = 1000
+
 function venv_script_path(root_path, microservice_path) {
   const venv_path = path.join(root_path, microservice_path, "venv")
-  var script_path
+  let script_path = ""
   if (process.platform === "win32") {
     script_path = path.join(venv_path, "Scripts")
   } else {
@@ -37,7 +41,7 @@ async function executable_path(microservice_path) {
 
 function executable_name(name) {
   if (process.platform === "win32") {
-    return name + ".exe"
+    return `${name}.exe`
   }
   return name
 }
@@ -65,119 +69,108 @@ function commandExistsSync(executable_name) {
   })
 }
 
+async function wait_for_ready(child, expected_response) {
+  for await (const [data] of on(child.stdout, "data")) {
+    if (data.toString().includes(expected_response)) {
+      return child
+    }
+  }
+  throw new Error("Process closed before signal")
+}
+
 async function run_script(
   executable_name,
   executable_path,
   args,
   expected_response,
-  timeout_seconds = 30,
+  timeout_seconds = DEFAULT_TIMEOUT_SECONDS,
 ) {
-  return new Promise((resolve, reject) => {
-    setTimeout(() => {
-      reject("Timed out after " + timeout_seconds + " seconds")
-    }, timeout_seconds * 1000)
+  const command = commandExistsSync(executable_name)
+    ? executable_name
+    : path.join(executable_path, executable_name)
+  console.log("run_script", command, args)
+  const child = child_process.spawn(command, args, {
+    encoding: "utf8",
+    shell: true,
+  })
 
-    const command = commandExistsSync(executable_name)
-      ? executable_name
-      : path.join(executable_path, executable_name)
-    console.log("run_script", command, args)
-    const child = child_process.spawn(command, args, {
-      encoding: "utf8",
-      shell: true,
-    })
+  child.stdout.on("data", (data) => console.log(data.toString()))
 
-    // You can also use a variable to save the output for when the script closes later
-    child.stderr.setEncoding("utf8")
-    child.on("error", async (error) => {
-      const electron = await import("electron")
-      electron.dialog.showMessageBox({
-        title: "Title",
-        type: "warning",
-        message: "Error occured.\r\n" + error,
-      })
-    })
-    child.stdout.setEncoding("utf8")
-    child.stdout.on("data", (data) => {
-      //Here is the output
-      data = data.toString()
-      if (data.includes(expected_response)) {
-        resolve(child)
-      }
-      console.log(data)
+  child.on("error", async (error) => {
+    const electron = await import("electron")
+    electron.dialog.showMessageBox({
+      title: "Title",
+      type: "warning",
+      message: `Error occured.\r\n${error}`,
     })
+  })
 
-    child.stderr.on("data", (data) => {
-      console.log(data)
-    })
+  child.on("close", (code) =>
+    console.log(`Child Process exited with code ${code}`),
+  )
+  child.on("kill", () => {
+    console.log("Child Process killed")
+  })
+  child.name = command.replace(/^.*[\\/]/, "")
 
-    child.on("close", (_code) => {
-      //Here you can get the exit code of the script
-      console.log("Child Process exited with code " + _code)
-    })
-    child.on("kill", () => {
-      console.log("Child Process killed")
+  try {
+    return await pTimeout(wait_for_ready(child, expected_response), {
+      milliseconds: timeout_seconds * MILLISECONDS_PER_SECOND,
+      message: `Timed out after ${timeout_seconds} seconds`,
     })
-    child.name = command.replace(/^.*[\\/]/, "")
-    return child
-  })
+  } catch (error) {
+    child.kill()
+    throw error
+  }
 }
 
-async function run_back(
-  executable_name,
-  executable_path,
-  args = {
-    project_folder_path,
-    upload_folder_path: undefined,
-  },
-) {
-  return new Promise(async (resolve, reject) => {
-    let upload_folder_path = args.upload_folder_path
-    if (!args.upload_folder_path) {
-      upload_folder_path = path.join(args.project_folder_path, "uploads")
-    }
-    const port = await get_available_port()
-    const back_args = [
-      "--port " + port,
-      "--data_folder_path " + args.project_folder_path,
-      "--upload_folder_path " + upload_folder_path,
-      "--allowed_origin http://localhost:*",
-      "--timeout " + 0,
-    ]
-    if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
-      back_args.push("--debug")
-    }
-    console.log("run_back", executable_name, executable_path, back_args)
-    await run_script(
-      executable_name,
-      executable_path,
-      back_args,
-      "Serving Flask app",
-    )
-    resolve(port)
-  })
+async function run_back(executable_name, executable_path, args = {}) {
+  let { project_folder_path, upload_folder_path } = args
+  if (!project_folder_path) {
+    throw new Error("project_folder_path is required")
+  }
+  if (!upload_folder_path) {
+    upload_folder_path = path.join(project_folder_path, "uploads")
+  }
+  const port = await get_available_port()
+  const back_args = [
+    `--port ${port}`,
+    `--data_folder_path ${project_folder_path}`,
+    `--upload_folder_path ${upload_folder_path}`,
+    `--allowed_origin http://localhost:*`,
+    `--timeout ${0}`,
+  ]
+  if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
+    back_args.push("--debug")
+  }
+  console.log("run_back", executable_name, executable_path, back_args)
+  await run_script(
+    executable_name,
+    executable_path,
+    back_args,
+    "Serving Flask app",
+  )
+  return port
 }
 
-async function run_viewer(
-  executable_name,
-  executable_path,
-  args = { project_folder_path },
-) {
-  return new Promise(async (resolve, reject) => {
-    const port = await get_available_port()
-    const viewer_args = [
-      "--port " + port,
-      "--data_folder_path " + args.project_folder_path,
-      "--timeout " + 0,
-    ]
-    console.log("run_viewer", executable_name, executable_path, viewer_args)
-    await run_script(
-      executable_name,
-      executable_path,
-      viewer_args,
-      "Starting factory",
-    )
-    resolve(port)
-  })
+async function run_viewer(executable_name, executable_path, args = {}) {
+  if (!args.project_folder_path) {
+    throw new Error("project_folder_path is required")
+  }
+  const port = await get_available_port()
+  const viewer_args = [
+    `--port ${port}`,
+    `--data_folder_path ${args.project_folder_path}`,
+    `--timeout ${0}`,
+  ]
+  console.log("run_viewer", executable_name, executable_path, viewer_args)
+  await run_script(
+    executable_name,
+    executable_path,
+    viewer_args,
+    "Starting factory",
+  )
+  return port
 }
 
 function delete_folder_recursive(data_folder_path) {
@@ -186,60 +179,52 @@ function delete_folder_recursive(data_folder_path) {
     return
   }
   try {
-    for (const i = 0; i <= 5; i++) {
+    for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
       console.log(`Deleting folder: ${data_folder_path}`)
       fs.rmSync(data_folder_path, { recursive: true, force: true })
       console.log(`Deleted folder: ${data_folder_path}`)
       return
     }
-  } catch (err) {
-    console.error(`Error deleting folder ${data_folder_path}:`, err)
+  } catch (error) {
+    console.error(`Error deleting folder ${data_folder_path}:`, error)
   }
 }
 
 function kill_back(back_port) {
-  return pTimeout(
-    new Promise((resolve, reject) => {
-      fetch(
-        "http://localhost:" +
-          back_port +
-          "/" +
-          back_schemas.opengeodeweb_back.kill.$id,
+  async function do_kill() {
+    try {
+      await fetch(
+        `http://localhost:${back_port}/${back_schemas.opengeodeweb_back.kill.$id}`,
         {
           method: back_schemas.opengeodeweb_back.kill.methods[0],
         },
       )
-        .then(() => {
-          console.log("Failed to kill back")
-          reject()
-        })
-        .catch(() => {
-          console.log("Back closed")
-          resolve()
-        })
-    }),
-    {
-      milliseconds: 500,
-      message: "Failed to kill back",
-    },
-  )
+      throw new Error("Failed to kill back")
+    } catch (error) {
+      console.log("Back closed", error)
+    }
+  }
+  return pTimeout(do_kill(), {
+    milliseconds: 500,
+    message: "Failed to kill back",
+  })
 }
 
 function kill_viewer(viewer_port) {
-  return pTimeout(
-    new Promise((resolve) => {
-      const socket = new WebSocket("ws://localhost:" + viewer_port + "/ws")
-      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) => {
+  async function do_kill() {
+    const socket = new WebSocket(`ws://localhost:${viewer_port}/ws`)
+    try {
+      await once(socket, "open")
+      console.log("Connected to WebSocket server")
+      socket.send(
+        JSON.stringify({
+          id: "system:hello",
+          method: "wslink.hello",
+          args: [{ secret: "wslink-secret" }],
+        }),
+      )
+
+      for await (const [data] of on(socket, "message")) {
         const message = data.toString()
         console.log("Received from server:", message)
 
@@ -250,48 +235,89 @@ function kill_viewer(viewer_port) {
               method: viewer_schemas.opengeodeweb_viewer.kill.$id,
             }),
           )
-          resolve()
+          break
         }
-      })
-      socket.on("close", () => {
-        console.log("Disconnected from WebSocket server")
-        resolve()
-      })
-      socket.on("error", (error) => {
-        console.error("WebSocket error:", error)
-        resolve()
-      })
-    }),
-    {
-      milliseconds: 500,
-      message: "Failed to kill viewer",
-    },
-  )
+      }
+      await once(socket, "close")
+      console.log("Disconnected from WebSocket server")
+    } catch (error) {
+      console.error("WebSocket error:", error)
+    } finally {
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.close()
+      }
+    }
+  }
+
+  return pTimeout(do_kill(), {
+    milliseconds: 500,
+    message: "Failed to kill viewer",
+  })
+}
+
+async function wait_nuxt(nuxt_process, back_port, viewer_port) {
+  for await (const [data] of on(nuxt_process.stdout, "data")) {
+    const output = data.toString()
+    const portMatch = output.match(
+      /Accepting connections at http:\/\/localhost:(\d+)/,
+    )
+    console.log("Nuxt:", output)
+    if (portMatch) {
+      const [, nuxt_port] = portMatch
+      process.env.NUXT_PORT = nuxt_port
+      return { geode_port: back_port, viewer_port, nuxt_port }
+    }
+  }
+  throw new Error("Nuxt process closed without accepting connections")
 }
 
 async function run_browser(
   script_name,
   microservices_options = {
-    back: { executable_name, executable_path, args: { project_folder_path } },
-    viewer: { executable_name, executable_path, args: { project_folder_path } },
+    back: {
+      executable_name: executable_name("opengeodeweb-back"),
+      executable_path: "",
+      args: { project_folder_path: "" },
+    },
+    viewer: {
+      executable_name: executable_name("opengeodeweb-viewer"),
+      executable_path: "",
+      args: { project_folder_path: "" },
+    },
   },
 ) {
-  console.log("microservices_options", microservices_options)
+  if (
+    microservices_options.back.executable_path === "" ||
+    microservices_options.back.args.project_folder_path === ""
+  ) {
+    const microservices_path = "microservices"
+    microservices_options.back.executable_path =
+      await executable_path(microservices_path)
+    microservices_options.back.args.project_folder_path = create_path(
+      path.join(process.cwd(), "data"),
+    )
+  }
+  if (
+    microservices_options.viewer.executable_path === "" ||
+    microservices_options.viewer.args.project_folder_path === ""
+  ) {
+    const microservices_path = "microservices"
+    microservices_options.viewer.executable_path =
+      await executable_path(microservices_path)
+    microservices_options.viewer.args.project_folder_path =
+      microservices_options.back.args.project_folder_path
+  }
   const back_promise = run_back(
     microservices_options.back.executable_name,
     microservices_options.back.executable_path,
-    {
-      ...microservices_options.back.args,
-    },
+    { ...microservices_options.back.args },
   )
   console.log("back_promise", back_promise)
 
   const viewer_promise = run_viewer(
     microservices_options.viewer.executable_name,
     microservices_options.viewer.executable_path,
-    {
-      ...microservices_options.viewer.args,
-    },
+    { ...microservices_options.viewer.args },
   )
   console.log("viewer_promise", viewer_promise)
 
@@ -316,22 +342,7 @@ async function run_browser(
     shell: true,
     FORCE_COLOR: true,
   })
-
-  return new Promise((resolve) => {
-    nuxt_process.stdout.on("data", function (data) {
-      const output = data.toString()
-      const portMatch = output.match(
-        /Accepting\ connections\ at\ http:\/\/localhost:(\d+)/,
-      )
-      console.log("Nuxt: ", output)
-      if (portMatch) {
-        const nuxt_port = portMatch[1]
-        process.env.NUXT_PORT = nuxt_port
-        resolve({ geode_port: back_port, viewer_port, nuxt_port })
-        return
-      }
-    })
-  })
+  return wait_nuxt(nuxt_process, back_port, viewer_port)
 }
 
 export {

package/app/utils/upload_file.js

@@ -1,5 +1,5 @@
-import { useGeodeStore } from "@ogw_front/stores/geode"
 import { useFeedbackStore } from "@ogw_front/stores/feedback"
+import { useGeodeStore } from "@ogw_front/stores/geode"
 
 export async function upload_file(
   { route, file },
@@ -18,7 +18,6 @@ export async function upload_file(
     method: "PUT",
     body: body,
   }
-
   geodeStore.start_request()
   return $fetch(route, {
     baseURL: geodeStore.base_url,

package/eslint.config.js

@@ -1,7 +1,8 @@
+import nuxt from "eslint-plugin-nuxt"
 import vue from "eslint-plugin-vue"
 import vuetify from "eslint-plugin-vuetify"
-import nuxt from "eslint-plugin-nuxt"
 
+// oxlint-disable-next-line import/no-anonymous-default-export
 export default [
   {
     files: ["**/*.{js,ts,vue}"],
@@ -11,7 +12,6 @@ export default [
       globals: {
         window: "readonly",
         document: "readonly",
-        // ajoute d'autres globals si nécessaire
       },
     },
     plugins: {

package/internal/database/database.js

@@ -1,8 +1,9 @@
-import Dexie from "dexie"
+import { Dexie } from "dexie"
+import { ExtendedDatabase } from "./extended_database"
 import { dataTable } from "./tables/data_table"
 import { modelComponentsTable } from "./tables/model_components"
 
-export class Database extends Dexie {
+class Database extends Dexie {
   constructor() {
     super("Database")
 
@@ -16,50 +17,34 @@ export class Database extends Dexie {
     const tempDb = new Database()
     await tempDb.open()
 
-    if (tempDb.tables.some((t) => t.name === tableName)) {
-      console.warn(`Table "${tableName}" already exists`)
+    if (tempDb.tables.some((table) => table.name === tableName)) {
       tempDb.close()
       return tempDb
     }
 
     const currentVersion = tempDb.verno
-
     const currentStores = {}
-    tempDb.tables.forEach((table) => {
+
+    for (const table of tempDb.tables) {
       const keyPath = table.schema.primKey.src
-      const indexes = table.schema.indexes.map((idx) => idx.src)
+      const indexes = table.schema.indexes.map((index) => index.src)
       currentStores[table.name] = [keyPath, ...indexes].join(",")
-    })
+    }
 
     tempDb.close()
 
-    class ExtendedDatabase extends Dexie {
-      constructor() {
-        super("Database")
-
-        for (let v = 1; v <= currentVersion; v++) {
-          if (v === 1) {
-            this.version(1).stores({
-              [dataTable.name]: dataTable.schema,
-              [modelComponentsTable.name]: modelComponentsTable.schema,
-            })
-          } else {
-            this.version(v).stores(currentStores)
-          }
-        }
-
-        this.version(currentVersion + 1).stores({
-          ...currentStores,
-          [tableName]: schemaDefinition,
-        })
-      }
-    }
-
-    const newDb = new ExtendedDatabase()
+    const newDb = new ExtendedDatabase(
+      currentVersion,
+      currentStores,
+      tableName,
+      schemaDefinition,
+    )
     await newDb.open()
 
     return newDb
   }
 }
 
-export const database = new Database()
+const database = new Database()
+
+export { Database, database }

package/internal/database/extended_database.js

@@ -0,0 +1,25 @@
+import { Dexie } from "dexie"
+import { dataTable } from "./tables/data_table"
+import { modelComponentsTable } from "./tables/model_components"
+
+export class ExtendedDatabase extends Dexie {
+  constructor(currentVersion, currentStores, tableName, schemaDefinition) {
+    super("Database")
+
+    for (let version = 1; version <= currentVersion; version += 1) {
+      if (version === 1) {
+        this.version(1).stores({
+          [dataTable.name]: dataTable.schema,
+          [modelComponentsTable.name]: modelComponentsTable.schema,
+        })
+      } else {
+        this.version(version).stores(currentStores)
+      }
+    }
+
+    this.version(currentVersion + 1).stores({
+      ...currentStores,
+      [tableName]: schemaDefinition,
+    })
+  }
+}

package/internal/stores/data_style/mesh/cells/cell.js

@@ -2,9 +2,9 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { useViewerStore } from "@ogw_front/stores/viewer"
 import { getRGBPointsFromPreset } from "@ogw_front/utils/colormap"
 import { useMeshCellsCommonStyle } from "./common"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
 const meshCellsCellAttributeSchemas =
@@ -30,7 +30,7 @@ export function useMeshCellsCellAttributeStyle() {
   }
 
   function meshCellsCellAttributeStoredConfig(id, name) {
-    const storedConfigs = meshCellsCellAttribute(id).storedConfigs
+    const { storedConfigs } = meshCellsCellAttribute(id)
     if (name in storedConfigs) {
       return storedConfigs[name]
     }
@@ -46,7 +46,7 @@ export function useMeshCellsCellAttributeStyle() {
     name,
     { minimum, maximum, colorMap },
   ) {
-    const storedConfigs = meshCellsCellAttribute(id).storedConfigs
+    const { storedConfigs } = meshCellsCellAttribute(id)
     storedConfigs[name] = { minimum, maximum, colorMap }
     return storedConfigs[name]
   }

package/internal/stores/data_style/mesh/cells/color.js

@@ -2,8 +2,8 @@
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 
 // Local imports
-import { useViewerStore } from "@ogw_front/stores/viewer"
 import { useMeshCellsCommonStyle } from "./common"
+import { useViewerStore } from "@ogw_front/stores/viewer"
 
 // Local constants
 const meshCellsColorSchemas =