@geode/opengeodeweb-front 10.0.2-rc.1 → 10.0.2-rc.3

package/app/stores/geode.js

@@ -1,6 +1,7 @@
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 import Status from "@ogw_front/utils/status.js"
 import { appMode } from "@ogw_front/utils/app_mode.js"
+import { api_fetch } from "../../internal/utils/api_fetch.js"
 
 export const useGeodeStore = defineStore("geode", {
   state: () => ({
@@ -49,7 +50,7 @@ export const useGeodeStore = defineStore("geode", {
       }, 10 * 1000)
     },
     do_ping() {
-      const geode_store = this
+      const geodeStore = this
       const feedback_store = useFeedbackStore()
       return useFetch(back_schemas.opengeodeweb_back.ping.$id, {
         baseURL: this.base_url,
@@ -57,17 +58,17 @@ export const useGeodeStore = defineStore("geode", {
         body: {},
         onRequestError({ error }) {
           feedback_store.$patch({ server_error: true })
-          geode_store.status = Status.NOT_CONNECTED
+          geodeStore.status = Status.NOT_CONNECTED
         },
         onResponse({ response }) {
           if (response.ok) {
             feedback_store.$patch({ server_error: false })
-            geode_store.status = Status.CONNECTED
+            geodeStore.status = Status.CONNECTED
           }
         },
         onResponseError({ response }) {
           feedback_store.$patch({ server_error: true })
-          geode_store.status = Status.NOT_CONNECTED
+          geodeStore.status = Status.NOT_CONNECTED
         },
       })
     },
@@ -77,6 +78,31 @@ export const useGeodeStore = defineStore("geode", {
     stop_request() {
       this.request_counter--
     },
+    launch() {
+      console.log("[GEODE] Launching geode microservice...")
+      return window.electronAPI.run_back()
+    },
+    connect() {
+      console.log("[GEODE] Connecting to geode microservice...")
+      return this.do_ping()
+    },
+    request(schema, params, callbacks = {}) {
+      console.log("[GEODE] Request:", schema.$id)
+
+      return api_fetch(
+        this,
+        { schema, params },
+        {
+          ...callbacks,
+          response_function: async (response) => {
+            console.log("[GEODE] Request completed:", schema.$id)
+            if (callbacks.response_function) {
+              await callbacks.response_function(response)
+            }
+          },
+        },
+      )
+    },
   },
   share: {
     omit: ["status"],

package/app/stores/hybrid_viewer.js

@@ -6,6 +6,7 @@ import vtkActor from "@kitware/vtk.js/Rendering/Core/Actor"
 
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 import Status from "@ogw_front/utils/status.js"
+import { viewer_call } from "../../internal/utils/viewer_call.js"
 
 export const useHybridViewerStore = defineStore("hybridViewer", () => {
   const viewerStore = useViewerStore()
@@ -91,11 +92,9 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
     genericRenderWindow.value.getRenderWindow().render()
     const schema = viewer_schemas?.opengeodeweb_viewer?.viewer?.set_z_scaling
     if (!schema) return
-    await viewer_call({
-      schema,
-      params: {
-        z_scale: z_scale,
-      },
+    const viewerStore = useViewerStore()
+    await viewerStore.request(schema, {
+      z_scale: z_scale,
     })
     remoteRender()
   }
@@ -114,11 +113,10 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
         distance: camera.getDistance(),
       },
     }
-    viewer_call(
-      {
-        schema: viewer_schemas.opengeodeweb_viewer.viewer.update_camera,
-        params,
-      },
+    const viewerStore = useViewerStore()
+    viewerStore.request(
+      viewer_schemas.opengeodeweb_viewer.viewer.update_camera,
+      params,
       {
         response_function: () => {
           remoteRender()
@@ -131,9 +129,8 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
   }
 
   function remoteRender() {
-    viewer_call({
-      schema: viewer_schemas.opengeodeweb_viewer.viewer.render,
-    })
+    const viewerStore = useViewerStore()
+    viewerStore.request(viewer_schemas.opengeodeweb_viewer.viewer.render)
   }
 
   function setContainer(container) {
@@ -216,6 +213,10 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
   }
 
   const importStores = (snapshot) => {
+    if (!snapshot) {
+      console.warn("importStores called with undefined snapshot")
+      return
+    }
     const z_scale = snapshot.zScale
 
     const applyCamera = () => {
@@ -244,11 +245,10 @@ export const useHybridViewerStore = defineStore("hybridViewer", () => {
           clipping_range: camera_options.clipping_range,
         },
       }
-      return viewer_call(
-        {
-          schema: viewer_schemas.opengeodeweb_viewer.viewer.update_camera,
-          params: payload,
-        },
+      const viewerStore = useViewerStore()
+      return viewerStore.request(
+        viewer_schemas.opengeodeweb_viewer.viewer.update_camera,
+        payload,
         {
           response_function: () => {
             remoteRender()

package/app/stores/infra.js

@@ -1,13 +1,13 @@
-import { useStorage } from "@vueuse/core"
 import Status from "@ogw_front/utils/status.js"
 import { appMode, getAppMode } from "@ogw_front/utils/app_mode.js"
 
 export const useInfraStore = defineStore("infra", {
   state: () => ({
     app_mode: getAppMode(),
-    ID: useStorage("ID", ""),
+    ID: "",
     is_captcha_validated: false,
     status: Status.NOT_CREATED,
+    microservices: [],
   }),
   getters: {
     domain_name() {
@@ -16,69 +16,84 @@ export const useInfraStore = defineStore("infra", {
       }
       return "localhost"
     },
-    lambda_url() {
-      const geode_store = useGeodeStore()
-      const public_runtime_config = useRuntimeConfig().public
-      const url =
-        geode_store.protocol +
-        "://" +
-        this.domain_name +
-        ":" +
-        geode_store.port +
-        public_runtime_config.SITE_BRANCH +
-        public_runtime_config.PROJECT +
-        "/createbackend"
-      return url
-    },
     microservices_connected() {
-      return (
-        useGeodeStore().status == Status.CONNECTED &&
-        useViewerStore().status == Status.CONNECTED
+      return this.microservices.every(
+        (store) => store.status === Status.CONNECTED,
       )
     },
     microservices_busy() {
-      return useGeodeStore().is_busy || useViewerStore().is_busy
+      return this.microservices.some((store) => store.is_busy === true)
     },
   },
   actions: {
+    register_microservice(store) {
+      const store_name = store.$id
+      console.log("[INFRA] Registering microservice:", store_name)
+
+      if (!this.microservices.find((store) => store.$id === store_name)) {
+        this.microservices.push(store)
+        console.log("[INFRA] Microservice registered:", store_name)
+      }
+    },
     async create_backend() {
-      console.log("create_backend this.app_mode", this.app_mode)
+      console.log("[INFRA] Starting create_backend - Mode:", this.app_mode)
+      console.log(
+        "[INFRA] Registered microservices:",
+        this.microservices.map((store) => store.$id),
+      )
+
       if (this.status === Status.CREATED) return
+
       return navigator.locks.request("infra.create_backend", async (lock) => {
         this.status = Status.CREATING
         if (this.status === Status.CREATED) return
-        console.log("LOCK GRANTED !", lock)
+        console.log("[INFRA] Lock granted for create_backend")
+
         if (this.app_mode == appMode.DESKTOP) {
-          const viewer_store = useViewerStore()
-          const geode_store = useGeodeStore()
-          const [back_port, viewer_port] = await Promise.all([
-            window.electronAPI.run_back(),
-            window.electronAPI.run_viewer(),
-          ])
-          geode_store.$patch({ default_local_port: back_port })
-          viewer_store.$patch({ default_local_port: viewer_port })
-        } else if (this.app_mode == appMode.CLOUD) {
-          const { data, error } = await useFetch(this.lambda_url, {
-            method: "POST",
+          console.log("[INFRA] DESKTOP mode - Launching microservices...")
+          const microservices_with_launch = this.microservices.filter(
+            (store) => store.launch,
+          )
+
+          const port_promises = microservices_with_launch.map((store) =>
+            store.launch(),
+          )
+          const ports = await Promise.all(port_promises)
+
+          microservices_with_launch.forEach((store, index) => {
+            store.$patch({ default_local_port: ports[index] })
           })
-          if (error.value || !data.value) {
-            this.status = Status.NOT_CREATED
-            const feedback_store = useFeedbackStore()
-            feedback_store.server_error = true
-            return
-          }
-          this.ID = data.value.ID
-          localStorage.setItem("ID", data.value.ID)
+        } else if (this.app_mode == appMode.CLOUD) {
+          console.log("[INFRA] CLOUD mode - Launching lambda...")
+          const lambdaStore = useLambdaStore()
+          this.ID = await lambdaStore.launch()
+          console.log("[INFRA] Lambda launched successfully")
         }
+
         this.status = Status.CREATED
+        console.log("[INFRA] Backend created successfully")
         return this.create_connection()
       })
     },
     async create_connection() {
-      console.log("create_connection")
-      await useViewerStore().ws_connect()
-      await useGeodeStore().do_ping()
+      console.log("[INFRA] Starting create_connection")
+      console.log(
+        "[INFRA] Connecting microservices:",
+        this.microservices.map((store) => store.$id),
+      )
+
+      const connection_promises = this.microservices.map((store) => {
+        return store.connect().then(() => {
+          console.log("[INFRA] Microservice connected:", store.$id)
+        })
+      })
+
+      await Promise.all(connection_promises)
+      console.log("[INFRA] All microservices connected")
       return
     },
   },
+  share: {
+    omit: ["microservices"],
+  },
 })

package/app/stores/lambda.js

@@ -0,0 +1,63 @@
+import Status from "@ogw_front/utils/status.js"
+
+export const useLambdaStore = defineStore("lambda", {
+  state: () => ({
+    status: Status.NOT_CONNECTED,
+  }),
+  getters: {
+    protocol() {
+      return "https"
+    },
+    port() {
+      return "443"
+    },
+    base_url() {
+      const public_runtime_config = useRuntimeConfig().public
+      const domain_name = public_runtime_config.API_URL
+      const url =
+        this.protocol +
+        "://" +
+        domain_name +
+        ":" +
+        this.port +
+        public_runtime_config.SITE_BRANCH +
+        public_runtime_config.PROJECT +
+        "/createbackend"
+      return url
+    },
+    is_busy() {
+      return false
+    },
+  },
+  actions: {
+    async launch() {
+      console.log("[LAMBDA] Launching lambda backend...")
+      const feedbackStore = useFeedbackStore()
+
+      const { data, error } = await useFetch(this.base_url, {
+        method: "POST",
+      })
+
+      if (error.value || !data.value) {
+        this.status = Status.NOT_CONNECTED
+        feedbackStore.server_error = true
+        console.error("[LAMBDA] Failed to launch lambda backend", error.value)
+        throw new Error("Failed to launch lambda backend")
+      }
+
+      this.status = Status.CONNECTED
+      const id = data.value.ID
+
+      console.log("[LAMBDA] Lambda launched, ID:", id)
+      return id
+    },
+    async connect() {
+      console.log("[LAMBDA] Lambda connected")
+      this.status = Status.CONNECTED
+      return Promise.resolve()
+    },
+  },
+  share: {
+    omit: ["status"],
+  },
+})

package/app/stores/viewer.js

@@ -4,6 +4,7 @@ import "@kitware/vtk.js/Rendering/OpenGL/Profiles/Geometry"
 import schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
 import Status from "@ogw_front/utils/status.js"
 import { appMode } from "@ogw_front/utils/app_mode.js"
+import { viewer_call } from "../../internal/utils/viewer_call.js"
 
 export const useViewerStore = defineStore("viewer", {
   state: () => ({
@@ -107,25 +108,23 @@ export const useViewerStore = defineStore("viewer", {
         // Connect
         const { connectImageStream } =
           await import("@kitware/vtk.js/Rendering/Misc/RemoteView")
-        const viewer_store = this
+        const viewerStore = this
         return new Promise((resolve, reject) => {
           clientToConnect
             .connect(config)
             .then((validClient) => {
               connectImageStream(validClient.getConnection().getSession())
-              viewer_store.client = validClient
+              viewerStore.client = validClient
               clientToConnect.endBusy()
-
-              // Now that the client is ready let's setup the server for us
-              viewer_call({
+              viewer_call(viewerStore, {
                 schema: schemas.opengeodeweb_viewer.viewer.reset_visualization,
               })
-              viewer_store.status = Status.CONNECTED
+              viewerStore.status = Status.CONNECTED
               resolve()
             })
             .catch((error) => {
               console.error("error", error)
-              viewer_store.status = Status.NOT_CONNECTED
+              viewerStore.status = Status.NOT_CONNECTED
               reject(error)
             })
         })
@@ -137,6 +136,34 @@ export const useViewerStore = defineStore("viewer", {
     stop_request() {
       this.request_counter--
     },
+    async launch() {
+      console.log("[VIEWER] Launching viewer microservice...")
+      const port = await window.electronAPI.run_viewer()
+      console.log("[VIEWER] Viewer launched on port:", port)
+      return port
+    },
+    async connect() {
+      console.log("[VIEWER] Connecting to viewer microservice...")
+      await this.ws_connect()
+      console.log("[VIEWER] Viewer connected successfully")
+    },
+    request(schema, params = {}, callbacks = {}) {
+      console.log("[VIEWER] Request:", schema.$id)
+
+      return viewer_call(
+        this,
+        { schema, params },
+        {
+          ...callbacks,
+          response_function: async (response) => {
+            console.log("[VIEWER] Request completed:", schema.$id)
+            if (callbacks.response_function) {
+              await callbacks.response_function(response)
+            }
+          },
+        },
+      )
+    },
   },
   share: {
     omit: ["status", "client"],

package/app/utils/file_import_workflow.js

@@ -57,18 +57,19 @@ async function importItem(item) {
 }
 
 async function importFile(filename, geode_object_type) {
-  const { data } = await api_fetch({
-    schema: back_schemas.opengeodeweb_back.save_viewable_file,
-    params: {
+  const geodeStore = useGeodeStore()
+  const response = await geodeStore.request(
+    back_schemas.opengeodeweb_back.save_viewable_file,
+    {
       geode_object_type,
       filename,
     },
-  })
-
-  console.log("data.value", data.value)
-  console.log("data.value", data._value)
+  )
 
-  const item = buildImportItemFromPayloadApi(data.value, geode_object_type)
+  const item = buildImportItemFromPayloadApi(
+    response.data.value,
+    geode_object_type,
+  )
   return importItem(item)
 }
 

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

@@ -3,7 +3,7 @@ export async function upload_file(
   { request_error_function, response_function, response_error_function } = {},
 ) {
   const feedback_store = useFeedbackStore()
-  const geode_store = useGeodeStore()
+  const geodeStore = useGeodeStore()
   if (!(file instanceof File)) {
     throw new Error("file must be a instance of File")
   }
@@ -16,12 +16,12 @@ export async function upload_file(
     body: body,
   }
 
-  geode_store.start_request()
+  geodeStore.start_request()
   return $fetch(route, {
-    baseURL: geode_store.base_url,
+    baseURL: geodeStore.base_url,
     ...request_options,
     onRequestError({ error }) {
-      geode_store.stop_request()
+      geodeStore.stop_request()
       feedback_store.add_error(error.code, route, error.message, error.stack)
       if (request_error_function) {
         request_error_function(error)
@@ -29,14 +29,14 @@ export async function upload_file(
     },
     onResponse({ response }) {
       if (response.ok) {
-        geode_store.stop_request()
+        geodeStore.stop_request()
         if (response_function) {
           response_function(response)
         }
       }
     },
     onResponseError({ response }) {
-      geode_store.stop_request()
+      geodeStore.stop_request()
       feedback_store.add_error(
         response.status,
         route,

package/{internal_stores → internal/stores}/mesh/cells.js

@@ -3,7 +3,6 @@ import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schem
 
 // Local constants
 const mesh_cells_schemas = viewer_schemas.opengeodeweb_viewer.mesh.cells
-
 export function useMeshCellsStyle() {
   const dataStyleStore = useDataStyleStore()
 
@@ -16,8 +15,10 @@ export function useMeshCellsStyle() {
   }
   function setMeshCellsVisibility(id, visibility) {
     const cells_style = meshCellsStyle(id)
-    return viewer_call(
-      { schema: mesh_cells_schemas.visibility, params: { id, visibility } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_cells_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           cells_style.visibility = visibility
@@ -36,8 +37,10 @@ export function useMeshCellsStyle() {
   }
   function setMeshCellsColor(id, color) {
     const coloring_style = meshCellsStyle(id).coloring
-    return viewer_call(
-      { schema: mesh_cells_schemas.color, params: { id, color } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_cells_schemas.color,
+      { id, color },
       {
         response_function: () => {
           coloring_style.color = color
@@ -56,11 +59,10 @@ export function useMeshCellsStyle() {
   }
   function setMeshCellsTextures(id, textures) {
     const coloring_style = meshCellsStyle(id).coloring
-    return viewer_call(
-      {
-        schema: mesh_cells_schemas.apply_textures,
-        params: { id, textures },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_cells_schemas.apply_textures,
+      { id, textures },
       {
         response_function: () => {
           coloring_style.textures = textures
@@ -76,11 +78,10 @@ export function useMeshCellsStyle() {
 
   function setMeshCellsVertexAttribute(id, vertex_attribute) {
     const coloring_style = meshCellsStyle(id).coloring
-    return viewer_call(
-      {
-        schema: mesh_cells_schemas.vertex_attribute,
-        params: { id, ...vertex_attribute },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_cells_schemas.vertex_attribute,
+      { id, ...vertex_attribute },
       {
         response_function: () => {
           coloring_style.vertex = vertex_attribute
@@ -99,11 +100,10 @@ export function useMeshCellsStyle() {
   }
   function setMeshCellsCellAttribute(id, cell_attribute) {
     const coloring_style = meshCellsStyle(id).coloring
-    return viewer_call(
-      {
-        schema: mesh_cells_schemas.cell_attribute,
-        params: { id, ...cell_attribute },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_cells_schemas.cell_attribute,
+      { id, ...cell_attribute },
       {
         response_function: () => {
           coloring_style.cell = cell_attribute

package/{internal_stores → internal/stores}/mesh/edges.js

@@ -15,8 +15,10 @@ export function useMeshEdgesStyle() {
     return meshEdgesStyle(id).visibility
   }
   function setMeshEdgesVisibility(id, visibility) {
-    return viewer_call(
-      { schema: mesh_edges_schemas.visibility, params: { id, visibility } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_edges_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           meshEdgesStyle(id).visibility = visibility
@@ -57,8 +59,10 @@ export function useMeshEdgesStyle() {
   }
   function setMeshEdgesColor(id, color) {
     const coloring_style = meshEdgesStyle(id).coloring
-    return viewer_call(
-      { schema: mesh_edges_schemas.color, params: { id, color } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_edges_schemas.color,
+      { id, color },
       {
         response_function: () => {
           coloring_style.color = color
@@ -77,8 +81,10 @@ export function useMeshEdgesStyle() {
   }
   function setMeshEdgesWidth(id, width) {
     const edges_style = meshEdgesStyle(id)
-    return viewer_call(
-      { schema: mesh_edges_schemas.width, params: { id, width } },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_edges_schemas.width,
+      { id, width },
       {
         response_function: () => {
           edges_style.width = width

package/{internal_stores → internal/stores}/mesh/index.js

@@ -24,11 +24,10 @@ export default function useMeshStyle() {
     return dataStyleStore.getStyle(id).visibility
   }
   function setMeshVisibility(id, visibility) {
-    return viewer_call(
-      {
-        schema: mesh_schemas.visibility,
-        params: { id, visibility },
-      },
+    const viewerStore = useViewerStore()
+    return viewerStore.request(
+      mesh_schemas.visibility,
+      { id, visibility },
       {
         response_function: () => {
           hybridViewerStore.setVisibility(id, visibility)