@geode/opengeodeweb-front 10.5.1 → 10.6.0

package/app/components/FileUploader.vue

@@ -1,9 +1,6 @@
 <script setup>
   import DragAndDrop from "@ogw_front/components/DragAndDrop"
-  import schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
-  import { upload_file } from "@ogw_front/utils/upload_file"
-
-  const schema = schemas.opengeodeweb_back.upload_file
+  import { useGeodeStore } from "@ogw_front/stores/geode"
 
   const emit = defineEmits(["files_uploaded", "decrement_step", "reset_values"])
 
@@ -15,6 +12,8 @@
     mini: { type: Boolean, required: false, default: false },
   })
 
+  const geodeStore = useGeodeStore()
+
   const internal_files = ref(files)
   const loading = ref(false)
   const files_uploaded = ref(false)
@@ -40,7 +39,7 @@
   async function upload_files() {
     toggle_loading()
     const promise_array = internal_files.value.map((file) =>
-      upload_file({ route: schema.$id, file }),
+      geodeStore.upload(file),
     )
     await Promise.all(promise_array)
     files_uploaded.value = true

package/app/stores/app.js

@@ -1,3 +1,6 @@
+import { upload_file } from "@ogw_internal/utils/upload_file.js"
+import { api_fetch } from "@ogw_internal/utils/api_fetch.js"
+
 export const useAppStore = defineStore("app", () => {
   const stores = []
 
@@ -108,8 +111,7 @@ export const useAppStore = defineStore("app", () => {
         })
         finalURL = URL.createObjectURL(newBlob)
       }
-
-      const extensionModule = await import(finalURL)
+      const extensionModule = await import(/* @vite-ignore */ finalURL)
 
       if (finalURL !== path && finalURL.startsWith("blob:")) {
         URL.revokeObjectURL(finalURL)
@@ -145,7 +147,6 @@ export const useAppStore = defineStore("app", () => {
         loadedExtensions.value.set(extensionId, extensionData)
 
         console.log(`[AppStore] Extension loaded successfully: ${extensionId}`)
-
         return extensionModule
       } else {
         throw new Error("Extension must export an install function")
@@ -217,6 +218,76 @@ export const useAppStore = defineStore("app", () => {
     return getExtension(id)?.enabled ?? false
   }
 
+  function upload(file, callbacks = {}) {
+    const route = "/api/extensions/upload"
+    const store = useAppStore()
+    return upload_file(
+      store,
+      { route, file },
+      {
+        ...callbacks,
+        response_function: async (response) => {
+          console.log("[APP] Request completed:", route)
+          if (callbacks.response_function) {
+            await callbacks.response_function(response)
+          }
+        },
+      },
+    )
+  }
+
+  function request(schema, params, callbacks = {}) {
+    console.log("[APP] Request:", schema.$id)
+
+    const store = useAppStore()
+    return api_fetch(
+      store,
+      { schema, params },
+      {
+        ...callbacks,
+        response_function: async (response) => {
+          console.log("[APP] Request completed:", schema.$id)
+          if (callbacks.response_function) {
+            await callbacks.response_function(response)
+          }
+        },
+      },
+    )
+  }
+
+  const request_counter = ref(0)
+  function start_request() {
+    request_counter.value += 1
+  }
+  function stop_request() {
+    request_counter.value -= 1
+  }
+
+  const projectFolderPath = ref("")
+  function createProjectFolder() {
+    const { PROJECT } = useRuntimeConfig().public
+    const schema = {
+      $id: "/api/app/project_folder_path",
+      methods: ["POST"],
+      type: "object",
+      properties: {
+        PROJECT: { type: "string" },
+      },
+      required: ["PROJECT"],
+      additionalProperties: true,
+    }
+    const params = { PROJECT }
+
+    console.log(createProjectFolder.name, { PROJECT })
+
+    return request(schema, params, {
+      response_function: async (response) => {
+        console.log(`[APP] ${response.projectFolderPath} created`)
+        projectFolderPath.value = response.projectFolderPath
+      },
+    })
+  }
+
   return {
     stores,
     registerStore,
@@ -233,5 +304,11 @@ export const useAppStore = defineStore("app", () => {
     toggleExtension,
     setExtensionEnabled,
     getExtensionEnabled,
+    request,
+    upload,
+    projectFolderPath,
+    createProjectFolder,
+    start_request,
+    stop_request,
   }
 })

package/app/stores/geode.js

@@ -4,6 +4,8 @@ import { appMode } from "@ogw_front/utils/app_mode"
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json"
 import { useFeedbackStore } from "@ogw_front/stores/feedback"
 import { useInfraStore } from "@ogw_front/stores/infra"
+import { useAppStore } from "@ogw_front/stores/app"
+import { upload_file } from "@ogw_internal/utils/upload_file.js"
 
 const MILLISECONDS_IN_SECOND = 1000
 const DEFAULT_PING_INTERVAL_SECONDS = 10
@@ -25,10 +27,6 @@ export const useGeodeStore = defineStore("geode", {
       if (useInfraStore().app_mode === appMode.CLOUD) {
         return "443"
       }
-      const { GEODE_PORT } = useRuntimeConfig().public
-      if (GEODE_PORT !== null && GEODE_PORT !== "") {
-        return GEODE_PORT
-      }
       return this.default_local_port
     },
     base_url() {
@@ -81,9 +79,39 @@ export const useGeodeStore = defineStore("geode", {
     stop_request() {
       this.request_counter -= 1
     },
-    launch() {
-      console.log("[GEODE] Launching geode microservice...")
-      return globalThis.electronAPI.run_back()
+    launch(args) {
+      console.log("[GEODE] Launching back microservice...", { args })
+      const appStore = useAppStore()
+
+      const { BACK_PATH, BACK_COMMAND } = useRuntimeConfig().public
+
+      console.log("[GEODE] BACK_PATH", BACK_PATH)
+      console.log("[GEODE] BACK_COMMAND", BACK_COMMAND)
+      const schema = {
+        $id: "/api/app/run_back",
+        methods: ["POST"],
+        type: "object",
+        properties: {
+          BACK_PATH: { type: "string" },
+          BACK_COMMAND: { type: "string" },
+        },
+        required: ["BACK_PATH", "BACK_COMMAND"],
+        additionalProperties: true,
+      }
+
+      const params = {
+        BACK_PATH,
+        BACK_COMMAND,
+        args,
+      }
+
+      console.log("[GEODE] params", params)
+      return appStore.request(schema, params, {
+        response_function: (response) => {
+          console.log(`[GEODE] Back launched on port ${response.port}`)
+          this.default_local_port = response.port
+        },
+      })
     },
     connect() {
       console.log("[GEODE] Connecting to geode microservice...")
@@ -114,6 +142,25 @@ export const useGeodeStore = defineStore("geode", {
         },
       )
     },
+    upload(file, callbacks = {}) {
+      const route = back_schemas.opengeodeweb_back.upload_file.$id
+      return upload_file(
+        this,
+        {
+          route,
+          file,
+        },
+        {
+          ...callbacks,
+          response_function: async (response) => {
+            console.log("[GEODE] Request completed:", route)
+            if (callbacks.response_function) {
+              await callbacks.response_function(response)
+            }
+          },
+        },
+      )
+    },
   },
   share: {
     omit: ["status"],

package/app/stores/infra.js

@@ -1,6 +1,9 @@
 import { appMode, getAppMode } from "@ogw_front/utils/app_mode"
 import { Status } from "@ogw_front/utils/status"
 import { useLambdaStore } from "@ogw_front/stores/lambda"
+import { useAppStore } from "@ogw_front/stores/app"
+
+import { registerRunningExtensions } from "@ogw_front/utils/extension"
 
 export const useInfraStore = defineStore("infra", {
   state: () => ({
@@ -59,25 +62,33 @@ export const useInfraStore = defineStore("infra", {
         }
         console.log("[INFRA] Lock granted for create_backend")
 
-        if (this.app_mode === appMode.DESKTOP) {
-          console.log("[INFRA] DESKTOP mode - Launching microservices...")
+        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")
+        } else {
+          console.log(
+            `[INFRA] ${this.app_mode} mode - Launching microservices...`,
+          )
+
+          const appStore = useAppStore()
+          await appStore.createProjectFolder()
+
+          if (this.app_mode === appMode.DESKTOP) {
+            globalThis.electronAPI.project_folder_path({
+              projectFolderPath: appStore.projectFolderPath,
+            })
+          }
+
           const microservices_with_launch = this.microservices.filter(
             (store) => store.launch,
           )
 
-          const port_promises = microservices_with_launch.map((store) =>
-            store.launch(),
+          const launch_promises = microservices_with_launch.map((store) =>
+            store.launch({ projectFolderPath: appStore.projectFolderPath }),
           )
-          const ports = await Promise.all(port_promises)
-
-          for (const [index, store] of microservices_with_launch.entries()) {
-            store.$patch({ default_local_port: ports[index] })
-          }
-        } 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")
+          await Promise.all(launch_promises, registerRunningExtensions())
         }
 
         this.status = Status.CREATED

package/app/stores/lambda.js

@@ -15,7 +15,8 @@ export const useLambdaStore = defineStore("lambda", {
     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`
+      const projectPath = `/${public_runtime_config.PROJECT}`
+      const url = `${this.protocol}://${domain_name}:${this.port}${public_runtime_config.SITE_BRANCH}${projectPath}/createbackend`
       return url
     },
     is_busy() {

package/app/stores/viewer.js

@@ -1,3 +1,4 @@
+// Third party imports
 import vtkWSLinkClient, {
   newInstance,
 } from "@kitware/vtk.js/IO/Core/WSLinkClient"
@@ -5,9 +6,13 @@ import vtkWSLinkClient, {
 import _ from "lodash"
 // oxlint-disable-next-line no-unassigned-import
 import "@kitware/vtk.js/Rendering/OpenGL/Profiles/Geometry"
+import schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import { useRuntimeConfig } from "nuxt/app"
+
+// Local imports
 import { Status } from "@ogw_front/utils/status"
 import { appMode } from "@ogw_front/utils/app_mode"
-import schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json"
+import { useAppStore } from "@ogw_front/stores/app"
 import { useInfraStore } from "@ogw_front/stores/infra"
 import { viewer_call } from "@ogw_internal/utils/viewer_call"
 
@@ -39,10 +44,6 @@ export const useViewerStore = defineStore(
       if (infraStore.app_mode === appMode.CLOUD) {
         return "443"
       }
-      const { VIEWER_PORT } = useRuntimeConfig().public
-      if (VIEWER_PORT !== undefined && VIEWER_PORT !== "") {
-        return VIEWER_PORT
-      }
       return default_local_port.value
     })
 
@@ -149,12 +150,40 @@ export const useViewerStore = defineStore(
       request_counter.value -= 1
     }
 
-    async function launch() {
-      status.value = Status.CREATING
-      console.log("[VIEWER] Launching viewer microservice...")
-      const launched_port = await globalThis.electronAPI.run_viewer()
-      console.log("[VIEWER] Viewer launched on port:", launched_port)
-      return launched_port
+    function launch(args = { projectFolderPath }) {
+      console.log("[VIEWER] Launching viewer microservice...", { args })
+      const appStore = useAppStore()
+
+      const { VIEWER_PATH, VIEWER_COMMAND } = useRuntimeConfig().public
+
+      console.log("[VIEWER] VIEWER_PATH", VIEWER_PATH)
+      console.log("[VIEWER] VIEWER_COMMAND", VIEWER_COMMAND)
+      const schema = {
+        $id: "/api/app/run_viewer",
+        methods: ["POST"],
+        type: "object",
+        properties: {
+          VIEWER_PATH: { type: "string" },
+          VIEWER_COMMAND: { type: "string" },
+        },
+        required: ["VIEWER_PATH", "VIEWER_COMMAND"],
+        additionalProperties: true,
+      }
+
+      const params = {
+        VIEWER_PATH,
+        VIEWER_COMMAND,
+        args,
+      }
+
+      console.log("[VIEWER] params", params)
+
+      return appStore.request(schema, params, {
+        response_function: (response) => {
+          console.log(`[VIEWER] Viewer launched on port ${response.port}`)
+          this.default_local_port = response.port
+        },
+      })
     }
 
     async function connect() {

package/app/utils/config.js

@@ -0,0 +1,45 @@
+// Node.js imports
+import path from "node:path"
+
+// Third party imports
+import Conf from "conf"
+
+// Local imports
+
+function projectConf(projectName) {
+  const projectConfig = new Conf({ projectName })
+  console.log(projectConf.name, { projectConfig })
+  return projectConfig
+}
+
+function confFolderPath(projectName) {
+  const projectConfig = projectConf(projectName)
+  return path.dirname(projectConfig.path)
+}
+
+function extensionsConf(projectName) {
+  const projectConfig = projectConf(projectName)
+  if (!projectConfig.has("extensions")) {
+    projectConfig.set("extensions", {})
+  }
+  const extensionsConfig = projectConfig.get("extensions")
+  return extensionsConfig
+}
+
+function addExtensionToConf(projectName, { extensionID, extensionPath }) {
+  const projectConfig = projectConf(projectName)
+  projectConfig.set(`extensions.${extensionID}.path`, extensionPath)
+}
+
+function extensionPathFromConf(projectName, extensionID) {
+  const projectConfig = projectConf(projectName)
+  return projectConfig.get(`extensions.${extensionID}.path`)
+}
+
+export {
+  confFolderPath,
+  projectConf,
+  extensionsConf,
+  addExtensionToConf,
+  extensionPathFromConf,
+}

package/app/utils/extension.js

@@ -0,0 +1,109 @@
+// Node.js imports
+
+// Third party imports
+import _ from "lodash"
+import { useRuntimeConfig } from "nuxt/app"
+
+// Local imports
+import { useAppStore } from "@ogw_front/stores/app"
+import { useInfraStore } from "@ogw_front/stores/infra"
+
+async function importExtensionFile(file) {
+  await uploadExtension(file)
+  return registerRunningExtensions()
+}
+
+async function registerRunningExtensions() {
+  const appStore = useAppStore()
+  const infraStore = useInfraStore()
+  const { extensionsArray } = await runExtensions()
+
+  for (const extension of extensionsArray) {
+    const { id, name, version, frontendContent, port } = extension
+    const blob = new Blob([frontendContent], {
+      type: "application/javascript",
+    })
+    const blobUrl = URL.createObjectURL(blob)
+    const extensionModule = await appStore.loadExtension(blobUrl)
+    console.log("[ExtensionManager] Extension loaded:", id)
+
+    if (extensionModule.metadata?.store) {
+      const storeFactory = extensionModule.metadata.store
+      const store = storeFactory()
+      store.$patch((state) => {
+        state.default_local_port = port
+      })
+      appStore.registerStore(store)
+      console.log("[ExtensionManager] Store registered:", store.$id)
+      await store.connect()
+      console.log("[ExtensionManager] Microservice connected:", store.$id)
+      infraStore.register_microservice(store)
+    }
+    return {
+      name,
+      version,
+      extensionModule,
+    }
+  }
+}
+
+async function unloadExtension(extensionId) {
+  const appStore = useAppStore()
+  console.log("[ExtensionManager] Unloading extension:", extensionId)
+
+  const extensionData = appStore.getExtension(extensionId)
+  if (!extensionData) {
+    console.warn("[ExtensionManager] Extension not found:", extensionId)
+    return false
+  }
+
+  // Get the store if it exists
+  const storeFactory = extensionData.metadata?.store
+  if (storeFactory) {
+    const store = storeFactory()
+    // Stop the microservice if possible
+    if (typeof store.kill === "function") {
+      await store.kill()
+    }
+  }
+
+  // Unload from AppStore
+  appStore.unloadExtension(extensionId)
+
+  console.log("[ExtensionManager] Extension unloaded:", extensionId)
+  return true
+}
+
+async function uploadExtension(file) {
+  const appStore = useAppStore()
+  await appStore.upload(file)
+}
+
+async function runExtensions() {
+  const appStore = useAppStore()
+  const projectFolderPath = appStore.projectFolderPath
+  const { PROJECT: projectName } = useRuntimeConfig().public
+  const params = { projectFolderPath, projectName }
+
+  const schema = {
+    $id: "/api/extensions/run",
+    methods: ["POST"],
+    type: "object",
+    properties: {
+      projectFolderPath: { type: "string" },
+      projectName: { type: "string" },
+    },
+    required: ["projectFolderPath", "projectName"],
+    additionalProperties: false,
+  }
+
+  return appStore.request(schema, params)
+}
+
+export {
+  importExtensionFile,
+  unloadExtension,
+  uploadExtension,
+  registerRunningExtensions,
+  runExtensions,
+}