@geode/opengeodeweb-front 9.11.5 → 9.11.6-rc.2

package/components/Viewer/Options/TextureItem.vue

@@ -42,15 +42,15 @@
 
   const props = defineProps({
     id: { type: String, required: true },
+    texture_id: { type: String, required: true },
     texture_name: { type: String, required: true },
-    texture_file_name: { type: String, required: true },
   })
 
   const texture_name = ref("")
   texture_name.value = props.texture_name
 
-  const texture_file_name = ref("")
-  texture_file_name.value = props.texture_file_name
+  const texture_id = ref("")
+  texture_id.value = props.texture_id
 
   const texture_coordinates = ref([])
 
@@ -86,7 +86,7 @@
         },
         {
           response_function: async (response) => {
-            texture_file_name.value = response._data.viewable_file_name
+            texture_id.value = response._data.id
           },
         },
       )
@@ -97,8 +97,8 @@
     emit("update_value", { key: "texture_name", value })
   })
 
-  watch(texture_file_name, (value) => {
-    emit("update_value", { key: "texture_file_name", value })
+  watch(texture_id, (value) => {
+    emit("update_value", { key: "id", value })
   })
 </script>
 

package/components/Viewer/Options/TexturesSelector.vue

@@ -18,7 +18,7 @@
     <ViewerOptionsTextureItem
       :id="id"
       :texture_name="internal_textures[index].texture_name"
-      :texture_file_name="internal_textures[index].texture_file_name"
+      :texture_id="internal_textures[index].id"
       @update_value="update_value_event($event, index)"
     />
   </v-row>
@@ -30,9 +30,7 @@
         icon="mdi-plus"
         v-tooltip:bottom="'Add a texture'"
         size="20"
-        @click="
-          internal_textures.push({ texture_name: '', texture_file_name: '' })
-        "
+        @click="internal_textures.push({ texture_name: '', id: '' })"
       />
     </v-col>
   </v-row>
@@ -51,16 +49,16 @@
     if (textures.value != null) {
       internal_textures.value = textures.value
     } else {
-      internal_textures.value = [{ texture_name: "", texture_file_name: "" }]
+      internal_textures.value = [{ id: "", texture_name: "" }]
     }
   })
 
   function update_value_event($event, index) {
     internal_textures.value[index][$event.key] = $event.value
     const filtered = internal_textures.value.filter((texture) => {
-      return texture.texture_name != "" && texture.texture_file_name != ""
+      return texture.texture_name !== "" && texture.id !== ""
     })
-    if (filtered.length != 0) {
+    if (filtered.length !== 0) {
       textures.value = filtered
     }
   }

package/composables/viewer_call.js

@@ -13,8 +13,8 @@ export function viewer_call(
       console.log("schema", schema)
       console.log("params", params)
     }
-    feedback_store.add_error(400, schema.route, "Bad request", error)
-    throw new Error(schema.route.concat(": ", error))
+    feedback_store.add_error(400, schema.$id, "Bad request", error)
+    throw new Error(schema.$id.concat(": "))
   }
 
   const client = viewer_store.client
@@ -45,7 +45,7 @@ export function viewer_call(
       .catch((error) => {
         feedback_store.add_error(
           error.code,
-          schema.route,
+          schema.$id,
           error.message,
           error.message,
         )

package/internal_stores/data_style_state.js

@@ -14,5 +14,8 @@ export default function useDataStyleState() {
     return selection
   })
 
-  return { styles, objectVisibility, selectedObjects }
+  function getStyle(id) {
+    return styles[id]
+  }
+  return { getStyle, styles, objectVisibility, selectedObjects }
 }

package/internal_stores/mesh/edges.js

@@ -4,58 +4,56 @@ const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
 export function useMeshEdgesStyle() {
   const dataStyleStore = useDataStyleStore()
 
+  function edgesStyle(id) {
+    return dataStyleStore.getStyle(id).edges
+  }
+
   function edgesVisibility(id) {
-    return dataStyleStore.styles[id].edges.visibility
+    return edgesStyle(id).visibility
   }
   function setEdgesVisibility(id, visibility) {
-    const edges_style = dataStyleStore.styles[id].edges
+    const edges_style = edgesStyle(id)
     return viewer_call(
-      {
-        schema: mesh_edges_schemas.visibility,
-        params: { id, visibility },
-      },
+      { schema: mesh_edges_schemas.visibility, params: { id, visibility } },
       {
         response_function: () => {
           edges_style.visibility = visibility
-          console.log(`${setEdgesVisibility.name} ${edges_style.visibility}`)
+          console.log(`${setEdgesVisibility.name} ${id} ${edgesVisibility(id)}`)
         },
       },
     )
   }
 
   function edgesActiveColoring(id) {
-    return dataStyleStore.styles[id].edges.coloring.active
+    return edgesStyle(id).coloring.active
   }
-  async function setEdgesActiveColoring(id, type) {
-    const coloring = dataStyleStore.styles[id].edges.coloring
-    if (type == "color") {
-      setEdgesColor(id, coloring.color)
-      // else if (type == "vertex") {
-      //   const vertex = coloring.vertex
-      // if (vertex !== null) setEdgesVertexAttribute(id, vertex)
-      // } else if (type == "edges") {
-      //   const edges = coloring.edges
-      //   if (edges !== null) setEdgesEdgeAttribute(id, edges)
-    } else throw new Error("Unknown edges coloring type: " + type)
+  function setEdgesActiveColoring(id, type) {
+    const coloring = edgesStyle(id).coloring
     coloring.active = type
-    console.log(`${setEdgesActiveColoring.name} ${coloring.active}`)
+    console.log(
+      `${setEdgesActiveColoring.name} ${id} ${edgesActiveColoring(id)}`,
+    )
+    if (type === "color") {
+      return setEdgesColor(id, coloring.color)
+      // } else if (type == "vertex" && coloring.vertex !== null) {
+      //   return setEdgesVertexAttribute(id, coloring.vertex)
+      // } else if (type == "edges" && coloring.edges !== null) {
+      //   return setEdgesEdgeAttribute(id, coloring.edges)
+    } else throw new Error("Unknown edges coloring type: " + type)
   }
 
   function edgesColor(id) {
-    return dataStyleStore.styles[id].edges.coloring.color
+    return edgesStyle(id).coloring.color
   }
   function setEdgesColor(id, color) {
-    const coloring_style = dataStyleStore.styles[id].edges.coloring
+    const coloring_style = edgesStyle(id).coloring
     return viewer_call(
-      {
-        schema: mesh_edges_schemas.color,
-        params: { id, color },
-      },
+      { schema: mesh_edges_schemas.color, params: { id, color } },
       {
         response_function: () => {
           coloring_style.color = color
           console.log(
-            `${setEdgesColor.name} ${JSON.stringify(coloring_style.color)}`,
+            `${setEdgesColor.name} ${id} ${JSON.stringify(edgesColor(id))}`,
           )
         },
       },
@@ -63,25 +61,22 @@ export function useMeshEdgesStyle() {
   }
 
   function edgesWidth(id) {
-    return dataStyleStore.styles[id].edges.size
+    return edgesStyle(id).size
   }
   function setEdgesWidth(id, width) {
-    const edges_style = dataStyleStore.styles[id].edges
+    const edges_style = edgesStyle(id)
     return viewer_call(
-      {
-        schema: mesh_edges_schemas.width,
-        params: { id, width },
-      },
+      { schema: mesh_edges_schemas.width, params: { id, width } },
       {
         response_function: () => {
           edges_style.width = width
-          console.log(`${setEdgesWidth.name} ${edges_style.width}`)
+          console.log(`${setEdgesWidth.name} ${id} ${edgesWidth(id)}`)
         },
       },
     )
   }
 
-  async function applyEdgesStyle(id, style) {
+  function applyEdgesStyle(id, style) {
     return Promise.all([
       setEdgesVisibility(id, style.visibility),
       setEdgesActiveColoring(id, style.coloring.active),

package/internal_stores/mesh/index.js

@@ -12,6 +12,9 @@ export default function useMeshStyle() {
   const polyhedraStyleStore = useMeshPolyhedraStyle()
   const hybridViewerStore = useHybridViewerStore()
 
+  function meshVisibility(id) {
+    return dataStyleStore.styles[id].visibility
+  }
   function setMeshVisibility(id, visibility) {
     return viewer_call(
       {
@@ -22,32 +25,35 @@ export default function useMeshStyle() {
         response_function: () => {
           hybridViewerStore.setVisibility(id, visibility)
           dataStyleStore.styles[id].visibility = visibility
+          console.log(`${setMeshVisibility.name} ${id} ${meshVisibility(id)}`)
         },
       },
     )
   }
 
-  async function applyMeshDefaultStyle(id) {
-    return new Promise(async (resolve) => {
-      const id_style = dataStyleStore.styles[id]
-      for (const [key, value] of Object.entries(id_style)) {
-        if (key == "visibility") {
-          await setMeshVisibility(id, value)
-        } else if (key == "points") {
-          await pointsStyleStore.applyPointsStyle(id, value)
-        } else if (key == "edges") {
-          await edgesStyleStore.applyEdgesStyle(id, value)
-        } else if (key == "polygons") {
-          await polygonsStyleStore.applyPolygonsStyle(id, value)
-        } else if (key == "polyhedra") {
-          await polyhedraStyleStore.applyPolyhedraStyle(id, value)
-        }
+  function applyMeshDefaultStyle(id) {
+    const style = dataStyleStore.getStyle(id)
+    const promise_array = []
+    for (const [key, value] of Object.entries(style)) {
+      if (key == "visibility") {
+        promise_array.push(setMeshVisibility(id, value))
+      } else if (key == "points") {
+        promise_array.push(pointsStyleStore.applyPointsStyle(id, value))
+      } else if (key == "edges") {
+        promise_array.push(edgesStyleStore.applyEdgesStyle(id, value))
+      } else if (key == "polygons") {
+        promise_array.push(polygonsStyleStore.applyPolygonsStyle(id, value))
+      } else if (key == "polyhedra") {
+        promise_array.push(polyhedraStyleStore.applyPolyhedraStyle(id, value))
+      } else {
+        throw new Error("Unknown key: " + key)
       }
-      resolve()
-    })
+    }
+    return promise_array
   }
 
   return {
+    meshVisibility,
     setMeshVisibility,
     applyMeshDefaultStyle,
     ...useMeshPointsStyle(),

package/package.json

@@ -40,11 +40,11 @@
   },
   "description": "OpenSource Vue/Vuetify framework for web applications",
   "type": "module",
-  "version": "9.11.5",
+  "version": "9.11.6-rc.2",
   "main": "./nuxt.config.js",
   "dependencies": {
-    "@geode/opengeodeweb-back": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/opengeodeweb-back": "next",
+    "@geode/opengeodeweb-viewer": "next",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",
     "@pinia/nuxt": "0.5.4",
@@ -59,11 +59,11 @@
     "pinia": "3.0.3",
     "sass": "1.87.0",
     "semver": "7.7.1",
-    "tree-kill": "1.2.2",
     "uuid": "11.1.0",
     "vue-recaptcha": "2.0.3",
     "vue3-carousel": "0.3.4",
     "vuetify": "3.8.12",
+    "ws": "8.18.3",
     "wslink": "1.12.4"
   },
   "repository": {

package/stores/data_base.js

@@ -42,10 +42,10 @@ export const useDataBaseStore = defineStore("dataBase", () => {
   }
 
   /** Actions **/
-  async function registerObject(id, file_name, viewer_object) {
+  async function registerObject(id, viewer_object) {
     return viewer_call({
       schema: viewer_schemas.opengeodeweb_viewer.generic.register,
-      params: { id, file_name, viewer_object },
+      params: { id, viewer_object },
     })
   }
   async function addItem(
@@ -76,14 +76,11 @@ export const useDataBaseStore = defineStore("dataBase", () => {
   }
 
   async function fetchMeshComponents(id) {
-    const { native_filename, geode_object } = itemMetaDatas(id)
     await api_fetch(
       {
         schema: back_schemas.opengeodeweb_back.models.mesh_components,
         params: {
           id,
-          filename: native_filename,
-          geode_object,
         },
       },
       {

package/stores/data_style.js

@@ -13,12 +13,12 @@ export const useDataStyleStore = defineStore("dataStyle", () => {
   function addDataStyle(id, geode_object, object_type) {
     dataStyleState.styles[id] = getDefaultStyle(geode_object)
     if (object_type === "mesh") {
-      return Promise.all([meshStyleStore.applyMeshDefaultStyle(id)])
+      return meshStyleStore.applyMeshDefaultStyle(id)
     } else if (object_type === "model") {
-      return Promise.all([
+      return [
         modelStyleStore.setMeshComponentsDefaultStyle(id),
         modelStyleStore.applyModelDefaultStyle(id),
-      ])
+      ]
     }
   }
 

package/tests/integration/microservices/back/requirements-internal.in

@@ -1 +1 @@
-opengeodeweb-back
+opengeodeweb-back

package/tests/integration/microservices/back/requirements.txt

@@ -2,105 +2,7 @@
 # This file is autogenerated by pip-compile with Python 3.12
 # by the following command:
 #
-#    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements-internal.in tests/integration/microservices/back/requirements.in
+#    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
-asgiref~=3.9
-    # via
-    #   flask
-    #   opengeodeweb-back
-blinker~=1.9
-    # via
-    #   flask
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-click~=8.3
-    # via
-    #   flask
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-fastjsonschema~=2.21
-    # via
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-flask[async]~=3.0
-    # via
-    #   flask-cors
-    #   flask-sqlalchemy
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-flask-cors~=6.0
-    # via opengeodeweb-back
-flask-sqlalchemy~=3.1
-    # via
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-geode-common~=33.11
-    # via
-    #   geode-viewables
-    #   opengeodeweb-back
-geode-viewables~=3.3
-    # via opengeodeweb-back
-greenlet~=3.2
-    # via
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-    #   sqlalchemy
-itsdangerous~=2.2
-    # via
-    #   flask
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-jinja2~=3.1
-    # via
-    #   flask
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-markupsafe~=3.0
-    # via
-    #   jinja2
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-    #   werkzeug
-opengeode-core~=15.27
-    # via
-    #   geode-common
-    #   geode-viewables
-    #   opengeode-geosciences
-    #   opengeode-geosciencesio
-    #   opengeode-inspector
-    #   opengeode-io
-    #   opengeodeweb-back
-opengeode-geosciences~=9.4
-    # via
-    #   geode-viewables
-    #   opengeode-geosciencesio
-    #   opengeodeweb-back
-opengeode-geosciencesio~=5.8
-    # via opengeodeweb-back
-opengeode-inspector~=6.8
-    # via opengeodeweb-back
-opengeode-io~=7.4
-    # via
-    #   geode-viewables
-    #   opengeode-geosciencesio
-    #   opengeodeweb-back
-opengeodeweb-back~=5.10,>=5.10.1
-    # via -r tests/integration/microservices/back/requirements-internal.in
-opengeodeweb-microservice~=1.0
-    # via opengeodeweb-back
-sqlalchemy~=2.0
-    # via
-    #   flask-sqlalchemy
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-typing-extensions~=4.15
-    # via
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
-    #   sqlalchemy
-werkzeug~=3.0
-    # via
-    #   flask
-    #   flask-cors
-    #   opengeodeweb-back
-    #   opengeodeweb-microservice
+
+opengeodeweb-back==5.*,>=5.10.3rc18

package/tests/integration/microservices/viewer/requirements-internal.in

@@ -1 +1 @@
-opengeodeweb-viewer[cpu]
+opengeodeweb-viewer

package/tests/integration/microservices/viewer/requirements.txt

@@ -2,160 +2,7 @@
 # This file is autogenerated by pip-compile with Python 3.12
 # by the following command:
 #
-#    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements-internal.in tests/integration/microservices/viewer/requirements.in
+#    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements.in
 #
-aiohappyeyeballs~=2.6
-    # via
-    #   aiohttp
-    #   opengeodeweb-viewer
-aiohttp~=3.12
-    # via
-    #   opengeodeweb-viewer
-    #   wslink
-aiosignal~=1.4
-    # via
-    #   aiohttp
-    #   opengeodeweb-viewer
-attrs~=25.3
-    # via
-    #   aiohttp
-    #   opengeodeweb-viewer
-blinker~=1.9
-    # via
-    #   flask
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-click~=8.3
-    # via
-    #   flask
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-contourpy~=1.3
-    # via
-    #   matplotlib
-    #   opengeodeweb-viewer
-cycler~=0.12
-    # via
-    #   matplotlib
-    #   opengeodeweb-viewer
-fastjsonschema~=2.21
-    # via
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-flask~=3.1
-    # via
-    #   flask-sqlalchemy
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-flask-sqlalchemy~=3.1
-    # via
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-fonttools~=4.60
-    # via
-    #   matplotlib
-    #   opengeodeweb-viewer
-frozenlist~=1.7
-    # via
-    #   aiohttp
-    #   aiosignal
-    #   opengeodeweb-viewer
-greenlet~=3.2
-    # via
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-    #   sqlalchemy
-idna==3.10
-    # via
-    #   opengeodeweb-viewer
-    #   yarl
-itsdangerous~=2.2
-    # via
-    #   flask
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-jinja2~=3.1
-    # via
-    #   flask
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-kiwisolver~=1.4
-    # via
-    #   matplotlib
-    #   opengeodeweb-viewer
-markupsafe~=3.0
-    # via
-    #   flask
-    #   jinja2
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-    #   werkzeug
-matplotlib~=3.10
-    # via
-    #   opengeodeweb-viewer
-    #   vtk
-multidict~=6.6
-    # via
-    #   aiohttp
-    #   opengeodeweb-viewer
-    #   yarl
-numpy~=2.3
-    # via
-    #   contourpy
-    #   matplotlib
-    #   opengeodeweb-viewer
-opengeodeweb-microservice~=1.0
-    # via opengeodeweb-viewer
-opengeodeweb-viewer[cpu]~=1.11
-    # via -r tests/integration/microservices/viewer/requirements-internal.in
-packaging==25.0
-    # via
-    #   matplotlib
-    #   opengeodeweb-viewer
-pillow~=11.3
-    # via
-    #   matplotlib
-    #   opengeodeweb-viewer
-propcache~=0.3
-    # via
-    #   aiohttp
-    #   opengeodeweb-viewer
-    #   yarl
-pyparsing~=3.2
-    # via
-    #   matplotlib
-    #   opengeodeweb-viewer
-python-dateutil==2.9.0.post0
-    # via
-    #   matplotlib
-    #   opengeodeweb-viewer
-six~=1.17
-    # via
-    #   opengeodeweb-viewer
-    #   python-dateutil
-sqlalchemy~=2.0
-    # via
-    #   flask-sqlalchemy
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-typing-extensions~=4.15
-    # via
-    #   aiosignal
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-    #   sqlalchemy
-vtk~=9.5
-    # via opengeodeweb-viewer
-websocket-client~=1.8
-    # via opengeodeweb-viewer
-werkzeug~=3.1
-    # via
-    #   flask
-    #   opengeodeweb-microservice
-    #   opengeodeweb-viewer
-wslink~=1.12
-    # via opengeodeweb-viewer
-yarl~=1.20
-    # via
-    #   aiohttp
-    #   opengeodeweb-viewer
+
+opengeodeweb-viewer==1.*,>=1.11.3rc9

package/tests/integration/stores/DataStyle/mesh/Edges.nuxt.test.js

@@ -1,4 +1,5 @@
 import path from "path"
+import fs from "fs"
 
 import { setActivePinia } from "pinia"
 import { createTestingPinia } from "@pinia/testing"
@@ -17,19 +18,25 @@ import {
 import {
   executable_name,
   executable_path,
-  kill_processes,
   run_viewer,
+  run_back,
+  kill_viewer,
+  kill_back,
 } from "@ogw_f/utils/local"
 
 import Status from "@ogw_f/utils/status"
 
+import { api_fetch } from "@ogw_f/composables/api_fetch"
 import * as composables from "@ogw_f/composables/viewer_call"
 import { useDataStyleStore } from "@ogw_f/stores/data_style"
 import { useDataBaseStore } from "@ogw_f/stores/data_base"
 import { useViewerStore } from "@ogw_f/stores/viewer"
 import { useInfraStore } from "@ogw_f/stores/infra"
+import { useGeodeStore } from "@ogw_f/stores/geode"
 
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
+import appMode from "@ogw_f/utils/app_mode"
 import { WebSocket } from "ws"
 
 const mesh_edges_schemas = viewer_schemas.opengeodeweb_viewer.mesh.edges
@@ -45,18 +52,50 @@ vi.stubGlobal("navigator", {
   },
 })
 
+let foldersBeforeTests = new Set()
+const data_folder_path = path.join(__dirname, "..", "..", "..", "data")
+
+function getCurrentFolders(dataFolderPath) {
+  if (!fs.existsSync(dataFolderPath)) {
+    return new Set()
+  }
+  const entries = fs.readdirSync(dataFolderPath)
+  const folders = new Set()
+  for (const entry of entries) {
+    const entryPath = path.join(dataFolderPath, entry)
+    if (fs.statSync(entryPath).isDirectory()) {
+      folders.add(entry)
+    }
+  }
+  return folders
+}
+
+function cleanupCreatedFolders(dataFolderPath, foldersBeforeTests) {
+  if (!fs.existsSync(dataFolderPath)) {
+    return
+  }
+  const currentFolders = getCurrentFolders(dataFolderPath)
+  for (const folder of currentFolders) {
+    if (!foldersBeforeTests.has(folder)) {
+      const folderPath = path.join(dataFolderPath, folder)
+      fs.rmSync(folderPath, { recursive: true, force: true })
+    }
+  }
+}
+
 beforeAll(() => {
   global.WebSocket = WebSocket
+  foldersBeforeTests = getCurrentFolders(data_folder_path)
 })
 
 afterAll(() => {
   delete global.WebSocket
+  cleanupCreatedFolders(data_folder_path, foldersBeforeTests)
 })
 
-const id = "fake_id"
-const file_name = "edged_curve.vtp"
+let id = "fake_id"
+const file_name = "test.og_edc2d"
 const geode_object = "EdgedCurve2D"
-const object_type = "mesh"
 
 beforeEach(async () => {
   const pinia = createTestingPinia({
@@ -66,33 +105,71 @@ beforeEach(async () => {
   setActivePinia(pinia)
   const dataStyleStore = useDataStyleStore()
   const dataBaseStore = useDataBaseStore()
+  const geodeStore = useGeodeStore()
   const viewerStore = useViewerStore()
   const infraStore = useInfraStore()
-  infraStore.app_mode = appMode.appMode.BROWSER
+  infraStore.app_mode = appMode.BROWSER
+
+  if (!fs.existsSync(data_folder_path)) {
+    fs.mkdirSync(data_folder_path, { recursive: true })
+  }
 
+  const back_path = path.join(
+    executable_path(path.join("tests", "integration", "microservices", "back")),
+    executable_name("opengeodeweb-back"),
+  )
   const viewer_path = path.join(
     executable_path(
       path.join("tests", "integration", "microservices", "viewer"),
     ),
-    executable_name("opengeodeweb_viewer"),
+    executable_name("opengeodeweb-viewer"),
   )
-  const viewer_port = await run_viewer(viewer_path, {
+
+  const back_promise = run_back(back_path, {
+    port: 5000,
+    data_folder_path,
+  })
+
+  const viewer_promise = run_viewer(viewer_path, {
     port: 1234,
-    data_folder_path: path.join(__dirname, "..", "..", "..", "data"),
+    data_folder_path,
   })
 
+  const [back_port, viewer_port] = await Promise.all([
+    back_promise,
+    viewer_promise,
+  ])
+  console.log("Viewer path:", viewer_path)
+  geodeStore.default_local_port = back_port
   viewerStore.default_local_port = viewer_port
   await viewerStore.ws_connect()
-  await dataBaseStore.registerObject(id, file_name, object_type)
-  await dataStyleStore.addDataStyle(id, geode_object, object_type)
+  console.log("schema", back_schemas.opengeodeweb_back.save_viewable_file)
+
+  const response = await api_fetch({
+    schema: back_schemas.opengeodeweb_back.save_viewable_file,
+    params: {
+      input_geode_object: geode_object,
+      filename: file_name,
+    },
+  })
+  id = response.data.value.id
+
+  await dataBaseStore.registerObject(id, "mesh")
+  await dataStyleStore.addDataStyle(id, geode_object, "mesh")
+
   expect(viewerStore.status).toBe(Status.CONNECTED)
 }, 15000)
 
-describe("Mesh edges", () => {
-  afterEach(async () => {
-    await kill_processes()
-  })
+afterEach(async () => {
+  const viewerStore = useViewerStore()
+  const geodeStore = useGeodeStore()
+  await Promise.all([
+    kill_viewer(viewerStore.default_local_port),
+    kill_back(geodeStore.default_local_port),
+  ])
+})
 
+describe("Mesh edges", () => {
   describe("Edges visibility", () => {
     test("test visibility true", async () => {
       const dataStyleStore = useDataStyleStore()

package/utils/local.js

@@ -2,22 +2,15 @@
 import fs from "fs"
 import path from "path"
 import child_process from "child_process"
+import WebSocket from "ws"
 
 // Third party imports
 import pkg from "electron"
 const { app, dialog } = pkg
 import { getPort } from "get-port-please"
-import kill from "tree-kill"
 import isElectron from "is-electron"
-
-import { fileURLToPath } from "url"
-
-const __filename = fileURLToPath(import.meta.url) // get the resolved path to the file
-const __dirname = path.dirname(__filename) // get the name of the directory
-console.log("__dirname", __dirname)
-
-// Global variables
-var processes = []
+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" }
 
 function venv_script_path(root_path, microservice_path) {
   const venv_path = path.join(root_path, microservice_path, "venv")
@@ -30,15 +23,16 @@ function venv_script_path(root_path, microservice_path) {
   return script_path
 }
 
-function executable_path(microservice_path, root_path = null) {
-  if (root_path != null) return venv_script_path(root_path, microservice_path)
+function executable_path(microservice_path) {
   if (isElectron()) {
     if (app.isPackaged) {
       return process.resourcesPath
+    } else {
+      return venv_script_path(app.getAppPath(), microservice_path)
     }
-    return venv_script_path(app.getAppPath(), microservice_path)
+  } else {
+    return venv_script_path(process.cwd(), microservice_path)
   }
-  return venv_script_path(process.cwd(), microservice_path)
 }
 
 function executable_name(name) {
@@ -50,40 +44,21 @@ function executable_name(name) {
 
 function create_path(path) {
   if (!fs.existsSync(path)) {
-    fs.mkdir(path, (err) => {
-      if (err) {
-        return console.error(err)
-      }
-      console.log(`${path} directory created successfully!`)
-    })
+    fs.mkdirSync(path, { recursive: true })
+    console.log(`${path} directory created successfully!`)
   }
   return path
 }
 
 async function get_available_port(port) {
-  const available_port = await getPort({ port, host: "localhost" })
+  const available_port = await getPort({
+    port,
+    host: "localhost",
+  })
   console.log("available_port", available_port)
   return available_port
 }
 
-async function kill_processes() {
-  console.log("kill_processes", processes)
-  await processes.forEach(async function (proc) {
-    console.log(`Process ${proc} will be killed!`)
-    try {
-      kill(proc)
-    } catch (error) {
-      console.log(`${error} Process ${proc} could not be killed!`)
-    }
-  })
-}
-
-function register_process(proc) {
-  if (!processes.includes(proc.pid)) {
-    processes.push(proc.pid)
-  }
-}
-
 async function run_script(
   command,
   args,
@@ -98,7 +73,6 @@ async function run_script(
       encoding: "utf8",
       shell: true,
     })
-    register_process(child)
 
     // You can also use a variable to save the output for when the script closes later
     child.stderr.setEncoding("utf8")
@@ -118,7 +92,7 @@ async function run_script(
       }
       console.log(data)
     })
-    child.stderr.setEncoding("utf8")
+
     child.stderr.on("data", (data) => {
       console.log(data)
     })
@@ -131,28 +105,27 @@ async function run_script(
       console.log("Child Process killed")
     })
     child.name = command.replace(/^.*[\\/]/, "")
+    return child
   })
 }
 
-async function run_back(port, data_folder_path) {
+async function run_back(command, args = { port, data_folder_path }) {
   return new Promise(async (resolve, reject) => {
-    const back_command = path.join(
-      executable_path(path.join("microservices", "back")),
-      executable_name("vease-back"),
-    )
-    const back_port = await get_available_port(port)
+    const back_port = await get_available_port(args.port)
+    const upload_folder_path = path.join(args.data_folder_path, "uploads")
     const back_args = [
       "--port " + back_port,
-      "--data_folder_path " + data_folder_path,
+      "--data_folder_path " + args.data_folder_path,
+      "--upload_folder_path " + upload_folder_path,
       "--allowed_origin http://localhost:*",
       "--timeout " + 0,
     ]
-    await run_script(back_command, back_args, "Serving Flask app")
+    await run_script(command, back_args, "Serving Flask app")
     resolve(back_port)
   })
 }
 
-async function run_viewer(viewer_path, args = { port, data_folder_path }) {
+async function run_viewer(command, args = { port, data_folder_path }) {
   return new Promise(async (resolve, reject) => {
     const viewer_port = await get_available_port(args.port)
     const viewer_args = [
@@ -160,19 +133,161 @@ async function run_viewer(viewer_path, args = { port, data_folder_path }) {
       "--data_folder_path " + args.data_folder_path,
       "--timeout " + 0,
     ]
-    await run_script(viewer_path, viewer_args, "Starting factory")
+    await run_script(command, viewer_args, "Starting factory")
     resolve(viewer_port)
   })
 }
 
+function delete_folder_recursive(data_folder_path) {
+  if (!fs.existsSync(data_folder_path)) {
+    console.log(`Folder ${data_folder_path} does not exist.`)
+    return
+  }
+  try {
+    fs.rmSync(data_folder_path, { recursive: true, force: true })
+    console.log(`Deleted folder: ${data_folder_path}`)
+  } catch (err) {
+    console.error(`Error deleting folder ${data_folder_path}:`, err)
+  }
+}
+
+function kill_back(back_port) {
+  return new Promise((resolve, reject) => {
+    console.log("back_schemas", back_schemas)
+
+    fetch(
+      "http://localhost:" +
+        back_port +
+        "/" +
+        back_schemas.opengeodeweb_back.kill.$id,
+      {
+        method: back_schemas.opengeodeweb_back.kill.methods[0],
+      },
+    )
+      .then(() => {
+        console.log("Back not killed")
+        reject()
+      })
+      .catch(() => {
+        console.log("Back closed")
+        resolve()
+      })
+  })
+}
+
+function kill_viewer(viewer_port) {
+  return new Promise((resolve, reject) => {
+    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) => {
+      const message = data.toString()
+      console.log("Received from server:", message)
+      if (message.includes("hello")) {
+        try {
+          console.log("viewer_schemas", viewer_schemas)
+          socket.send(
+            JSON.stringify({
+              id: viewer_schemas.opengeodeweb_viewer.kill.$id,
+              method: viewer_schemas.opengeodeweb_viewer.kill.$id,
+            }),
+          )
+        } catch (error) {
+          console.error("WebSocket error:", error)
+          resolve()
+        }
+      }
+    })
+    socket.on("close", () => {
+      console.log("Disconnected from WebSocket server")
+      resolve()
+    })
+    socket.on("error", (error) => {
+      console.error("WebSocket error:", error)
+      resolve()
+    })
+  })
+}
+
+async function run_browser(
+  script_name,
+  microservices_options = {
+    back: { command, args: { port: 5000, data_folder_path } },
+    viewer: { command, args: { port: 1234, data_folder_path } },
+  },
+) {
+  console.log("microservices_options", microservices_options)
+  const back_promise = run_back(microservices_options.back.command, {
+    ...microservices_options.back.args,
+  })
+  console.log("back_promise", back_promise)
+
+  const viewer_promise = run_viewer(microservices_options.viewer.command, {
+    ...microservices_options.viewer.args,
+  })
+  console.log("viewer_promise", viewer_promise)
+
+  const [back_port, viewer_port] = await Promise.all([
+    back_promise,
+    viewer_promise,
+  ])
+  process.env.GEODE_PORT = back_port
+  process.env.VIEWER_PORT = viewer_port
+  console.log("back_port", back_port)
+  console.log("viewer_port", viewer_port)
+
+  process.env.BROWSER = true
+  process.on("SIGINT", async () => {
+    console.log("Shutting down microservices")
+    await Promise.all([
+      kill_back(process.env.GEODE_PORT),
+      kill_viewer(process.env.VIEWER_PORT),
+    ])
+    console.log("Quitting App...")
+    process.exit(0)
+  })
+
+  const nuxt_port = await get_available_port()
+  console.log("nuxt_port", nuxt_port)
+
+  process.env.NUXT_PORT = nuxt_port
+  const nuxt_process = child_process.spawn("npm", ["run", script_name], {
+    shell: true,
+  })
+
+  return new Promise((resolve, reject) => {
+    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) {
+        resolve(portMatch[1])
+        return
+      }
+    })
+  })
+}
+
 export {
   create_path,
+  delete_folder_recursive,
   executable_name,
   executable_path,
   get_available_port,
-  kill_processes,
-  register_process,
+  kill_back,
+  kill_viewer,
   run_script,
   run_back,
   run_viewer,
+  run_browser,
 }